com.hazelcast.util

Class ExceptionUtil

java.lang.Object

com.hazelcast.util.ExceptionUtil

public final class ExceptionUtil
extends Object

Contains various exception related utility methods.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	ExceptionUtil.ExceptionWrapper<T extends Throwable> Interface used by rethrow/peel to wrap the peeled exception

Method Summary

Modifier and Type	Method and Description
static void	fixAsyncStackTrace(Throwable asyncCause, StackTraceElement[] localSideStackTrace) This method changes the given async cause, and it adds the also given local stacktrace. If the remoteCause is an ExecutionException and it has a non-null inner cause, this inner cause is unwrapped and the local stacktrace and exception message are added to the that instead of the given asyncCause itself.
static void	fixAsyncStackTrace(Throwable asyncCause, StackTraceElement[] localSideStackTrace, String localExceptionMessage) This method changes the given async cause, and it adds the also given local stacktrace separated by the supplied exception message. If the remoteCause is an ExecutionException and it has a non-null inner cause, this inner cause is unwrapped and the local stacktrace and exception message are added to the that instead of the given remoteCause itself.
static RuntimeException	peel(Throwable t)
static <T extends Throwable> Throwable	peel(Throwable t, Class<T> allowedType, String message) Processes Throwable t so that the returned Throwable's type matches allowedType or RuntimeException.
static <T,W extends Throwable> Throwable	peel(Throwable t, Class<T> allowedType, String message, ExceptionUtil.ExceptionWrapper<W> exceptionWrapper) Processes Throwable t so that the returned Throwable's type matches allowedType, RuntimeException or any Throwable returned by `exceptionWrapper` Processing may include unwrapping t's cause hierarchy, wrapping it in a exception created by using exceptionWrapper or just returning the same instance t if it is already an instance of RuntimeException.
static RuntimeException	rethrow(Throwable t)
static <T extends Throwable> RuntimeException	rethrow(Throwable t, Class<T> allowedType)
static RuntimeException	rethrow(Throwable t, ExceptionUtil.ExceptionWrapper<RuntimeException> exceptionWrapper)
static <T extends Throwable> RuntimeException	rethrowAllowedTypeFirst(Throwable t, Class<T> allowedType) This rethrow the exception providing an allowed Exception in first priority, even it is a Runtime exception
static RuntimeException	rethrowAllowInterrupted(Throwable t)
static <T> T	sneakyThrow(Throwable t)
static String	toString(Throwable cause) Converts a Throwable stacktrace to a String.
static <T extends Throwable> T	tryCreateExceptionWithMessageAndCause(Class<? extends Throwable> exceptionClass, String message, Throwable cause) Tries to create the exception with appropriate constructor in the following order.

Methods inherited from class java.lang.Object

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

Method Detail

toString

public static String toString(Throwable cause)

Converts a Throwable stacktrace to a String.

Parameters:

cause - the Throwable

Returns:

the String.

peel

public static RuntimeException peel(Throwable t)

peel

public static <T extends Throwable> Throwable peel(Throwable t,
                                                   Class<T> allowedType,
                                                   String message)

Processes Throwable t so that the returned Throwable's type matches allowedType or RuntimeException. Processing may include unwrapping t's cause hierarchy, wrapping it in a HazelcastException or just returning the same instance t if it is already an instance of RuntimeException.

Type Parameters:

T - expected type of Throwable

Parameters:

t - Throwable to be peeled

allowedType - the type expected to be returned; when null, this method returns instances of RuntimeException

message - if not null, used as the message in the HazelcastException that may wrap the peeled Throwable

Returns:

the peeled Throwable

peel

public static <T,W extends Throwable> Throwable peel(Throwable t,
                                                     Class<T> allowedType,
                                                     String message,
                                                     ExceptionUtil.ExceptionWrapper<W> exceptionWrapper)

Processes Throwable t so that the returned Throwable's type matches allowedType, RuntimeException or any Throwable returned by `exceptionWrapper` Processing may include unwrapping t's cause hierarchy, wrapping it in a exception created by using exceptionWrapper or just returning the same instance t if it is already an instance of RuntimeException.

Type Parameters:

W - Type of the wrapper exception in exceptionWrapper

T - allowed type of Throwable

Parameters:

t - Throwable to be peeled

allowedType - the type expected to be returned; when null, this method returns instances of RuntimeException or

message - if not null, used as the message in RuntimeException that may wrap the peeled Throwable

exceptionWrapper - wraps the peeled code using this exceptionWrapper

Returns:

the peeled Throwable

rethrow

public static RuntimeException rethrow(Throwable t)

rethrow

public static RuntimeException rethrow(Throwable t,
                                       ExceptionUtil.ExceptionWrapper<RuntimeException> exceptionWrapper)

rethrow

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

Throws:

T extends Throwable

rethrowAllowedTypeFirst

public static <T extends Throwable> RuntimeException rethrowAllowedTypeFirst(Throwable t,
                                                                             Class<T> allowedType)
                                                                      throws T extends Throwable

This rethrow the exception providing an allowed Exception in first priority, even it is a Runtime exception

Throws:

T extends Throwable

rethrowAllowInterrupted

public static RuntimeException rethrowAllowInterrupted(Throwable t)
                                                throws InterruptedException

Throws:

InterruptedException

sneakyThrow

public static <T> T sneakyThrow(Throwable t)

fixAsyncStackTrace

public static void fixAsyncStackTrace(Throwable asyncCause,
                                      StackTraceElement[] localSideStackTrace)

This method changes the given async cause, and it adds the also given local stacktrace.
If the remoteCause is an ExecutionException and it has a non-null inner cause, this inner cause is unwrapped and the local stacktrace and exception message are added to the that instead of the given asyncCause itself.

Parameters:

asyncCause - the async exception

localSideStackTrace - the local stacktrace to add to the exception stacktrace

fixAsyncStackTrace

public static void fixAsyncStackTrace(Throwable asyncCause,
                                      StackTraceElement[] localSideStackTrace,
                                      String localExceptionMessage)

This method changes the given async cause, and it adds the also given local stacktrace separated by the supplied exception message.
If the remoteCause is an ExecutionException and it has a non-null inner cause, this inner cause is unwrapped and the local stacktrace and exception message are added to the that instead of the given remoteCause itself.

Parameters:

asyncCause - the async exception

localSideStackTrace - the local stacktrace to add to the exceptions stacktrace

localExceptionMessage - a special exception message which is added to the stacktrace

tryCreateExceptionWithMessageAndCause

public static <T extends Throwable> T tryCreateExceptionWithMessageAndCause(Class<? extends Throwable> exceptionClass,
                                                                            String message,
                                                                            @Nullable
                                                                            Throwable cause)

Tries to create the exception with appropriate constructor in the following order. In all cases the cause is set (via constructor or via initCause) new Throwable(String message, Throwable cause) new Throwable(Throwable cause) new Throwable(String message) new Throwable()

Parameters:

exceptionClass - class of the exception

message - message to be pass to constructor of the exception

cause - cause to be set to the exception

Returns:

null if can not find a constructor as described above, otherwise returns newly constructed exception