| /** |
| * $RCSfile$ |
| * $Revision$ |
| * $Date$ |
| * |
| * Copyright 2003-2007 Jive Software. |
| * |
| * All rights reserved. Licensed 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 org.jivesoftware.smack; |
| |
| import org.jivesoftware.smack.packet.StreamError; |
| import org.jivesoftware.smack.packet.XMPPError; |
| |
| import java.io.PrintStream; |
| import java.io.PrintWriter; |
| |
| /** |
| * A generic exception that is thrown when an error occurs performing an |
| * XMPP operation. XMPP servers can respond to error conditions with an error code |
| * and textual description of the problem, which are encapsulated in the XMPPError |
| * class. When appropriate, an XMPPError instance is attached instances of this exception.<p> |
| * |
| * When a stream error occured, the server will send a stream error to the client before |
| * closing the connection. Stream errors are unrecoverable errors. When a stream error |
| * is sent to the client an XMPPException will be thrown containing the StreamError sent |
| * by the server. |
| * |
| * @see XMPPError |
| * @author Matt Tucker |
| */ |
| public class XMPPException extends Exception { |
| |
| private StreamError streamError = null; |
| private XMPPError error = null; |
| private Throwable wrappedThrowable = null; |
| |
| /** |
| * Creates a new XMPPException. |
| */ |
| public XMPPException() { |
| super(); |
| } |
| |
| /** |
| * Creates a new XMPPException with a description of the exception. |
| * |
| * @param message description of the exception. |
| */ |
| public XMPPException(String message) { |
| super(message); |
| } |
| |
| /** |
| * Creates a new XMPPException with the Throwable that was the root cause of the |
| * exception. |
| * |
| * @param wrappedThrowable the root cause of the exception. |
| */ |
| public XMPPException(Throwable wrappedThrowable) { |
| super(); |
| this.wrappedThrowable = wrappedThrowable; |
| } |
| |
| /** |
| * Cretaes a new XMPPException with the stream error that was the root case of the |
| * exception. When a stream error is received from the server then the underlying |
| * TCP connection will be closed by the server. |
| * |
| * @param streamError the root cause of the exception. |
| */ |
| public XMPPException(StreamError streamError) { |
| super(); |
| this.streamError = streamError; |
| } |
| |
| /** |
| * Cretaes a new XMPPException with the XMPPError that was the root case of the |
| * exception. |
| * |
| * @param error the root cause of the exception. |
| */ |
| public XMPPException(XMPPError error) { |
| super(); |
| this.error = error; |
| } |
| |
| /** |
| * Creates a new XMPPException with a description of the exception and the |
| * Throwable that was the root cause of the exception. |
| * |
| * @param message a description of the exception. |
| * @param wrappedThrowable the root cause of the exception. |
| */ |
| public XMPPException(String message, Throwable wrappedThrowable) { |
| super(message); |
| this.wrappedThrowable = wrappedThrowable; |
| } |
| |
| /** |
| * Creates a new XMPPException with a description of the exception, an XMPPError, |
| * and the Throwable that was the root cause of the exception. |
| * |
| * @param message a description of the exception. |
| * @param error the root cause of the exception. |
| * @param wrappedThrowable the root cause of the exception. |
| */ |
| public XMPPException(String message, XMPPError error, Throwable wrappedThrowable) { |
| super(message); |
| this.error = error; |
| this.wrappedThrowable = wrappedThrowable; |
| } |
| |
| /** |
| * Creates a new XMPPException with a description of the exception and the |
| * XMPPException that was the root cause of the exception. |
| * |
| * @param message a description of the exception. |
| * @param error the root cause of the exception. |
| */ |
| public XMPPException(String message, XMPPError error) { |
| super(message); |
| this.error = error; |
| } |
| |
| /** |
| * Returns the XMPPError asscociated with this exception, or <tt>null</tt> if there |
| * isn't one. |
| * |
| * @return the XMPPError asscociated with this exception. |
| */ |
| public XMPPError getXMPPError() { |
| return error; |
| } |
| |
| /** |
| * Returns the StreamError asscociated with this exception, or <tt>null</tt> if there |
| * isn't one. The underlying TCP connection is closed by the server after sending the |
| * stream error to the client. |
| * |
| * @return the StreamError asscociated with this exception. |
| */ |
| public StreamError getStreamError() { |
| return streamError; |
| } |
| |
| /** |
| * Returns the Throwable asscociated with this exception, or <tt>null</tt> if there |
| * isn't one. |
| * |
| * @return the Throwable asscociated with this exception. |
| */ |
| public Throwable getWrappedThrowable() { |
| return wrappedThrowable; |
| } |
| |
| public void printStackTrace() { |
| printStackTrace(System.err); |
| } |
| |
| public void printStackTrace(PrintStream out) { |
| super.printStackTrace(out); |
| if (wrappedThrowable != null) { |
| out.println("Nested Exception: "); |
| wrappedThrowable.printStackTrace(out); |
| } |
| } |
| |
| public void printStackTrace(PrintWriter out) { |
| super.printStackTrace(out); |
| if (wrappedThrowable != null) { |
| out.println("Nested Exception: "); |
| wrappedThrowable.printStackTrace(out); |
| } |
| } |
| |
| public String getMessage() { |
| String msg = super.getMessage(); |
| // If the message was not set, but there is an XMPPError, return the |
| // XMPPError as the message. |
| if (msg == null && error != null) { |
| return error.toString(); |
| } |
| else if (msg == null && streamError != null) { |
| return streamError.toString(); |
| } |
| return msg; |
| } |
| |
| public String toString() { |
| StringBuilder buf = new StringBuilder(); |
| String message = super.getMessage(); |
| if (message != null) { |
| buf.append(message).append(": "); |
| } |
| if (error != null) { |
| buf.append(error); |
| } |
| if (streamError != null) { |
| buf.append(streamError); |
| } |
| if (wrappedThrowable != null) { |
| buf.append("\n -- caused by: ").append(wrappedThrowable); |
| } |
| |
| return buf.toString(); |
| } |
| } |