Exceptional (io.earcam.unexceptional 1.0.0 API)

java.lang.Object
- io.earcam.unexceptional.Exceptional

All Implemented Interfaces:

Serializable
```
public final class Exceptional
extends Object
implements Serializable
```
Static utility for easy conversion of checked exceptions, and invocation of methods declaring checked exceptions.

There are many cases where you know, within a given context that a checked exception will not be raised, but if it is, then it's certainly game over. An example being URLs in server configuration.

The functionality centres around java.util.function given their beautifully broad application.

In addition, common standard library annoyances are included; e.g. URL, URI, and highly concise (re-read as terse one-liner - arguably laconic over expressive) for common IO streams usage.

When dealing with Stream from an IO source (e.g. the file system), it may be preferable (to pay a performance cost due to wrapping) and use EmeticStream which mirrors Stream functionality but with checked equivalent types.

Exceptional
/ɪkˈsɛpʃ(ə)n(ə)l,ɛkˈsɛpʃ(ə)n(ə)l/
adjective:

1. unusual; not typical.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static Thread.UncaughtExceptionHandler`	`RETHROWING` An `Thread.UncaughtExceptionHandler` that simply rethrows, wrapping in an appropriate unchecked if necessary
`static Thread.UncaughtExceptionHandler`	`SWALLOWING` An `Thread.UncaughtExceptionHandler` that simply swallows all exceptions, except subclasses of `Error`, which are rethrown.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T,U> void`	`accept(CheckedBiConsumer<T,U,?> consumer, T t, U u)` Invokes `CheckedConsumer.accept(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T> void`	`accept(CheckedConsumer<T,?> consumer, T value)` Invokes `CheckedConsumer.accept(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static void`	`accept(CheckedIntConsumer<?> consumer, int value)` Invokes `CheckedIntConsumer.accept(int)` catching any checked `Exception`s rethrowing as unchecked.
`static <T,U,R> R`	`apply(CheckedBiFunction<T,U,R,?> function, T t, U u)` Invokes `CheckedFunction.apply(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T,R> R`	`apply(CheckedFunction<T,R,?> function, T argument)` Invokes `CheckedFunction.apply(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T> double`	`applyAsDouble(CheckedToDoubleFunction<T,?> function, T t)` Invokes `CheckedToDoubleFunction.applyAsDouble(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T,U> int`	`applyAsInt(CheckedToIntBiFunction<T,U,?> function, T t, U u)` Invokes `CheckedFunction.apply(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T> int`	`applyAsInt(CheckedToIntFunction<T,?> function, T t)` Invokes `CheckedToIntFunction.applyAsInt(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T> long`	`applyAsLong(CheckedToLongFunction<T,?> function, T t)` Invokes `CheckedToLongFunction.applyAsLong(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static <T> T`	`call(Callable<T> callable)` Invokes `Callable.call()` catching any checked `Exception`s rethrowing as unchecked.
`static <T> void`	`forEach(Iterable<T> iterable, CheckedConsumer<T,?> consumer)` Invokes the `Iterable.forEach(Consumer)` method having unchecked the consumer
`static <K,V> void`	`forEach(Map<K,V> map, CheckedBiConsumer<K,V,?> consumer)` Invokes the `Map.forEach(BiConsumer)` method having unchecked the bi-consumer
`static <T> T`	`get(CheckedSupplier<T,?> supplier)` Invokes `CheckedSupplier.get()` catching any checked `Exception`s rethrowing as unchecked.
`static void`	`resetIfInterrupt(Throwable thrown)` Catching an `InterruptedException` clears the interrupt flag, this merely resets the flag IFF the `thrown` parameter is an instance of `InterruptedException`.
`static RuntimeException`	`rethrow(Throwable thrown)` Directly rethrows `Error`s or `RuntimeException`s, wraps checked exceptions appropriately
`static void`	`run(CheckedRunnable<?> runnable)` Invokes `CheckedRunnable.run()` catching any checked `Exception`s rethrowing them as unchecked.
`static void`	`swallow(Throwable caught)` Will regurgitate any `Error` - otherwise will dutifully and silently swallow whole.
`static <T> boolean`	`test(CheckedPredicate<T,?> predicate, T value)` Invokes `CheckedPredicate.test(Object)` catching any checked `Exception`s rethrowing as unchecked.
`static RuntimeException`	`throwAsUnchecked(Throwable throwable)` This fugly method relies on erasure to trick the compiler, allowing you to throw any checked exception without declaring so on the surrounding method.
`static RuntimeException`	`uncheck(Throwable caught)` Converts `Throwable`s to `RuntimeException`s.
`static <T,U> BiConsumer<T,U>`	`uncheckBiConsumer(CheckedBiConsumer<T,U,?> consumer)` Convert a `CheckedBiConsumer` into a `BiConsumer`.
`static <T,U,R> BiFunction<T,U,R>`	`uncheckBiFunction(CheckedBiFunction<T,U,R,?> function)` Convert a `CheckedBiFunction` into a `BiFunction`.
`static <T> BinaryOperator<T>`	`uncheckBinaryOperator(CheckedBinaryOperator<T,?> operator)` Converts a `CheckedBinaryOperator` into a `BinaryOperator`.
`static <T> Comparator<T>`	`uncheckComparator(CheckedComparator<T,?> comparator)` Converts a `CheckedComparator` into an unchecked `Comparator`.
`static <T> Consumer<T>`	`uncheckConsumer(CheckedConsumer<T,?> consumer)` Converts `CheckedConsumer` to `Consumer`
`static <T,R> Function<T,R>`	`uncheckFunction(CheckedFunction<T,R,?> function)` Converts a `CheckedFunction` into a `Function`.
`static IntConsumer`	`uncheckIntConsumer(CheckedIntConsumer<?> consumer)` Converts `CheckedIntConsumer` to `IntConsumer`
`static <T> Predicate<T>`	`uncheckPredicate(CheckedPredicate<T,?> predicate)` Converts a `CheckedPredicate` into a `Predicate`.
`static Runnable`	`uncheckRunnable(CheckedRunnable<?> runnable)` Convert a `CheckedRunnable` into a `Runnable`
`static <T> Supplier<T>`	`uncheckSupplier(CheckedSupplier<T,?> supplier)` Convert a `CheckedSupplier` into an unchecked `Supplier`.
`static <T> ToDoubleFunction<T>`	`uncheckToDoubleFunction(CheckedToDoubleFunction<T,?> function)` Converts a `CheckedToDoubleFunction` into a `ToDoubleFunction`.
`static <T,U> ToIntBiFunction<T,U>`	`uncheckToIntBiFunction(CheckedToIntBiFunction<T,U,?> function)` Converts a `CheckedToIntBiFunction` into an unchecked `ToIntBiFunction`.
`static <T> ToIntFunction<T>`	`uncheckToIntFunction(CheckedToIntFunction<T,?> function)` Converts a `CheckedToIntFunction` into a `ToIntFunction`.
`static <T> ToLongFunction<T>`	`uncheckToLongFunction(CheckedToLongFunction<T,?> function)` Converts a `CheckedToLongFunction` into a `ToLongFunction`.
`static Throwable`	`unwrap(InvocationTargetException throwable)` Recursively find the wrapped throwable
`static Throwable`	`unwrap(Throwable throwable)` Attempts to unwrap invocation and unchecked exceptions to their underlying cause.
`static Throwable`	`unwrap(UndeclaredThrowableException throwable)` Recursively find the wrapped throwable
`static URI`	`uri(CharSequence ʊri)`
`static URI`	`uri(URL earl)` Invokes `URL.toURI()`, catching any `URISyntaxException` and rethrowing wrapped as `UncheckedUriSyntaxException`
`static URL`	`url(CharSequence earl)`
`static URL`	`url(String protocol, String host, int port, String path, URLStreamHandler handler)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - RETHROWING
```
public static final Thread.UncaughtExceptionHandler RETHROWING
```
    An Thread.UncaughtExceptionHandler that simply rethrows, wrapping in an appropriate unchecked if necessary
    
    Since:
    
    0.2.0
  - SWALLOWING
```
public static final Thread.UncaughtExceptionHandler SWALLOWING
```
    An Thread.UncaughtExceptionHandler that simply swallows all exceptions, except subclasses of Error, which are rethrown.
    
    Since:
    
    0.2.0
- Method Detail
  - url
```
public static URL url(CharSequence earl)
```
    Parameters:
    
    earl - the text URL
    
    Returns:
    
    a URL representation
    
    Since:
    
    0.2.0
  - url
```
public static URL url(String protocol,
                      String host,
                      int port,
                      String path,
                      URLStreamHandler handler)
```
    Parameters:
    
    protocol - e.g. https, ftp, sctp
    
    host - hostname or IP
    
    port - 0 to 65536
    
    path - the "file" portion of the URL
    
    handler - optional URLStreamHandler
    
    Returns:
    
    a URL representation
    
    Since:
    
    0.2.0
  - uri
```
public static URI uri(CharSequence ʊri)
```
    Parameters:
    
    ʊri - the text URI (as Earl is to URL, so ʊri (as in Uri Geller) is to URI)
    
    Returns:
    
    a URI representation
    
    Since:
    
    0.2.0
  - uri
```
public static URI uri(URL earl)
```
    Invokes URL.toURI(), catching any URISyntaxException and rethrowing wrapped as UncheckedUriSyntaxException
    
    Parameters:
    
    earl - the URL to convert
    
    Returns:
    
    the URI form of the earl argument
    
    Since:
    
    0.3.0
  - swallow
```
public static void swallow(Throwable caught)
```
    Will regurgitate any Error - otherwise will dutifully and silently swallow whole. Gulping of InterruptedExceptions will result in the current Thread's interrupt flag being reset. Caution: used carelessly/incorrectly this foul method will inevitably lead to a frustrating debugging session resulting in plenty of "doh"/"wtf" but never a "eureka" moment. Shooting of messenger is in breach of license terms.
    
    Parameters:
    
    caught - the caught unmentionable
    
    Since:
    
    0.2.0
  - resetIfInterrupt
```
public static void resetIfInterrupt(Throwable thrown)
```
    Catching an InterruptedException clears the interrupt flag, this merely resets the flag IFF the thrown parameter is an instance of InterruptedException.
    
    Parameters:
    
    thrown - possible InterruptedException
    
    Since:
    
    0.2.0
  - rethrow
```
public static RuntimeException rethrow(Throwable thrown)
```
    Directly rethrows Errors or RuntimeExceptions, wraps checked exceptions appropriately
    
    Parameters:
    
    thrown - the caught throwable to be rethrown as unchecked
    
    Returns:
    
    actually nothing, this just allows you to write throw Exceptional.rethrow(e) for methods than have return values.
    
    Since:
    
    0.2.0
    
    See Also:
    
    throwAsUnchecked(Throwable)
  - run
```
public static void run(CheckedRunnable<?> runnable)
```
    Invokes CheckedRunnable.run() catching any checked Exceptions rethrowing them as unchecked.
    
    Parameters:
    
    runnable - the checked runnable to run
    
    Since:
    
    0.2.0
  - uncheckRunnable
```
public static Runnable uncheckRunnable(CheckedRunnable<?> runnable)
```
    Convert a CheckedRunnable into a Runnable
    
    Parameters:
    
    runnable - the checked runnable to wrap
    
    Returns:
    
    an unchecked wrapper around the runnable argument
    
    Since:
    
    0.2.0
  - call
```
public static <T> T call(Callable<T> callable)
```
    Invokes Callable.call() catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - the return type of the Callable
    
    Parameters:
    
    callable - the Callable to execute
    
    Returns:
    
    the result of calling the Callable
    
    Since:
    
    0.2.0
  - uncheck
```
public static RuntimeException uncheck(Throwable caught)
```
    Converts Throwables to RuntimeExceptions.
    
    If the supplied Throwable is already a RuntimeException, then it's simply cast and returned.
    
    Error subclasses will be wrapped in an UncheckedException.
    
    The interrupt flag will be reset IFF caught instanceof InterruptedException
    
    Parameters:
    
    caught - any Throwable
    
    Returns:
    
    a RuntimeException, typically a subclass of UncheckedException or an UncheckedIOException
    
    Since:
    
    0.2.0
    
    See Also:
    
    rethrow(Throwable)
  - uncheckConsumer
```
public static <T> Consumer<T> uncheckConsumer(CheckedConsumer<T,?> consumer)
```
    Converts CheckedConsumer to Consumer
    
    Type Parameters:
    
    T - the consumed type
    
    Parameters:
    
    consumer - a consumer that declares checked exception(s)
    
    Returns:
    
    a vanilla Consumer
    
    Since:
    
    0.2.0
  - accept
```
public static <T> void accept(CheckedConsumer<T,?> consumer,
                              T value)
```
    Invokes CheckedConsumer.accept(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - the consumed type
    
    Parameters:
    
    consumer - the consumer of the value
    
    value - the value to be consumed
    
    Since:
    
    0.2.0
  - uncheckIntConsumer
```
public static IntConsumer uncheckIntConsumer(CheckedIntConsumer<?> consumer)
```
    Converts CheckedIntConsumer to IntConsumer
    
    Parameters:
    
    consumer - a consumer of primitive integer that declares checked exception(s)
    
    Returns:
    
    a vanilla IntConsumer
    
    Since:
    
    0.5.0
  - accept
```
public static void accept(CheckedIntConsumer<?> consumer,
                          int value)
```
    Invokes CheckedIntConsumer.accept(int) catching any checked Exceptions rethrowing as unchecked.
    
    Parameters:
    
    consumer - the consumer of the int value
    
    value - the value to be consumed
    
    Since:
    
    0.5.0
  - uncheckBiConsumer
```
public static <T,U> BiConsumer<T,U> uncheckBiConsumer(CheckedBiConsumer<T,U,?> consumer)
```
    Convert a CheckedBiConsumer into a BiConsumer.
    
    Type Parameters:
    
    T - first argument type
    
    U - last argument type
    
    Parameters:
    
    consumer - the checked consumer
    
    Returns:
    
    an unchecked consumer wrapping the consumer argument
    
    Since:
    
    0.2.0
  - accept
```
public static <T,U> void accept(CheckedBiConsumer<T,U,?> consumer,
                                T t,
                                U u)
```
    Invokes CheckedConsumer.accept(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - first argument type
    
    U - last argument type
    
    Parameters:
    
    consumer - the consumer of the value
    
    t - first argument to be consumed
    
    u - last argument to be consumed
    
    Since:
    
    0.2.0
  - uncheckFunction
```
public static <T,R> Function<T,R> uncheckFunction(CheckedFunction<T,R,?> function)
```
    Converts a CheckedFunction into a Function.
    
    Type Parameters:
    
    T - argument type
    
    R - return type
    
    Parameters:
    
    function - the checked function
    
    Returns:
    
    an unchecked function wrapping the function argument.
    
    Since:
    
    0.2.0
  - apply
```
public static <T,R> R apply(CheckedFunction<T,R,?> function,
                            T argument)
```
    Invokes CheckedFunction.apply(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - argument type
    
    R - return type
    
    Parameters:
    
    function - the checked function to invoke with the argument
    
    argument - the argument to apply to the function
    
    Returns:
    
    the result of applying argument to function
    
    Since:
    
    0.2.0
  - uncheckBiFunction
```
public static <T,U,R> BiFunction<T,U,R> uncheckBiFunction(CheckedBiFunction<T,U,R,?> function)
```
    Convert a CheckedBiFunction into a BiFunction.
    
    Type Parameters:
    
    T - first argument type
    
    U - last argument type
    
    R - return type
    
    Parameters:
    
    function - the checked bi-function
    
    Returns:
    
    an unchecked bi-function wrapping the function argument.
    
    Since:
    
    0.2.0
  - apply
```
public static <T,U,R> R apply(CheckedBiFunction<T,U,R,?> function,
                              T t,
                              U u)
```
    Invokes CheckedFunction.apply(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - first argument type
    
    U - last argument type
    
    R - return type
    
    Parameters:
    
    function - the checked function to invoke with the argument
    
    t - the first argument to apply to the function
    
    u - the second argument to apply to the function
    
    Returns:
    
    the result of applying function to the arguments t and u
    
    Since:
    
    0.2.0
  - uncheckBinaryOperator
```
public static <T> BinaryOperator<T> uncheckBinaryOperator(CheckedBinaryOperator<T,?> operator)
```
    Converts a CheckedBinaryOperator into a BinaryOperator.
    
    Type Parameters:
    
    T - operator type
    
    Parameters:
    
    operator - the checked binary operator
    
    Returns:
    
    and unchecked wrapper around the operator argument
    
    Since:
    
    0.2.0
  - uncheckToDoubleFunction
```
public static <T> ToDoubleFunction<T> uncheckToDoubleFunction(CheckedToDoubleFunction<T,?> function)
```
    Converts a CheckedToDoubleFunction into a ToDoubleFunction.
    
    Type Parameters:
    
    T - argument type
    
    Parameters:
    
    function - the checked to-double-function
    
    Returns:
    
    an unchecked to-double-function wrapping the function argument.
    
    Since:
    
    0.2.0
  - applyAsDouble
```
public static <T> double applyAsDouble(CheckedToDoubleFunction<T,?> function,
                                       T t)
```
    Invokes CheckedToDoubleFunction.applyAsDouble(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - argument type
    
    Parameters:
    
    function - the checked to-double function
    
    t - the function argument
    
    Returns:
    
    the double result of applying the function to argument t
    
    Since:
    
    0.2.0
  - uncheckToIntFunction
```
public static <T> ToIntFunction<T> uncheckToIntFunction(CheckedToIntFunction<T,?> function)
```
    Converts a CheckedToIntFunction into a ToIntFunction.
    
    Type Parameters:
    
    T - argument type
    
    Parameters:
    
    function - the checked to-int-function
    
    Returns:
    
    an unchecked to-int-function wrapping the function argument.
    
    Since:
    
    0.2.0
  - applyAsInt
```
public static <T> int applyAsInt(CheckedToIntFunction<T,?> function,
                                 T t)
```
    Invokes CheckedToIntFunction.applyAsInt(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - argument type
    
    Parameters:
    
    function - the checked to-int function
    
    t - the function argument
    
    Returns:
    
    the int result of applying the function to argument t
    
    Since:
    
    0.2.0
  - uncheckToLongFunction
```
public static <T> ToLongFunction<T> uncheckToLongFunction(CheckedToLongFunction<T,?> function)
```
    Converts a CheckedToLongFunction into a ToLongFunction.
    
    Type Parameters:
    
    T - argument type
    
    Parameters:
    
    function - the checked to-long-function
    
    Returns:
    
    an unchecked to-long-function wrapping the function argument.
    
    Since:
    
    0.2.0
  - applyAsLong
```
public static <T> long applyAsLong(CheckedToLongFunction<T,?> function,
                                   T t)
```
    Invokes CheckedToLongFunction.applyAsLong(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - argument type
    
    Parameters:
    
    function - the checked to-long function
    
    t - the function argument
    
    Returns:
    
    the long result of applying the function to argument t
    
    Since:
    
    0.2.0
  - uncheckSupplier
```
public static <T> Supplier<T> uncheckSupplier(CheckedSupplier<T,?> supplier)
```
    Convert a CheckedSupplier into an unchecked Supplier.
    
    Type Parameters:
    
    T - supplied type
    
    Parameters:
    
    supplier - the checked supplier to wrap
    
    Returns:
    
    an unchecked supplier wrapping the supplier argument
    
    Since:
    
    0.2.0
  - get
```
public static <T> T get(CheckedSupplier<T,?> supplier)
```
    Invokes CheckedSupplier.get() catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - supplied type
    
    Parameters:
    
    supplier - the checked supplier
    
    Returns:
    
    the result as supplied from the supplier argument
    
    Since:
    
    0.2.0
  - uncheckPredicate
```
public static <T> Predicate<T> uncheckPredicate(CheckedPredicate<T,?> predicate)
```
    Converts a CheckedPredicate into a Predicate.
    
    Type Parameters:
    
    T - tested type
    
    Parameters:
    
    predicate - the checked predicate to wrap
    
    Returns:
    
    an unchecked predicate wrapping the predicate argument
    
    Since:
    
    0.2.0
  - test
```
public static <T> boolean test(CheckedPredicate<T,?> predicate,
                               T value)
```
    Invokes CheckedPredicate.test(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - tested type
    
    Parameters:
    
    predicate - the checked predicate to test on the value
    
    value - the value to be tested
    
    Returns:
    
    true IFF value passes predicate's test
    
    Since:
    
    0.2.0
  - uncheckComparator
```
public static <T> Comparator<T> uncheckComparator(CheckedComparator<T,?> comparator)
```
    Converts a CheckedComparator into an unchecked Comparator.
    
    Type Parameters:
    
    T - compared type
    
    Parameters:
    
    comparator - the checked comparator to wrap
    
    Returns:
    
    an unchecked comparator wrapping the comparator argument
    
    Since:
    
    0.2.0
  - uncheckToIntBiFunction
```
public static <T,U> ToIntBiFunction<T,U> uncheckToIntBiFunction(CheckedToIntBiFunction<T,U,?> function)
```
    Converts a CheckedToIntBiFunction into an unchecked ToIntBiFunction.
    
    Type Parameters:
    
    T - first argument type
    
    U - last argument type
    
    Parameters:
    
    function - the checked bi-function
    
    Returns:
    
    an unchecked bi-function
  - applyAsInt
```
public static <T,U> int applyAsInt(CheckedToIntBiFunction<T,U,?> function,
                                   T t,
                                   U u)
```
    Invokes CheckedFunction.apply(Object) catching any checked Exceptions rethrowing as unchecked.
    
    Type Parameters:
    
    T - first argument type
    
    U - last argument type
    
    Parameters:
    
    function - the checked function to invoke with the argument
    
    t - the first argument to apply to the function
    
    u - the second argument to apply to the function
    
    Returns:
    
    the result of applying function to the arguments t and u
    
    Since:
    
    0.2.0
  - throwAsUnchecked
```
public static RuntimeException throwAsUnchecked(Throwable throwable)
```
    This fugly method relies on erasure to trick the compiler, allowing you to throw any checked exception without declaring so on the surrounding method. You are almost certainly better off using rethrow(Throwable).
    
    Note: this may well become an obsolete hack in future versions of Java if generics change.
    
    Parameters:
    
    throwable - the Throwable to be thrown
    
    Returns:
    
    this alleged return will never be received, but useful in that you may write throws throwAsUnchecked(Throwable); to placate the compiler WRT non-void method returns, and ensure Static Code Analysis doesn't accuse you of swallowing the exception.
    
    Since:
    
    0.2.0
    
    See Also:
    
    rethrow(Throwable)
  - unwrap
```
public static Throwable unwrap(Throwable throwable)
```
    Attempts to unwrap invocation and unchecked exceptions to their underlying cause. Unwrapping is recursively applied. The original wrapper exception is added to the suppressed throwables of the returned unwrapped throwable.
    
    Unwraps: InvocationTargetException, UndeclaredThrowableException, UncheckedIOException and UncheckedException
    
    Parameters:
    
    throwable - to be unwrapped
    
    Returns:
    
    the root cause, or original throwable if not unwrapped
    
    Since:
    
    0.2.0
  - unwrap
```
public static Throwable unwrap(UndeclaredThrowableException throwable)
```
    Recursively find the wrapped throwable
    NOTE: this method now just delegates to unwrap(Throwable) and is therefore superfluous, as such it will be removed in the next major release without impact to client code; given this, it is not marked Deprecated to avoid unnecessary upcasting to Throwable.
    
    Parameters:
    
    throwable - to be unwrapped
    
    Returns:
    
    the value of UndeclaredThrowableException.getUndeclaredThrowable()
    
    Since:
    
    0.2.0
    
    See Also:
    
    unwrap(Throwable)
  - unwrap
```
public static Throwable unwrap(InvocationTargetException throwable)
```
    Recursively find the wrapped throwable
    NOTE: this method now just delegates to unwrap(Throwable) and is therefore superfluous, as such it will be removed in the next major release without impact to client code; given this, it is not marked Deprecated to avoid unnecessary upcasting to Throwable.
    
    Parameters:
    
    throwable - to be unwrapped
    
    Returns:
    
    the value of InvocationTargetException.getTargetException()
    
    Since:
    
    0.2.0
  - forEach
```
public static <T> void forEach(Iterable<T> iterable,
                               CheckedConsumer<T,?> consumer)
```
    Invokes the Iterable.forEach(Consumer) method having unchecked the consumer
    
    Type Parameters:
    
    T - the consumed Iterable's element type
    
    Parameters:
    
    iterable - the Iterable to consume each element of
    
    consumer - the checked consumer of the Iterable's elements
    
    Since:
    
    0.4.0
    
    See Also:
    
    uncheckConsumer(CheckedConsumer)
  - forEach
```
public static <K,V> void forEach(Map<K,V> map,
                                 CheckedBiConsumer<K,V,?> consumer)
```
    Invokes the Map.forEach(BiConsumer) method having unchecked the bi-consumer
    
    Type Parameters:
    
    K - the consumed Map's key type
    
    V - the consumed Map's value type
    
    Parameters:
    
    map - the entries to consume
    
    consumer - the consumer of the map's key value pairs
    
    Since:
    
    0.4.0
    
    See Also:
    
    uncheckBiConsumer(CheckedBiConsumer)

Class Exceptional

Exceptional

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

RETHROWING

SWALLOWING

Method Detail

url

url

uri

uri

swallow

resetIfInterrupt

rethrow

run

uncheckRunnable

call

uncheck

uncheckConsumer

accept

uncheckIntConsumer

accept

uncheckBiConsumer

accept

uncheckFunction

apply

uncheckBiFunction

apply

uncheckBinaryOperator

uncheckToDoubleFunction

applyAsDouble

uncheckToIntFunction

applyAsInt

uncheckToLongFunction

applyAsLong

uncheckSupplier

get

uncheckPredicate

test

uncheckComparator

uncheckToIntBiFunction

applyAsInt

throwAsUnchecked

unwrap

unwrap

unwrap

forEach

forEach