org.neo4j.helpers

Class Exceptions

java.lang.Object

org.neo4j.helpers.Exceptions

public class Exceptions
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
static Thread.UncaughtExceptionHandler	SILENT_UNCAUGHT_EXCEPTION_HANDLER

Method Summary

Modifier and Type	Method and Description
static <T extends Throwable> T	chain(T initial, T current)
static <E extends Throwable> E	combine(E first, E second) Deprecated. Use Throwable.addSuppressed(Throwable) and Throwable.initCause(Throwable) where appropriate instead.
static boolean	contains(Throwable cause, Class... anyOfTheseClasses)
static boolean	contains(Throwable cause, Predicate<Throwable> toLookFor)
static boolean	contains(Throwable cause, String containsMessage, Class... anyOfTheseClasses)
static <T extends Throwable> T	launderedException(Class<T> type, String messageForUnexpected, Throwable exception) Deprecated. use throw e or throw new RuntimeException(e) directly. Prefer multi-caches if applicable. For more elaborate scenarios, have a look at throwIfUnchecked(Throwable) and throwIfInstanceOf(Throwable, Class) For a more furrow explanation take a look at the very similar case: Why we deprecated Throwables.propagate
static <T extends Throwable> T	launderedException(Class<T> type, Throwable exception) Deprecated. See launderedException(Class, String, Throwable).
static RuntimeException	launderedException(String messageForUnexpected, Throwable exception) Deprecated. See launderedException(Class, String, Throwable).
static RuntimeException	launderedException(Throwable exception) Deprecated. See launderedException(Class, String, Throwable).
static Throwable	peel(Throwable exception, Predicate<Throwable> toPeel) Peels off layers of causes.
static Throwable	rootCause(Throwable caughtException) Returns the root cause of an exception.
static void	setMessage(Throwable cause, String message)
static String	stringify(Thread thread, StackTraceElement[] elements)
static String	stringify(Throwable throwable)
static <T extends Throwable> void	throwIfInstanceOf(Throwable exception, Class<T> clazz) Will rethrow the provided exception if it is an instance of clazz.
static void	throwIfUnchecked(Throwable exception) Rethrows exception if it is an instance of RuntimeException or Error.
static <T extends Throwable> T	withCause(T exception, Throwable cause) Deprecated. Use Throwable.initCause(Throwable) instead.
static <T extends Throwable> T	withMessage(T cause, String message)
static <T extends Throwable> T	withSuppressed(T exception, Throwable... suppressed) Deprecated. Use Throwable.addSuppressed(Throwable) instead.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

SILENT_UNCAUGHT_EXCEPTION_HANDLER

public static final Thread.UncaughtExceptionHandler SILENT_UNCAUGHT_EXCEPTION_HANDLER

Method Detail

throwIfUnchecked

public static void throwIfUnchecked(Throwable exception)

Rethrows exception if it is an instance of RuntimeException or Error. Typical usage is:

 catch (Throwable e) {
   ......common code......
   throwIfUnchecked(e);
   throw new RuntimeException(e);
 }
 

This will only wrap checked exception in a RuntimeException. Do note that if the segment common code is missing, it's preferable to use this instead:

 catch (RuntimeException | Error e) {
   throw e;
 }
 catch (Throwable e) {
   throw new RuntimeException(e);
 }
 

Parameters:

exception - to rethrow.

throwIfInstanceOf

public static <T extends Throwable> void throwIfInstanceOf(Throwable exception,
                                                           Class<T> clazz)
                                                    throws T extends Throwable

Will rethrow the provided exception if it is an instance of clazz. Typical usage is:

 catch (Throwable e) {
   ......common code......
   throwIfInstanceOf(e, BarException.class);
   throw new RuntimeException(e);
 }
 

This will filter out all BarExceptions and wrap the rest in RuntimeException. Do note that if the segment common code is missing, it's preferable to use this instead:

 catch (BarException e) {
   throw e;
 } catch (Throwable e) {
   threw new RuntimeException(e);
 }
 

Type Parameters:

T - type thrown, if thrown at all.

Parameters:

exception - to rethrow.

clazz - a Class instance to check against.

Throws:

T - if exception is an instance of clazz.

T extends Throwable

withCause

@Deprecated
public static <T extends Throwable> T withCause(T exception,
                                                            Throwable cause)

Deprecated. Use Throwable.initCause(Throwable) instead.

withSuppressed

@Deprecated
public static <T extends Throwable> T withSuppressed(T exception,
                                                                 Throwable... suppressed)

Deprecated. Use Throwable.addSuppressed(Throwable) instead.

launderedException

@Deprecated
public static RuntimeException launderedException(Throwable exception)

Deprecated. See launderedException(Class, String, Throwable).

launderedException

@Deprecated
public static RuntimeException launderedException(String messageForUnexpected,
                                                              Throwable exception)

Deprecated. See launderedException(Class, String, Throwable).

launderedException

@Deprecated
public static <T extends Throwable> T launderedException(Class<T> type,
                                                                     Throwable exception)

Deprecated. See launderedException(Class, String, Throwable).

launderedException

@Deprecated
public static <T extends Throwable> T launderedException(Class<T> type,
                                                                     String messageForUnexpected,
                                                                     Throwable exception)

Deprecated. use throw e or throw new RuntimeException(e) directly. Prefer multi-caches if applicable. For more elaborate scenarios, have a look at throwIfUnchecked(Throwable) and throwIfInstanceOf(Throwable, Class)

For a more furrow explanation take a look at the very similar case: Why we deprecated Throwables.propagate

peel

public static Throwable peel(Throwable exception,
                             Predicate<Throwable> toPeel)

Peels off layers of causes. For example: MyFarOuterException cause: MyOuterException cause: MyInnerException cause: MyException and a toPeel predicate returning true for MyFarOuterException and MyOuterException will return MyInnerException. If the predicate peels all exceptions null is returned.

Parameters:

exception - the outer exception to peel to get to an delegate cause.

toPeel - Predicate for deciding what to peel. true means to peel (i.e. remove), whereas the first false means stop and return.

Returns:

the delegate cause of an exception, dictated by the predicate.

rootCause

public static Throwable rootCause(Throwable caughtException)

Returns the root cause of an exception.

Parameters:

caughtException - exception to find the root cause of.

Returns:

the root cause.

Throws:

IllegalArgumentException - if the provided exception is null.

stringify

public static String stringify(Throwable throwable)

stringify

public static String stringify(Thread thread,
                               StackTraceElement[] elements)

contains

public static boolean contains(Throwable cause,
                               String containsMessage,
                               Class... anyOfTheseClasses)

contains

public static boolean contains(Throwable cause,
                               Class... anyOfTheseClasses)

contains

public static boolean contains(Throwable cause,
                               Predicate<Throwable> toLookFor)

combine

@Deprecated
public static <E extends Throwable> E combine(E first,
                                                          E second)

Deprecated. Use Throwable.addSuppressed(Throwable) and Throwable.initCause(Throwable) where appropriate instead.

setMessage

public static void setMessage(Throwable cause,
                              String message)

withMessage

public static <T extends Throwable> T withMessage(T cause,
                                                  String message)

chain

public static <T extends Throwable> T chain(T initial,
                                            T current)