Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2007 The Guava Authors
   *
   * 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 com.google.common.base;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.util.List;
 
Static utility methods pertaining to instances of java.lang.Throwable.

See the Guava User Guide entry on Throwables.

Author(s):
Kevin Bourrillion
Ben Yu
Since:
1.0
 
 public final class Throwables {
   private Throwables() {}

  
Propagates throwable exactly as-is, if and only if it is an instance of declaredType. Example usage:
   try {
     someMethodThatCouldThrowAnything();
   } catch (IKnowWhatToDoWithThisException e) {
     handle(e);
   } catch (Throwable t) {
     Throwables.propagateIfInstanceOf(t, IOException.class);
     Throwables.propagateIfInstanceOf(t, SQLException.class);
     throw Throwables.propagate(t);
   }
 
 
   public static <X extends Throwablevoid propagateIfInstanceOf(
       @Nullable Throwable throwableClass<X> declaredTypethrows X {
     // Check for null is needed to avoid frequent JNI calls to isInstance().
     if (throwable != null && declaredType.isInstance(throwable)) {
       throw declaredType.cast(throwable);
     }
   }

  
Propagates throwable exactly as-is, if and only if it is an instance of java.lang.RuntimeException or java.lang.Error. Example usage:
   try {
     someMethodThatCouldThrowAnything();
   } catch (IKnowWhatToDoWithThisException e) {
     handle(e);
   } catch (Throwable t) {
     Throwables.propagateIfPossible(t);
     throw new RuntimeException("unexpected", t);
   }
 
 
   public static void propagateIfPossible(@Nullable Throwable throwable) {
     propagateIfInstanceOf(throwableError.class);
     propagateIfInstanceOf(throwableRuntimeException.class);
   }

  
Propagates throwable exactly as-is, if and only if it is an instance of java.lang.RuntimeException, java.lang.Error, or declaredType. Example usage:
   try {
     someMethodThatCouldThrowAnything();
   } catch (IKnowWhatToDoWithThisException e) {
     handle(e);
   } catch (Throwable t) {
     Throwables.propagateIfPossible(t, OtherException.class);
     throw new RuntimeException("unexpected", t);
   }
 

Parameters:
throwable the Throwable to possibly propagate
declaredType the single checked exception type declared by the calling method
  public static <X extends Throwablevoid propagateIfPossible(
      @Nullable Throwable throwableClass<X> declaredTypethrows X {
    propagateIfInstanceOf(throwabledeclaredType);
    propagateIfPossible(throwable);
  }

  
Propagates throwable exactly as-is, if and only if it is an instance of java.lang.RuntimeException, java.lang.Error, declaredType1, or declaredType2. In the unlikely case that you have three or more declared checked exception types, you can handle them all by invoking these methods repeatedly. See usage example in propagateIfPossible(java.lang.Throwable,java.lang.Class).

Parameters:
throwable the Throwable to possibly propagate
declaredType1 any checked exception type declared by the calling method
declaredType2 any other checked exception type declared by the calling method
  public static <X1 extends Throwable, X2 extends Throwable>
      void propagateIfPossible(@Nullable Throwable throwable,
          Class<X1> declaredType1Class<X2> declaredType2throws X1, X2 {
    checkNotNull(declaredType2);
    propagateIfInstanceOf(throwabledeclaredType1);
    propagateIfPossible(throwabledeclaredType2);
  }

  
Propagates throwable as-is if it is an instance of java.lang.RuntimeException or java.lang.Error, or else as a last resort, wraps it in a RuntimeException then propagates.

This method always throws an exception. The RuntimeException return type is only for client code to make Java type system happy in case a return value is required by the enclosing method. Example usage:

   T doSomething() {
     try {
       return someMethodThatCouldThrowAnything();
     } catch (IKnowWhatToDoWithThisException e) {
       return handle(e);
     } catch (Throwable t) {
       throw Throwables.propagate(t);
     }
   }
 

Parameters:
throwable the Throwable to propagate
Returns:
nothing will ever be returned; this return type is only for your convenience, as illustrated in the example above
  public static RuntimeException propagate(Throwable throwable) {
    throw new RuntimeException(throwable);
  }

  
Returns the innermost cause of throwable. The first throwable in a chain provides context from when the error or exception was initially detected. Example usage:
   assertEquals("Unable to assign a customer id",
       Throwables.getRootCause(e).getMessage());
 
  public static Throwable getRootCause(Throwable throwable) {
    Throwable cause;
    while ((cause = throwable.getCause()) != null) {
      throwable = cause;
    }
    return throwable;
  }

  
Gets a Throwable cause chain as a list. The first entry in the list will be throwable followed by its cause hierarchy. Note that this is a snapshot of the cause chain and will not reflect any subsequent changes to the cause chain.

Here's an example of how it can be used to find specific types of exceptions in the cause chain:

 Iterables.filter(Throwables.getCausalChain(e), IOException.class));
 

Parameters:
throwable the non-null Throwable to extract causes from
Returns:
an unmodifiable list containing the cause chain starting with throwable
  @Beta // TODO(kevinb): decide best return type
  public static List<ThrowablegetCausalChain(Throwable throwable) {
    checkNotNull(throwable);
    List<Throwablecauses = new ArrayList<Throwable>(4);
    while (throwable != null) {
      causes.add(throwable);
      throwable = throwable.getCause();
    }
    return Collections.unmodifiableList(causes);
  }

  
Returns a string containing the result of toString(), followed by the full, recursive stack trace of throwable. Note that you probably should not be parsing the resulting string; if you need programmatic access to the stack frames, you can call java.lang.Throwable.getStackTrace().
  public static String getStackTraceAsString(Throwable throwable) {
    StringWriter stringWriter = new StringWriter();
    throwable.printStackTrace(new PrintWriter(stringWriter));
    return stringWriter.toString();
  }
New to GrepCode? Check out our FAQ X