org.jivesoftware.smack.XMPPException Maven / Gradle / Ivy
Show all versions of jamppa Show documentation
/**
*
* 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 java.io.PrintStream;
import java.io.PrintWriter;
import org.jivesoftware.smack.packet.StreamError;
import org.xmpp.packet.PacketError;
/**
* 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.
*
*
* 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 static final long serialVersionUID = 6881651633890968625L;
private StreamError streamError = null;
private PacketError error = null;
private Throwable wrappedThrowable = null;
private SmackError smackError = 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 a Smack specific error code.
*
* @param code
* the root cause of the exception.
*/
public XMPPException(SmackError code) {
super(code.getErrorMessage());
smackError = code;
}
/**
* 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;
}
/**
* Creates 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(PacketError 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, PacketError 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, PacketError error) {
super(message);
this.error = error;
}
/**
* Returns the XMPPError asscociated with this exception, or null
* if there isn't one.
*
* @return the XMPPError asscociated with this exception.
*/
public PacketError getXMPPError() {
return error;
}
/**
* Returns the SmackError asscociated with this exception, or null
* if there isn't one.
*
* @return the SmackError asscociated with this exception.
*/
public SmackError getSmackError() {
return smackError;
}
/**
* Returns the StreamError asscociated with this exception, or null
* 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 null
* 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();
}
}