1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
/* * $Id: SOAPException.java,v 1.5 2004/04/02 01:24:18 ofung Exp $ * $Revision: 1.5 $ * $Date: 2004/04/02 01:24:18 $ */ /* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.xml.soap; /** * An exception that signals that a SOAP exception has occurred. A * <code>SOAPException</code> object may contain a <code>String</code> * that gives the reason for the exception, an embedded * <code>Throwable</code> object, or both. This class provides methods * for retrieving reason messages and for retrieving the embedded * <code>Throwable</code> object. * * <P> Typical reasons for throwing a <code>SOAPException</code> * 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</code> * 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 Throwable cause; /** * Constructs a <code>SOAPException</code> object with no * reason or embedded <code>Throwable</code> object. */ public SOAPException() { super(); this.cause = null; } /** * Constructs a <code>SOAPException</code> object with the given * <code>String</code> as the reason for the exception being thrown. * * @param reason a description of what caused the exception */ public SOAPException(String reason) { super(reason); this.cause = null; } /** * Constructs a <code>SOAPException</code> object with the given * <code>String</code> as the reason for the exception being thrown * and the given <code>Throwable</code> object as an embedded * exception. * * @param reason a description of what caused the exception * @param cause a <code>Throwable</code> object that is to * be embedded in this <code>SOAPException</code> object */ public SOAPException(String reason, Throwable cause) { super(reason); initCause(cause); } /** * Constructs a <code>SOAPException</code> object initialized * with the given <code>Throwable</code> object. */ public SOAPException(Throwable cause) { super(cause.toString()); initCause(cause); } /** * Returns the detail message for this <code>SOAPException</code> * object. * <P> * If there is an embedded <code>Throwable</code> object, and if the * <code>SOAPException</code> object has no detail message of its * own, this method will return the detail message from the embedded * <code>Throwable</code> object. * * @return the error or warning message for this * <code>SOAPException</code> or, if it has none, the * message of the embedded <code>Throwable</code> object, * if there is one */ public String getMessage() { String message = super.getMessage(); if (message == null && cause != null) { return cause.getMessage(); } else { return message; } } /** * Returns the <code>Throwable</code> object embedded in this * <code>SOAPException</code> if there is one. Otherwise, this method * returns <code>null</code>. * * @return the embedded <code>Throwable</code> object or <code>null</code> * if there is none */ public Throwable getCause() { return cause; } /** * Initializes the <code>cause</code> field of this <code>SOAPException</code> * object with the given <code>Throwable</code> object. * <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</code> object. * If this <code>SOAPException</code> object was created with the * constructor {@link #SOAPException(Throwable)} or * {@link #SOAPException(String,Throwable)}, meaning that its * <code>cause</code> field already has a value, this method cannot be * called even once. * * @param cause the <code>Throwable</code> object that caused this * <code>SOAPException</code> object to be thrown. The value of this * parameter is saved for later retrieval by the * {@link #getCause()} method. A <tt>null</tt> value is * permitted and indicates that the cause is nonexistent or * unknown. * @return a reference to this <code>SOAPException</code> instance * @throws IllegalArgumentException if <code>cause</code> is this * <code>Throwable</code> object. (A <code>Throwable</code> object * cannot be its own cause.) * @throws IllegalStateException if the cause for this <code>SOAPException</code> object * has already been initialized */ 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"); } this.cause = cause; return this; } }