File Doc Category Size Date Package
NestableException.java API Doc Hibernate 3.2.5 8027 Sat Nov 20 17:11:28 GMT 2004 org.hibernate.exception

NestableException

java.lang.Object
- java.lang.Throwable
  - java.lang.Exception

public class NestableException extends Exception implements Nestable

The base class of all exceptions which can contain other exceptions.

It is intended to ease the debugging by carrying on the information about the exception which was caught and provoked throwing the current exception. Catching and rethrowing may occur multiple times, and provided that all exceptions except the first one are descendands of NestedException, when the exception is finally printed out using any of the printStackTrace() methods, the stacktrace will contain the information about all exceptions thrown and caught on the way.

Running the following program

1 import org.apache.commons.lang.exception.NestableException;
2
3 public class Test {
4 public static void main( String[] args ) {
5 try {
6 a();
7 } catch(Exception e) {
8 e.printStackTrace();
9 }
10 }
11
12 public static void a() throws Exception {
13 try {
14 b();
15 } catch(Exception e) {
16 throw new NestableException("foo", e);
17 }
18 }
19
20 public static void b() throws Exception {
21 try {
22 c();
23 } catch(Exception e) {
24 throw new NestableException("bar", e);
25 }
26 }
27
28 public static void c() throws Exception {
29 throw new Exception("baz");
30 }
31 }

Yields the following stacktrace:

org.apache.commons.lang.exception.NestableException: foo
at Test.a(Test.java:16)
at Test.main(Test.java:6)
Caused by: org.apache.commons.lang.exception.NestableException: bar
at Test.b(Test.java:24)
at Test.a(Test.java:14)
... 1 more
Caused by: java.lang.Exception: baz
at Test.c(Test.java:29)
at Test.b(Test.java:22)
... 2 more

author: Rafal Krzewski
author: Daniel Rall
author: Kasper Nielsen
author: Steven Caswell
version: $Id: NestableException.java 4782 2004-11-21 00:11:27Z pgmjsd $
since: 1.0

Fields Summary
protected NestableDelegate
delegate
The helper instance which contains much of the code which we delegate to.
private Throwable
cause
Holds the reference to the exception or error that caused this exception to be thrown.
Constructors Summary
public NestableException()
Constructs a new NestableException without specified detail message.
super();
public NestableException(String msg)
Constructs a new NestableException with specified detail message.
param
msg The error message.
super( msg );
public NestableException(Throwable cause)
Constructs a new NestableException with specified nested Throwable.
param
cause the exception or error that caused this exception to be thrown
super(); this.cause = cause;
public NestableException(String msg, Throwable cause)
Constructs a new NestableException with specified detail message and nested Throwable.
param
msg the error message
param
cause the exception or error that caused this exception to be thrown
super( msg ); this.cause = cause;
Methods Summary
public java.lang.Throwable getCause()
return cause;
public java.lang.String getMessage()
Returns the detail message string of this throwable. If it was created with a null message, returns the following: ( cause==null ? null : cause.toString() ).
if ( super.getMessage() != null ) { return super.getMessage(); } else if ( cause != null ) { return cause.toString(); } else { return null; }
public java.lang.String getMessage(int index)
if ( index == 0 ) { return super.getMessage(); } else { return delegate.getMessage( index ); }
public java.lang.String[] getMessages()
return delegate.getMessages();
public java.lang.Throwable getThrowable(int index)
return delegate.getThrowable( index );
public int getThrowableCount()
return delegate.getThrowableCount();
public java.lang.Throwable[] getThrowables()
return delegate.getThrowables();
public int indexOfThrowable(java.lang.Class type)
return delegate.indexOfThrowable( type, 0 );
public int indexOfThrowable(java.lang.Class type, int fromIndex)
return delegate.indexOfThrowable( type, fromIndex );
public final void printPartialStackTrace(java.io.PrintWriter out)
super.printStackTrace( out );
public void printStackTrace()
delegate.printStackTrace();
public void printStackTrace(java.io.PrintStream out)
delegate.printStackTrace( out );
public void printStackTrace(java.io.PrintWriter out)
delegate.printStackTrace( out );