Axis 2 example source code file (SOAPException.java)

This example Axis 2 source code file (SOAPException.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Axis 2 tags/keywords

can't, exception, illegalargumentexception, illegalargumentexception, illegalstateexception, self-causation, soapexception, soapexception, string, string, throwable, throwable

The Axis 2 SOAPException.java source code

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package javax.xml.soap;

/**
 * An exception that signals that a SOAP exception has occurred. A <CODE>SOAPException object
 * may contain a <CODE>String that gives the reason for the exception, an embedded
 * <CODE>Throwable object, or both. This class provides methods for retrieving reason
 * messages and for retrieving the embedded <CODE>Throwable object.

 * <p/>
 * <P>Typical reasons for throwing a SOAPException object are problems such as
 * difficulty setting a header, not being able to send a message, and not being able to get a
 * connection with the provider. Reasons for embedding a <CODE> Throwable object include
 * problems such as input/output errors or a parsing problem, such as an error in parsing a header.
 */
public class SOAPException extends Exception {

    private static final long serialVersionUID = 5083961510786058130L;

    /**
     * Constructs a <CODE>SOAPException object with no reason or embedded
     * <CODE>Throwable object.
     */
    public SOAPException() {
        cause = null;
    }

    /**
     * Constructs a <CODE>SOAPException object with the given String as the
     * reason for the exception being thrown.
     *
     * @param reason a description of what caused the exception
     */
    public SOAPException(String reason) {

        super(reason);

        cause = null;
    }

    /**
     * Constructs a <CODE>SOAPException object with the given String as the
     * reason for the exception being thrown and the given <CODE>Throwable object as an
     * embedded exception.
     *
     * @param reason a description of what caused the exception
     * @param cause  a <CODE>Throwable object that is to be embedded in this
     *               <CODE>SOAPException object
     */
    public SOAPException(String reason, Throwable cause) {

        super(reason);

        initCause(cause);
    }

    /**
     * Constructs a <CODE>SOAPException object initialized with the given
     * <CODE>Throwable object.
     *
     * @param cause a <CODE>Throwable object that is to be embedded in this
     *              <CODE>SOAPException object
     */
    public SOAPException(Throwable cause) {

        super(cause.toString());

        initCause(cause);
    }

    /**
     * Returns the detail message for this <CODE> SOAPException object.
     * <p/>
     * <P>If there is an embedded Throwable object, and if the
     * <CODE>SOAPException object has no detail message of its own, this method will return
     * the detail message from the embedded <CODE>Throwable object.

     *
     * @return the error or warning message for this <CODE> SOAPException or, if it has none,
     *         the message of the embedded <CODE>Throwable object, if there is one
     */
    public String getMessage() {

        String s = super.getMessage();

        if ((s == null) && (cause != null)) {
            return cause.getMessage();
        } else {
            return s;
        }
    }

    /**
     * Returns the <CODE>Throwable object embedded in this SOAPException if
     * there is one. Otherwise, this method returns <CODE>null.
     *
     * @return the embedded <CODE>Throwable object or  null if there is none
     */
    public Throwable getCause() {
        return cause;
    }

    /**
     * Initializes the <CODE>cause field of this  SOAPException object with the
     * given <CODE> Throwable object.
     * <p/>
     * <P>This method can be called at most once. It is generally called from within the constructor
     * or immediately after the constructor has returned a new <CODE>SOAPException object. If
     * this <CODE>SOAPException object was created with the constructor {@link
     * #SOAPException(java.lang.Throwable) SOAPException(java.lang.Throwable)} or {@link
     * #SOAPException(java.lang.String, java.lang.Throwable) SOAPException(java.lang.String,
     * java.lang.Throwable)}, meaning that its <CODE>cause field already has a value, this
     * method cannot be called even once.
     *
     * @param cause the <CODE>Throwable object that caused this SOAPException
     *              object to be thrown. The value of this parameter is saved for later retrieval by
     *              the <A href= "../../../javax/xml/soap/SOAPException.html#getCause()">
     *              <CODE>getCause() method. A null value is permitted and
     *              indicates that the cause is nonexistent or unknown.
     * @return a reference to this <CODE>SOAPException instance
     * @throws IllegalArgumentException
     *          if <CODE>cause is this Throwable object. (A
     *          <CODE>Throwable object cannot be its own cause.)
     * @throws IllegalStateException
     *          if this <CODE> SOAPException object was created with {@link
     *          #SOAPException(java.lang.Throwable) SOAPException(java.lang.Throwable)} or {@link
     *          #SOAPException(java.lang.String, java.lang.Throwable) SOAPException(java.lang.String,
     *          java.lang.Throwable)}, or this method has already been called on this <CODE>
     *          SOAPException</CODE> object
     */
    public synchronized Throwable initCause(Throwable cause) {

        if (this.cause != null) {
            throw new IllegalStateException("Can't override cause");
        }

        if (cause == this) {
            throw new IllegalArgumentException("Self-causation not permitted");
        } else {
            this.cause = cause;

            return this;
        }
    }

    private Throwable cause;
}