public NestableDelegate(Nestable nestable) 
{
	                                     	 
		if ( nestable instanceof Throwable ) {
			this.nestable = ( Throwable ) nestable;
		}
		else {
			throw new IllegalArgumentException( MUST_BE_THROWABLE );
		}
}

Constructs a new NestableDelegate instance to manage the specified Nestable.

Parameters:

nestable - the Nestable implementation (must extend java.lang.Throwable )

since: 2.0 -

 public String getMessage(int index) 
{
		Throwable t = this.getThrowable( index );
		if ( Nestable.class.isInstance( t ) ) {
			return ( ( Nestable ) t ).getMessage( 0 );
		}
		else {
			return t.getMessage();
		}
}

Returns the error message of the Throwable in the chain of Throwables at the specified index, numbererd from 0.

 public String getMessage(String baseMsg) 
{
		StringBuffer msg = new StringBuffer();
		if ( baseMsg != null ) {
			msg.append( baseMsg );
		}
		Throwable nestedCause = ExceptionUtils.getCause( this.nestable );
		if ( nestedCause != null ) {
			String causeMsg = nestedCause.getMessage();
			if ( causeMsg != null ) {
				if ( baseMsg != null ) {
					msg.append( ": " );
				}
				msg.append( causeMsg );
			}
		}
		return ( msg.length()  > 0 ? msg.toString() : null );
}

Returns the full message contained by the Nestable and any nested Throwables.

 public String[] getMessages() 
{
		Throwable[] throwables = this.getThrowables();
		String[] msgs = new String[throwables.length];
		for ( int i = 0; i <  throwables.length; i++ ) {
			msgs[i] = Nestable.class.isInstance( throwables[i] ) ?
					( ( Nestable ) throwables[i] ).getMessage( 0 ) :
					throwables[i].getMessage();
		}
		return msgs;
}

Returns the error message of this and any nested Throwables in an array of Strings, one element for each message. Any Throwable not containing a message is represented in the array by a null. This has the effect of cause the length of the returned array to be equal to the result of the #getThrowableCount() operation.

 protected String[] getStackFrames(Throwable t) 
{
		StringWriter sw = new StringWriter();
		PrintWriter pw = new PrintWriter( sw, true );
		// Avoid infinite loop between decompose() and printStackTrace().
		if ( t instanceof Nestable ) {
			( ( Nestable ) t ).printPartialStackTrace( pw );
		}
		else {
			t.printStackTrace( pw );
		}
		return ExceptionUtils.getStackFrames( sw.getBuffer().toString() );
}

Captures the stack trace associated with the specified Throwable object, decomposing it into a list of stack frames.

 public Throwable getThrowable(int index) 
{
		if ( index == 0 ) {
			return this.nestable;
		}
		Throwable[] throwables = this.getThrowables();
		return throwables[index];
}

Returns the Throwable in the chain of Throwables at the specified index, numbererd from 0.

 public int getThrowableCount() 
{
		return ExceptionUtils.getThrowableCount( this.nestable );
}

Returns the number of Throwables contained in the Nestable contained by this delegate.

 public Throwable[] getThrowables() 
{
		return ExceptionUtils.getThrowables( this.nestable );
}

Returns this delegate's Nestable and any nested Throwables in an array of Throwables, one element for each Throwable.

 public int indexOfThrowable(Class type,
    int fromIndex) 
{
		if ( fromIndex <  0 ) {
			throw new IndexOutOfBoundsException( "The start index was out of bounds: " + fromIndex );
		}
		Throwable[] throwables = ExceptionUtils.getThrowables( this.nestable );
		if ( fromIndex  >= throwables.length ) {
			throw new IndexOutOfBoundsException( "The start index was out of bounds: "
					+ fromIndex + "  >= " + throwables.length );
		}
		for ( int i = fromIndex; i <  throwables.length; i++ ) {
			if ( throwables[i].getClass().equals( type ) ) {
				return i;
			}
		}
		return -1;
}

Returns the index, numbered from 0, of the first Throwable that matches the specified type in the chain of Throwables held in this delegate's Nestable with an index greater than or equal to the specified index, or -1 if the type is not found.

 public  void printStackTrace() 
{
		printStackTrace( System.err );
}

Prints the stack trace of this exception the the standar error stream.

 public  void printStackTrace(PrintStream out) 
{
		synchronized ( out ) {
			PrintWriter pw = new PrintWriter( out, false );
			printStackTrace( pw );
			// Flush the PrintWriter before it's GC'ed.
			pw.flush();
		}
}

Prints the stack trace of this exception to the specified stream.

 public  void printStackTrace(PrintWriter out) 
{
		Throwable throwable = this.nestable;
		// if running on jre1.4 or higher, use default printStackTrace
		if ( ExceptionUtils.isThrowableNested() ) {
			if ( throwable instanceof Nestable ) {
				( ( Nestable ) throwable ).printPartialStackTrace( out );
			}
			else {
				throwable.printStackTrace( out );
			}
			return;
		}
		// generating the nested stack trace
		List stacks = new ArrayList();
		while ( throwable != null ) {
			String[] st = getStackFrames( throwable );
			stacks.add( st );
			throwable = ExceptionUtils.getCause( throwable );
		}
		// If NOT topDown, reverse the stack
		String separatorLine = "Caused by: ";
		if ( !topDown ) {
			separatorLine = "Rethrown as: ";
			Collections.reverse( stacks );
		}
		// Remove the repeated lines in the stack
		if ( trimStackFrames ) trimStackFrames( stacks );
		synchronized ( out ) {
			for ( Iterator iter = stacks.iterator(); iter.hasNext(); ) {
				String[] st = ( String[] ) iter.next();
				for ( int i = 0, len = st.length; i <  len; i++ ) {
					out.println( st[i] );
				}
				if ( iter.hasNext() ) out.print( separatorLine );
			}
		}
}

Prints the stack trace of this exception to the specified writer. If the Throwable class has a getCause method (i.e. running on jre1.4 or higher), this method just uses Throwable's printStackTrace() method. Otherwise, generates the stack-trace, by taking into account the 'topDown' and 'trimStackFrames' parameters. The topDown and trimStackFrames are set to 'true' by default (produces jre1.4-like stack trace).

 protected  void trimStackFrames(List stacks) 
{
		for ( int size = stacks.size(), i = size - 1; i  > 0; i-- ) {
			String[] curr = ( String[] ) stacks.get( i );
			String[] next = ( String[] ) stacks.get( i - 1 );
			List currList = new ArrayList( Arrays.asList( curr ) );
			List nextList = new ArrayList( Arrays.asList( next ) );
			ExceptionUtils.removeCommonFrames( currList, nextList );
			int trimmed = curr.length - currList.size();
			if ( trimmed  > 0 ) {
				currList.add( "\t... " + trimmed + " more" );
				stacks.set( i,
						currList.toArray( new String[currList.size()] ) );
			}
		}
}

Trims the stack frames. The first set is left untouched. The rest of the frames are truncated from the bottom by comparing with one just on top.