Class ExceptionUtilities

java.lang.Object
com.strobel.core.ExceptionUtilities

public final class ExceptionUtilities extends Object
  • Constructor Details

    • ExceptionUtilities

      public ExceptionUtilities()
  • Method Details

    • asRuntimeException

      public static RuntimeException asRuntimeException(Throwable t)
    • unwrap

      public static Throwable unwrap(Throwable t)
    • getMessage

      public static String getMessage(Throwable t)
    • getStackTraceString

      public static String getStackTraceString(Throwable t)
    • rethrowCritical

      public static void rethrowCritical(Throwable t)
      Rethrows the specified exception only if it is within a narrow subset of 'critical' exceptions, e.g., ThreadDeath or VirtualMachineError.
    • rethrow

      public static <T extends Throwable> RuntimeException rethrow(Throwable t) throws T

      Sneakily rethrows any exception without the compiler complaining if the exception is checked but unhandled. The signature declares a return type of RuntimeException, for cases where the caller method must exit to satisfy control flow requirements (e.g., final variable assignment), but this method never actually returns a value.

      Trivial example:

       void doSomething() {
           try {
               mightThrowCheckedException();
           }
           catch (final Throwable t) {
               throw ExceptionUtilities.rethrow(t);
           }
       }

      Example requiring a return value:

       T returnSomething() {
           try {
               return mightThrowCheckedException();
           }
           catch (final Throwable t) {
               // The call below always throws, but the compiler doesn't know that and demands
               // we either return a value or throw.  The return value, while never used, allows
               // us to satisfying the compiler by exiting the current method exceptionally.
               throw ExceptionUtilities.rethrow(t);
           }
       }

      Example with constructor and final fields:

       class U {
           final T mustBeAssigned;
      
           U() {
               try {
                   mustBeAssigned = mightThrowCheckedException();
               }
               catch (final Throwable t) {
                   // The compiler requires us to definitively assign all final fields before
                   // returning or throw.  Since the compiler doesn't know that the call below
                   // always throws, we can throw the dummy result to satisfy the compiler.
                   throw ExceptionUtilities.rethrow(t);
               }
           }
       }
      Returns:
      This method will never return a value; it always throws.
      Throws:
      T - This method rethrows the original exception t, or a NullPointerException if t is null.
    • rethrowAs

      public static <T extends Throwable, R> R rethrowAs(Throwable t) throws T

      Equivalent to rethrow, but with an open-ended return type, allowing calls to this method to be used as the body of lambda expressions that must return a specific type.

      Example:

       public static <T, R> Function<T, R> throwing(final Throwable t) {
           return _ -> ExceptionUtilities.rethrowAs(t);
       }
      Returns:
      This method will never return a value; it always throws.
      Throws:
      T - This method rethrows the original exception t, or a NullPointerException if t is null.
    • wrapOrThrow

      public static RuntimeException wrapOrThrow(Throwable t)