Module iu.util

Package edu.iu

Class IuException

java.lang.Object

edu.iu.IuException

public final class IuException
extends Object

Exception handling utilities.

Method Summary

Modifier and Type	Method	Description
static void	checked(UnsafeRunnable runnable)	Gracefully runs an UnsafeRunnable.
static <T> T	checked(UnsafeSupplier<T> supplier)	Gracefully gets from an UnsafeSupplier.
static <T extends Exception> void	checked(Class<T> expectedExceptionClass, UnsafeRunnable runnable)	Gracefully runs an UnsafeRunnable.
static <T, T1 extends Exception> T	checked(Class<T1> expectedExceptionClass, UnsafeSupplier<T> supplier)	Gracefully gets from an UnsafeSupplier.
static <T1 extends Exception, T2 extends Exception> void	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, UnsafeRunnable runnable)	Gracefully runs an UnsafeRunnable.
static <T, T1 extends Exception, T2 extends Exception> T	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, UnsafeSupplier<T> supplier)	Gracefully gets from an UnsafeSupplier.
static <T1 extends Exception, T2 extends Exception, T3 extends Exception> void	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, UnsafeRunnable runnable)	Gracefully runs an UnsafeRunnable.
static <T, T1 extends Exception, T2 extends Exception, T3 extends Exception> T	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, UnsafeSupplier<T> supplier)	Gracefully gets from an UnsafeSupplier.
static <T, T1 extends Exception, T2 extends Exception, T3 extends Exception> void	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, T argument, UnsafeConsumer<T> consumer)	Gracefully supplies a value to an UnsafeConsumer.
static <T, R, T1 extends Exception, T2 extends Exception, T3 extends Exception> R	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, T argument, UnsafeFunction<T,R> function)	Gracefully applies an UnsafeFunction.
static <T, U, T1 extends Exception, T2 extends Exception, T3 extends Exception> void	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, T firstArgument, U secondArgument, UnsafeBiConsumer<T,U> consumer)	Gracefully supplies a value to an UnsafeBiConsumer.
static <T, U, R, T1 extends Exception, T2 extends Exception, T3 extends Exception> R	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, T firstArgument, U secondArgument, UnsafeBiFunction<T,U,R> function)	Gracefully applies an UnsafeBiFunction.
static <T, T1 extends Exception, T2 extends Exception> void	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, T argument, UnsafeConsumer<T> consumer)	Gracefully supplies a value to an UnsafeConsumer.
static <T, R, T1 extends Exception, T2 extends Exception> R	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, T argument, UnsafeFunction<T,R> function)	Gracefully applies an UnsafeFunction.
static <T, U, T1 extends Exception, T2 extends Exception> void	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, T firstArgument, U secondArgument, UnsafeBiConsumer<T,U> consumer)	Gracefully supplies a value to an UnsafeBiConsumer.
static <T, U, R, T1 extends Exception, T2 extends Exception> R	checked(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, T firstArgument, U secondArgument, UnsafeBiFunction<T,U,R> function)	Gracefully applies an UnsafeBiFunction.
static <T, T1 extends Exception> void	checked(Class<T1> expectedExceptionClass, T argument, UnsafeConsumer<T> consumer)	Gracefully supplies a value to an UnsafeConsumer.
static <T, R, T1 extends Exception> R	checked(Class<T1> expectedExceptionClass, T argument, UnsafeFunction<T,R> function)	Gracefully applies an UnsafeFunction.
static <T, U, T1 extends Exception> void	checked(Class<T1> expectedExceptionClass, T firstArgument, U secondArgument, UnsafeBiConsumer<T,U> consumer)	Gracefully supplies a value to an UnsafeBiConsumer.
static <T, U, R, T1 extends Exception> R	checked(Class<T1> expectedExceptionClass, T firstArgument, U secondArgument, UnsafeBiFunction<T,U,R> function)	Gracefully applies an UnsafeBiFunction.
static Exception	checked(Throwable throwable)	Expects a Throwable to be a checked exception.
static <T extends Exception> T	checked(Throwable throwable, Class<T> expectedExceptionClass)	Expects a Throwable to be a specific checked exception.
static <T1 extends Exception, T2 extends Exception> T1	checked(Throwable throwable, Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2)	Expects a Throwable to be a specific checked exception.
static <T1 extends Exception, T2 extends Exception, T3 extends Exception> T1	checked(Throwable throwable, Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3)	Expects a Throwable to be a specific checked exception.
static <T> void	checked(T argument, UnsafeConsumer<T> consumer)	Gracefully supplies a value to an UnsafeConsumer.
static <T, R> R	checked(T argument, UnsafeFunction<T,R> function)	Gracefully applies an UnsafeFunction.
static <T, U> void	checked(T firstArgument, U secondArgument, UnsafeBiConsumer<T,U> consumer)	Gracefully supplies a value to an UnsafeBiConsumer.
static <T, U, R> R	checked(T firstArgument, U secondArgument, UnsafeBiFunction<T,U,R> function)	Gracefully applies an UnsafeBiFunction.
static <R> R	checkedInvocation(UnsafeSupplier<R> supplier)	Gracefully invokes a method or constructor.
static <R, T extends Exception> R	checkedInvocation(Class<T> expectedExceptionClass, UnsafeSupplier<R> supplier)	Gracefully invokes a method or constructor.
static <R, T1 extends Exception, T2 extends Exception> R	checkedInvocation(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, UnsafeSupplier<R> supplier)	Gracefully invokes a method or constructor.
static <R, T1 extends Exception, T2 extends Exception, T3 extends Exception> R	checkedInvocation(Class<T1> expectedExceptionClass1, Class<T2> expectedExceptionClass2, Class<T3> expectedExceptionClass3, UnsafeSupplier<R> supplier)	Gracefully invokes a method or constructor.
static <T extends AutoCloseable, R> R	initialize(T resource, UnsafeFunction<T,R> initializer)	Gracefully initializes a component that depends on an AutoCloseable resource, closing the resource and suppressing any close errors before rethrowing a checked exception if the component fails to initialize.
static void	suppress(UnsafeRunnable... tasks)	Runs a sequence of tasks with error suppression.
static void	suppress(Iterable<UnsafeRunnable> tasks)	Runs a sequence of tasks with error suppression.
static Throwable	suppress(Throwable throwable, UnsafeRunnable runnable)	Runs an UnsafeRunnable and adds any exception thrown as suppressed by an another exception.
static String	trace(Throwable e)	Gets a stack trace from a Throwable as a String.
static void	unchecked(UnsafeRunnable runnable)	Gracefully runs an UnsafeRunnable.
static void	unchecked(UnsafeRunnable runnable, String message)	Gracefully runs an UnsafeRunnable.
static <T> T	unchecked(UnsafeSupplier<T> supplier)	Gracefully gets from an UnsafeSupplier.
static <T> T	unchecked(UnsafeSupplier<T> supplier, String message)	Gracefully gets from an UnsafeSupplier.
static RuntimeException	unchecked(Throwable throwable)	Expects a Throwable to be an (unchecked) RuntimeException.
static RuntimeException	unchecked(Throwable throwable, String message)	Expects a Throwable to be an (unchecked) RuntimeException.
static <T> void	unchecked(T argument, UnsafeConsumer<T> consumer)	Gracefully supplies a value to an UnsafeConsumer.
static <T, R> R	unchecked(T argument, UnsafeFunction<T,R> function)	Gracefully applies an UnsafeFunction.
static <T, U> void	unchecked(T firstArgument, U secondArgument, UnsafeBiConsumer<T,U> consumer)	Gracefully supplies a value to an UnsafeBiConsumer.
static <T, U, R> R	unchecked(T firstArgument, U secondArgument, UnsafeBiFunction<T,U,R> function)	Gracefully applies an UnsafeBiFunction.
static <R> R	uncheckedInvocation(UnsafeSupplier<R> supplier)	Gracefully invokes a supplier assumed to wrap invocation.

Methods inherited from class java.lang.Object

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

Method Details

unchecked

public static RuntimeException unchecked(Throwable throwable)
                                  throws IllegalStateException,
Error

Expects a Throwable to be an (unchecked) RuntimeException.

This method may be used as an exception handler in situations where Throwable or one or more checked exceptions are thrown from a downstream invocation, but a checked exception must not be thrown from the interface being implemented and no special handling is specified.

 try {
        // something unsafe
 } catch (Throwable e) {
        throw IuException.unchecked(e);
 }
 

Parameters:

throwable - Any Throwable

Returns:

throwable if RuntimeException

Throws:

IllegalStateException - if throwable is a checked exception or custom throwable

Error - if throwable is an Error

unchecked

public static RuntimeException unchecked(Throwable throwable,
 String message)
                                  throws IllegalStateException,
Error

Expects a Throwable to be an (unchecked) RuntimeException.

This method may be used as an exception handler in situations where Throwable or one or more checked exceptions are thrown from a downstream invocation, but a checked exception must not be thrown from the interface being implemented and no special handling is specified.

 try {
        // something unsafe
 } catch (Throwable e) {
        throw IuException.unchecked(e);
 }
 

Parameters:

throwable - Any Throwable

message - Message to use with IllegalStateException if throwable is not a RuntimeException or Error

Returns:

throwable if RuntimeException

Throws:

IllegalStateException - if throwable is a checked exception or custom throwable

Error - if throwable is an Error

checked

public static Exception checked(Throwable throwable)
                         throws Error,
IllegalStateException

Expects a Throwable to be a checked exception.

This method may be used as an exception handler in situations where Throwable is thrown from a downstream invocation, but only exception may be thrown from the interface being implemented and special handling is not specified for custom throwables.

 try {
        // something unsafe
 } catch (Throwable e) {
        throw IuException.checked(e);
 }
 

Parameters:

throwable - Any Throwable

Returns:

throwable if Exception

Throws:

IllegalStateException - if throwable is a custom throwable

Error - if throwable is an Error

checked

public static <T extends Exception> T checked(Throwable throwable,
 Class<T> expectedExceptionClass)
                                       throws RuntimeException,
Error,
IllegalStateException

Expects a Throwable to be a specific checked exception.

This method may be used as an exception handler in situations where Throwable, Exception, or specific checked exceptions are thrown from a downstream invocation, but at least one of these must not be thrown from the interface being implemented and special handling is not specified for the unexpected throwable types.

 try {
        // something unsafe
 } catch (Throwable e) {
        throw IuException.checked(e, ACheckedException.class);
 }
 

Type Parameters:

T - Expected exception type

Parameters:

throwable - Any Throwable

expectedExceptionClass - Expected exception class

Returns:

throwable if instanceof T

Throws:

RuntimeException - if throwable is a RuntimeException

Error - if throwable is an Error

IllegalStateException - if throwable is custom or a checked exception other than T

checked

public static <T1 extends Exception,
T2 extends Exception>
T1 checked(Throwable throwable,
 Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2)
    throws T2,
RuntimeException,
Error,
IllegalStateException

Expects a Throwable to be a specific checked exception.

This method may be used as an exception handler in situations where Throwable, Exception, or specific checked exceptions are thrown from a downstream invocation, but at least one of these must not be thrown from the interface being implemented and special handling is not specified for the unexpected throwable types.

 try {
        // something unsafe
 } catch (Throwable e) {
        throw IuException.checked(e, ACheckedException.class, AnotherCheckedException.class);
 }
 

Type Parameters:

T1 - Expected exception type

T2 - Additional exception type that may be thrown

Parameters:

throwable - Any Throwable

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Additional exception class that may be thrown

Returns:

throwable if instanceof T1

Throws:

T2 - if throwable is T2

RuntimeException - if throwable is a RuntimeException

Error - if throwable is an Error

IllegalStateException - if throwable is custom or a checked exception other than T be thrown

checked

public static <T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
T1 checked(Throwable throwable,
 Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3)
    throws T2,
T3,
RuntimeException,
Error,
IllegalStateException

Expects a Throwable to be a specific checked exception.

This method may be used as an exception handler in situations where Throwable, Exception, or specific checked exceptions are thrown from a downstream invocation, but at least one of these must not be thrown from the interface being implemented and special handling is not specified for the unexpected throwable types.

 try {
        // something unsafe
 } catch (Throwable e) {
        throw IuException.checked(e, ACheckedException.class, AnotherCheckedException.class,
                        YetAnotherCheckedException.class);
 }
 

Type Parameters:

T1 - Expected exception type

T2 - Additional exception type that may be thrown

T3 - Additional exception type that may be thrown

Parameters:

throwable - Any Throwable

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Additional exception class that may be thrown

expectedExceptionClass3 - Additional exception class that may be thrown

Returns:

throwable if instanceof T1

Throws:

T2 - if throwable is T2

T3 - if throwable is T3

RuntimeException - if throwable is a RuntimeException

Error - if throwable is an Error

IllegalStateException - if throwable is custom or a checked exception other than T be thrown

uncheckedInvocation

public static <R> R uncheckedInvocation(UnsafeSupplier<R> supplier)

Gracefully invokes a supplier assumed to wrap invocation.

Handles InvocationTargetException by unwrapping the cause and re-throwing.

Handles other exceptions via unchecked(Throwable).

Type Parameters:

R - result type

Parameters:

supplier - UnsafeSupplier assumed to wrap invocation.

Returns:

result

checkedInvocation

public static <R> R checkedInvocation(UnsafeSupplier<R> supplier)
                               throws Exception

Gracefully invokes a method or constructor.

Handles InvocationTargetException by unwrapping the cause and re-throwing.

Handles other exceptions via checked(Throwable).

Type Parameters:

R - result type

Parameters:

supplier - UnsafeSupplier assumed to wrap invocation.

Returns:

result

Throws:

Exception - If invocation fails

checkedInvocation

public static <R,
T extends Exception> R checkedInvocation(Class<T> expectedExceptionClass,
 UnsafeSupplier<R> supplier)
                                                    throws T

Gracefully invokes a method or constructor.

Handles InvocationTargetException by unwrapping the cause and re-throwing.

Handles other exceptions via checked(Throwable, Class).

Type Parameters:

R - result type

T - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

supplier - UnsafeSupplier assumed to wrap invocation.

Returns:

result

Throws:

T - If invocation fails

checkedInvocation

public static <R,
T1 extends Exception,
T2 extends Exception>
R checkedInvocation(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 UnsafeSupplier<R> supplier)
             throws T1,
T2

Gracefully invokes a method or constructor.

Handles InvocationTargetException by unwrapping the cause and re-throwing.

Handles other exceptions via checked(Throwable, Class, Class).

Type Parameters:

R - result type

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

supplier - UnsafeSupplier assumed to wrap invocation.

Returns:

result

Throws:

T1 - If invocation fails

T2 - If invocation fails

checkedInvocation

public static <R,
T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
R checkedInvocation(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 UnsafeSupplier<R> supplier)
             throws T1,
T2,
T3

Gracefully invokes a method or constructor.

Handles InvocationTargetException by unwrapping the cause and re-throwing.

Handles other exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

R - result type

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

supplier - UnsafeSupplier assumed to wrap invocation.

Returns:

result

Throws:

T1 - If invocation fails

T2 - If invocation fails

T3 - If invocation fails

unchecked

public static void unchecked(UnsafeRunnable runnable)

Gracefully runs an UnsafeRunnable.

Handles exceptions via unchecked(Throwable).

Parameters:

runnable - Any UnsafeRunnable

unchecked

public static void unchecked(UnsafeRunnable runnable,
 String message)

Gracefully runs an UnsafeRunnable.

Handles exceptions via unchecked(Throwable).

Parameters:

runnable - Any UnsafeRunnable

message - message for use with unchecked(Throwable, String)

checked

public static void checked(UnsafeRunnable runnable)
                    throws Exception

Gracefully runs an UnsafeRunnable.

Handles exceptions via checked(Throwable).

Parameters:

runnable - Any UnsafeRunnable

Throws:

Exception - If thrown by UnsafeRunnable.run()

checked

public static <T extends Exception> void checked(Class<T> expectedExceptionClass,
 UnsafeRunnable runnable)
                                          throws T

Gracefully runs an UnsafeRunnable.

Handles exceptions via checked(Throwable, Class).

Type Parameters:

T - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

runnable - Any UnsafeRunnable

Throws:

T - If thrown by UnsafeRunnable.run()

checked

public static <T1 extends Exception,
T2 extends Exception>
void checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 UnsafeRunnable runnable)
      throws T1,
T2

Gracefully runs an UnsafeRunnable.

Handles exceptions via checked(Throwable, Class, Class).

Type Parameters:

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

runnable - Any UnsafeRunnable

Throws:

T1 - If thrown by UnsafeRunnable.run()

T2 - If thrown by UnsafeRunnable.run()

checked

public static <T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
void checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 UnsafeRunnable runnable)
      throws T1,
T2,
T3

Gracefully runs an UnsafeRunnable.

Handles exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

runnable - Any UnsafeRunnable

Throws:

T1 - If thrown by UnsafeRunnable.run()

T2 - If thrown by UnsafeRunnable.run()

T3 - If thrown by UnsafeRunnable.run()

unchecked

public static <T> T unchecked(UnsafeSupplier<T> supplier)

Gracefully gets from an UnsafeSupplier.

Handles exceptions via unchecked(Throwable).

Type Parameters:

T - result type

Parameters:

supplier - Any UnsafeSupplier

Returns:

result

unchecked

public static <T> T unchecked(UnsafeSupplier<T> supplier,
 String message)

Gracefully gets from an UnsafeSupplier.

Handles exceptions via unchecked(Throwable).

Type Parameters:

T - result type

Parameters:

supplier - Any UnsafeSupplier

message - Message to use with unchecked(Throwable, String)

Returns:

result

checked

public static <T> T checked(UnsafeSupplier<T> supplier)
                     throws Exception

Gracefully gets from an UnsafeSupplier.

Handles exceptions via checked(Throwable).

Type Parameters:

T - result type

Parameters:

supplier - Any UnsafeSupplier

Returns:

result

Throws:

Exception - If thrown by UnsafeSupplier.get()

checked

public static <T,
T1 extends Exception> T checked(Class<T1> expectedExceptionClass,
 UnsafeSupplier<T> supplier)
                                           throws T1

Gracefully gets from an UnsafeSupplier.

Handles exceptions via checked(Throwable, Class).

Type Parameters:

T - result type

T1 - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

supplier - Any UnsafeSupplier

Returns:

result

Throws:

T1 - If thrown by UnsafeSupplier.get()

checked

public static <T,
T1 extends Exception,
T2 extends Exception>
T checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 UnsafeSupplier<T> supplier)
   throws T1,
T2

Gracefully gets from an UnsafeSupplier.

Handles exceptions via checked(Throwable, Class, Class).

Type Parameters:

T - result type

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

supplier - Any UnsafeSupplier

Returns:

result

Throws:

T1 - If thrown by UnsafeSupplier.get()

T2 - If thrown by UnsafeSupplier.get()

checked

public static <T,
T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
T checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 UnsafeSupplier<T> supplier)
   throws T1,
T2,
T3

Gracefully gets from an UnsafeSupplier.

Handles exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

T - result type

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

supplier - Any UnsafeSupplier

Returns:

result

Throws:

T1 - If thrown by UnsafeSupplier.get()

T2 - If thrown by UnsafeSupplier.get()

T3 - If thrown by UnsafeSupplier.get()

unchecked

public static <T> void unchecked(T argument,
 UnsafeConsumer<T> consumer)

Gracefully supplies a value to an UnsafeConsumer.

Handles exceptions via unchecked(Throwable).

Type Parameters:

T - argument type

Parameters:

argument - Argument for UnsafeConsumer.accept(Object)

consumer - Any UnsafeConsumer

checked

public static <T> void checked(T argument,
 UnsafeConsumer<T> consumer)
                        throws Exception

Gracefully supplies a value to an UnsafeConsumer.

Handles exceptions via checked(Throwable).

Type Parameters:

T - argument type

Parameters:

argument - Argument for UnsafeConsumer.accept(Object)

consumer - Any UnsafeConsumer

Throws:

Exception - If thrown by UnsafeConsumer.accept(Object)

checked

public static <T,
T1 extends Exception> void checked(Class<T1> expectedExceptionClass,
 T argument,
 UnsafeConsumer<T> consumer)
                                              throws T1

Gracefully supplies a value to an UnsafeConsumer.

Handles exceptions via checked(Throwable, Class).

Type Parameters:

T - argument type

T1 - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

argument - Argument for UnsafeConsumer.accept(Object)

consumer - Any UnsafeConsumer

Throws:

T1 - If thrown by UnsafeConsumer.accept(Object)

checked

public static <T,
T1 extends Exception,
T2 extends Exception>
void checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 T argument,
 UnsafeConsumer<T> consumer)
      throws T1,
T2

Gracefully supplies a value to an UnsafeConsumer.

Handles exceptions via checked(Throwable, Class, Class).

Type Parameters:

T - argument type

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

argument - Argument for UnsafeConsumer.accept(Object)

consumer - Any UnsafeConsumer

Throws:

T1 - If thrown by UnsafeConsumer.accept(Object)

T2 - If thrown by UnsafeConsumer.accept(Object)

checked

public static <T,
T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
void checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 T argument,
 UnsafeConsumer<T> consumer)
      throws T1,
T2,
T3

Gracefully supplies a value to an UnsafeConsumer.

Handles exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

T - argument type

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

argument - Argument for UnsafeConsumer.accept(Object)

consumer - Any UnsafeConsumer

Throws:

T1 - If thrown by UnsafeConsumer.accept(Object)

T2 - If thrown by UnsafeConsumer.accept(Object)

T3 - If thrown by UnsafeConsumer.accept(Object)

unchecked

public static <T,
R> R unchecked(T argument,
 UnsafeFunction<T,R> function)

Gracefully applies an UnsafeFunction.

Handles exceptions via unchecked(Throwable).

Type Parameters:

T - argument type

R - result type

Parameters:

argument - Argument to UnsafeFunction.apply(Object)

function - Any UnsafeFunction

Returns:

result

checked

public static <T,
R> R checked(T argument,
 UnsafeFunction<T,R> function)
                        throws Exception

Gracefully applies an UnsafeFunction.

Handles exceptions via checked(Throwable).

Type Parameters:

T - argument type

R - result type

Parameters:

argument - Argument to UnsafeFunction.apply(Object)

function - Any UnsafeFunction

Returns:

result

Throws:

Exception - If thrown by UnsafeFunction.apply(Object)

checked

public static <T,
R,
T1 extends Exception> R checked(Class<T1> expectedExceptionClass,
 T argument,
 UnsafeFunction<T,R> function)
                                              throws T1

Gracefully applies an UnsafeFunction.

Handles exceptions via checked(Throwable, Class).

Type Parameters:

T - argument type

R - result type

T1 - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

argument - Argument to UnsafeFunction.apply(Object)

function - Any UnsafeFunction

Returns:

result

Throws:

T1 - If thrown by UnsafeFunction.apply(Object)

checked

public static <T,
R,
T1 extends Exception,
T2 extends Exception>
R checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 T argument,
 UnsafeFunction<T,R> function)
   throws T1,
T2

Gracefully applies an UnsafeFunction.

Handles exceptions via checked(Throwable, Class, Class).

Type Parameters:

T - argument type

R - result type

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

argument - Argument to UnsafeFunction.apply(Object)

function - Any UnsafeFunction

Returns:

result

Throws:

T1 - If thrown by UnsafeFunction.apply(Object)

T2 - If thrown by UnsafeFunction.apply(Object)

checked

public static <T,
R,
T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
R checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 T argument,
 UnsafeFunction<T,R> function)
   throws T1,
T2,
T3

Gracefully applies an UnsafeFunction.

Handles exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

T - argument type

R - result type

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

argument - Argument to UnsafeFunction.apply(Object)

function - Any UnsafeFunction

Returns:

result

Throws:

T1 - If thrown by UnsafeFunction.apply(Object)

T2 - If thrown by UnsafeFunction.apply(Object)

T3 - If thrown by UnsafeFunction.apply(Object)

unchecked

public static <T,
U> void unchecked(T firstArgument,
 U secondArgument,
 UnsafeBiConsumer<T,U> consumer)

Gracefully supplies a value to an UnsafeBiConsumer.

Handles exceptions via unchecked(Throwable).

Type Parameters:

T - first argument type

U - second argument type

Parameters:

firstArgument - First argument for UnsafeBiConsumer.accept(Object,Object)

secondArgument - Second argument for UnsafeBiConsumer.accept(Object,Object)

consumer - Any UnsafeBiConsumer

checked

public static <T,
U> void checked(T firstArgument,
 U secondArgument,
 UnsafeBiConsumer<T,U> consumer)
                           throws Exception

Gracefully supplies a value to an UnsafeBiConsumer.

Handles exceptions via checked(Throwable).

Type Parameters:

T - first argument type

U - second argument type

Parameters:

firstArgument - Argument for UnsafeBiConsumer.accept(Object,Object)

secondArgument - Second argument for UnsafeBiConsumer.accept(Object,Object)

consumer - Any UnsafeBiConsumer

Throws:

Exception - If thrown by UnsafeBiConsumer.accept(Object,Object)

checked

public static <T,
U,
T1 extends Exception> void checked(Class<T1> expectedExceptionClass,
 T firstArgument,
 U secondArgument,
 UnsafeBiConsumer<T,U> consumer)
                                                 throws T1

Gracefully supplies a value to an UnsafeBiConsumer.

Handles exceptions via checked(Throwable, Class).

Type Parameters:

T - first argument type

U - second argument type

T1 - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

firstArgument - Argument for UnsafeBiConsumer.accept(Object,Object)

secondArgument - Second argument for UnsafeBiConsumer.accept(Object,Object)

consumer - Any UnsafeBiConsumer

Throws:

T1 - If thrown by UnsafeBiConsumer.accept(Object,Object)

checked

public static <T,
U,
T1 extends Exception,
T2 extends Exception>
void checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 T firstArgument,
 U secondArgument,
 UnsafeBiConsumer<T,U> consumer)
      throws T1,
T2

Gracefully supplies a value to an UnsafeBiConsumer.

Handles exceptions via checked(Throwable, Class, Class).

Type Parameters:

T - first argument type

U - second argument type

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

firstArgument - Argument for UnsafeBiConsumer.accept(Object,Object)

secondArgument - Second argument for UnsafeBiConsumer.accept(Object,Object)

consumer - Any UnsafeBiConsumer

Throws:

T1 - If thrown by UnsafeBiConsumer.accept(Object,Object)

T2 - If thrown by UnsafeBiConsumer.accept(Object,Object)

checked

public static <T,
U,
T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
void checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 T firstArgument,
 U secondArgument,
 UnsafeBiConsumer<T,U> consumer)
      throws T1,
T2,
T3

Gracefully supplies a value to an UnsafeBiConsumer.

Handles exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

T - first argument type

U - second argument type

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

firstArgument - Argument for UnsafeBiConsumer.accept(Object,Object)

secondArgument - Second argument for UnsafeBiConsumer.accept(Object,Object)

consumer - Any UnsafeBiConsumer

Throws:

T1 - If thrown by UnsafeBiConsumer.accept(Object,Object)

T2 - If thrown by UnsafeBiConsumer.accept(Object,Object)

T3 - If thrown by UnsafeBiConsumer.accept(Object,Object)

unchecked

public static <T,
U,
R> R unchecked(T firstArgument,
 U secondArgument,
 UnsafeBiFunction<T,U,R> function)

Gracefully applies an UnsafeBiFunction.

Handles exceptions via unchecked(Throwable).

Type Parameters:

T - first argument type

U - second argument type

R - result type

Parameters:

firstArgument - First argument to UnsafeBiFunction.apply(Object, Object)

secondArgument - Second argument to UnsafeBiFunction.apply(Object, Object)

function - Any UnsafeFunction

Returns:

result

checked

public static <T,
U,
R> R checked(T firstArgument,
 U secondArgument,
 UnsafeBiFunction<T,U,R> function)
                           throws Exception

Gracefully applies an UnsafeBiFunction.

Handles exceptions via checked(Throwable).

Type Parameters:

T - first argument type

U - second argument type

R - result type

Parameters:

firstArgument - First argument to UnsafeBiFunction.apply(Object, Object)

secondArgument - Second argument to UnsafeBiFunction.apply(Object, Object)

function - Any UnsafeBiFunction

Returns:

result

Throws:

Exception - If thrown by UnsafeBiFunction.apply(Object, Object)

checked

public static <T,
U,
R,
T1 extends Exception> R checked(Class<T1> expectedExceptionClass,
 T firstArgument,
 U secondArgument,
 UnsafeBiFunction<T,U,R> function)
                                                 throws T1

Gracefully applies an UnsafeBiFunction.

Handles exceptions via checked(Throwable, Class).

Type Parameters:

T - first argument type

U - second argument type

R - result type

T1 - Expected exception type

Parameters:

expectedExceptionClass - Expected exception class

firstArgument - First argument to UnsafeBiFunction.apply(Object, Object)

secondArgument - Second argument to UnsafeBiFunction.apply(Object, Object)

function - Any UnsafeBiFunction

Returns:

result

Throws:

T1 - If thrown by UnsafeBiFunction.apply(Object, Object)

checked

public static <T,
U,
R,
T1 extends Exception,
T2 extends Exception>
R checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 T firstArgument,
 U secondArgument,
 UnsafeBiFunction<T,U,R> function)
   throws T1,
T2

Gracefully applies an UnsafeBiFunction.

Handles exceptions via checked(Throwable, Class, Class).

Type Parameters:

T - first argument type

U - second argument type

R - result type

T1 - Expected exception type

T2 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

firstArgument - First argument to UnsafeBiFunction.apply(Object, Object)

secondArgument - Second argument to UnsafeBiFunction.apply(Object, Object)

function - Any UnsafeBiFunction

Returns:

result

Throws:

T1 - If thrown by UnsafeBiFunction.apply(Object, Object)

T2 - If thrown by UnsafeBiFunction.apply(Object, Object)

checked

public static <T,
U,
R,
T1 extends Exception,
T2 extends Exception,
T3 extends Exception>
R checked(Class<T1> expectedExceptionClass1,
 Class<T2> expectedExceptionClass2,
 Class<T3> expectedExceptionClass3,
 T firstArgument,
 U secondArgument,
 UnsafeBiFunction<T,U,R> function)
   throws T1,
T2,
T3

Gracefully applies an UnsafeBiFunction.

Handles exceptions via checked(Throwable, Class, Class, Class).

Type Parameters:

T - first argument type

U - second argument type

R - result type

T1 - Expected exception type

T2 - Expected exception type

T3 - Expected exception type

Parameters:

expectedExceptionClass1 - Expected exception class

expectedExceptionClass2 - Expected exception class

expectedExceptionClass3 - Expected exception class

firstArgument - First argument to UnsafeBiFunction.apply(Object, Object)

secondArgument - Second argument to UnsafeBiFunction.apply(Object, Object)

function - Any UnsafeBiFunction

Returns:

result

Throws:

T1 - If thrown by UnsafeBiFunction.apply(Object, Object)

T2 - If thrown by UnsafeBiFunction.apply(Object, Object)

T3 - If thrown by UnsafeBiFunction.apply(Object, Object)

initialize

public static <T extends AutoCloseable,
R> R initialize(T resource,
 UnsafeFunction<T,R> initializer)
                                                 throws Exception

Gracefully initializes a component that depends on an AutoCloseable resource, closing the resource and suppressing any close errors before rethrowing a checked exception if the component fails to initialize.

If no exception or error is thrown by initializer, then the resource remains open, and becomes the responsibility of the initialized component to close when finished with it.

Type Parameters:

T - AutoCloseable resource type

R - UnsafeFunction dependent component type

Parameters:

resource - Open resource

initializer - UnsafeFunction for initializing the resource

Returns:

resource, after successfully invoking initializationConsumer

Throws:

Exception - If thrown from by initializationConsumer

suppress

public static Throwable suppress(Throwable throwable,
 UnsafeRunnable runnable)

Runs an UnsafeRunnable and adds any exception thrown as suppressed by an another exception.

This is useful for adding clean-up tasks to error handling routines related to failed initialization of closeable resources.

Parameters:

throwable - Throwable that will suppress exceptions thrown from runnable.

runnable - UnsafeRunnable; will be run, and any exceptions thrown will be suppressed by throwable

Returns:

throwable if non-null; the exception thrown from runnable or null if no exception was thrown

suppress

public static void suppress(UnsafeRunnable... tasks)
                     throws Throwable

Runs a sequence of tasks with error suppression.

All tasks are guaranteed to run, but not guaranteed to finish. After all tasks have run, the first error encountered will be thrown; all additional errors will be suppressed.

Parameters:

tasks - tasks to run

Throws:

Throwable - from the first task the fails in error

suppress

public static void suppress(Iterable<UnsafeRunnable> tasks)
                     throws Throwable

Runs a sequence of tasks with error suppression.

All tasks are guaranteed to run, but not guaranteed to finish. After all tasks have run, the first error encountered will be thrown; all additional errors will be suppressed.

Parameters:

tasks - tasks to run

Throws:

Throwable - from the first task the fails in error

trace

public static String trace(Throwable e)

Gets a stack trace from a Throwable as a String.

Parameters:

e - Throwable

Returns:

String representation of the stack trace.