    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.lang.exception;
    018
    019    import java.io.PrintStream;
    020    import java.io.PrintWriter;
    021
    022    /**
    023     * The base class of all errors which can contain other exceptions.
    024     *
    025     * @author Daniel L. Rall
    026     * @see org.apache.commons.lang.exception.NestableException
    027     * @since 1.0
    028     * @version $Id: NestableError.java 512889 2007-02-28 18:18:20Z dlr $
    029     */
    030    public class NestableError extends Error implements Nestable {
    031
    032        /**
    033         * Required for serialization support.
    034         *
    035         * @see java.io.Serializable
    036         */
    037        private static final long serialVersionUID = 1L;
    038
    039        /**
    040         * The helper instance which contains much of the code which we
    041         * delegate to.
    042         */
    043        protected NestableDelegate delegate = new NestableDelegate(this);
    044
    045        /**
    046         * Holds the reference to the exception or error that caused
    047         * this exception to be thrown.
    048         */
    049        private Throwable cause = null;
    050
    051        /**
    052         * Constructs a new <code>NestableError</code> without specified
    053         * detail message.
    054         */
    055        public NestableError() {
    056            super();
    057        }
    058
    059        /**
    060         * Constructs a new <code>NestableError</code> with specified
    061         * detail message.
    062         *
    063         * @param msg The error message.
    064         */
    065        public NestableError(String msg) {
    066            super(msg);
    067        }
    068
    069        /**
    070         * Constructs a new <code>NestableError</code> with specified
    071         * nested <code>Throwable</code>.
    072         *
    073         * @param cause the exception or error that caused this exception to be
    074         * thrown
    075         */
    076        public NestableError(Throwable cause) {
    077            super();
    078            this.cause = cause;
    079        }
    080
    081        /**
    082         * Constructs a new <code>NestableError</code> with specified
    083         * detail message and nested <code>Throwable</code>.
    084         *
    085         * @param msg    the error message
    086         * @param cause  the exception or error that caused this exception to be
    087         * thrown
    088         */
    089        public NestableError(String msg, Throwable cause) {
    090            super(msg);
    091            this.cause = cause;
    092        }
    093
    094        /**
    095         * {@inheritDoc}
    096         */
    097        public Throwable getCause() {
    098            return cause;
    099        }
    100
    101        /**
    102         * Returns the detail message string of this throwable. If it was
    103         * created with a null message, returns the following:
    104         * (cause==null ? null : cause.toString()).
    105         *
    106         * @return String message string of the throwable
    107         */
    108        public String getMessage() {
    109            if (super.getMessage() != null) {
    110                return super.getMessage();
    111            } else if (cause != null) {
    112                return cause.toString();
    113            } else {
    114                return null;
    115            }
    116        }
    117
    118        /**
    119         * {@inheritDoc}
    120         */
    121        public String getMessage(int index) {
    122            if (index == 0) {
    123                return super.getMessage();
    124            }
    125            return delegate.getMessage(index);
    126        }
    127
    128        /**
    129         * {@inheritDoc}
    130         */
    131        public String[] getMessages() {
    132            return delegate.getMessages();
    133        }
    134
    135        /**
    136         * {@inheritDoc}
    137         */
    138        public Throwable getThrowable(int index) {
    139            return delegate.getThrowable(index);
    140        }
    141
    142        /**
    143         * {@inheritDoc}
    144         */
    145        public int getThrowableCount() {
    146            return delegate.getThrowableCount();
    147        }
    148
    149        /**
    150         * {@inheritDoc}
    151         */
    152        public Throwable[] getThrowables() {
    153            return delegate.getThrowables();
    154        }
    155
    156        /**
    157         * {@inheritDoc}
    158         */
    159        public int indexOfThrowable(Class type) {
    160            return delegate.indexOfThrowable(type, 0);
    161        }
    162
    163        /**
    164         * {@inheritDoc}
    165         */
    166        public int indexOfThrowable(Class type, int fromIndex) {
    167            return delegate.indexOfThrowable(type, fromIndex);
    168        }
    169
    170        /**
    171         * {@inheritDoc}
    172         */
    173        public void printStackTrace() {
    174            delegate.printStackTrace();
    175        }
    176
    177        /**
    178         * {@inheritDoc}
    179         */
    180        public void printStackTrace(PrintStream out) {
    181            delegate.printStackTrace(out);
    182        }
    183
    184        /**
    185         * {@inheritDoc}
    186         */
    187        public void printStackTrace(PrintWriter out) {
    188            delegate.printStackTrace(out);
    189        }
    190
    191        /**
    192         * {@inheritDoc}
    193         */
    194        public final void printPartialStackTrace(PrintWriter out) {
    195            super.printStackTrace(out);
    196        }
    197    }