ErrorHandler (errorhandler 1.1.0 API)

java.lang.Object
- com.workable.errorhandler.ErrorHandler

```
public class ErrorHandler
extends java.lang.Object
```
An ErrorHandler is responsible for handling an error by executing one or more actions, instances of Action, that are found to match the error.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ErrorHandler`	`always(Action action)` Register `action` to be executed on all errors.
`<T> ErrorHandler`	`bind(T errorCode, MatcherFactory<? super T> matcherFactory)` Bind an `errorCode` to a `Matcher`, using a `MatcherFactory`.
`<T> ErrorHandler`	`bindClass(java.lang.Class<T> errorCodeClass, MatcherFactory<? super T> matcherFactory)` Bind an `errorCode` `Class` to a `Matcher`, using a `MatcherFactory`.
`void`	`clear()` Clear ErrorHandler instance from all its registered Actions and Matchers.
`static ErrorHandler`	`create()` Create a new @{link ErrorHandler}, that delegates to the default one.
`static ErrorHandler`	`createIsolated()` Create a new @{link ErrorHandler}, isolated from the default one.
`static ErrorHandler`	`defaultErrorHandler()` Get the default @{link ErrorHandler}, a singleton object to which all other instances by default delegate to.
`protected <T> MatcherFactory<? super T>`	`getMatcherFactoryForErrorCode(T errorCode)`
`void`	`handle(java.lang.Throwable error)` Handle `error` by executing all matching actions.
`protected void`	`handle(java.lang.Throwable error, java.lang.ThreadLocal<com.workable.errorhandler.ErrorHandler.Context> context)`
`ErrorHandler`	`on(java.lang.Class<? extends java.lang.Exception> exceptionClass, Action action)` Register `action` to be executed by `handle(Throwable)`, if the thrown error is an instance of `exceptionClass`.
`ErrorHandler`	`on(Matcher matcher, Action action)` Register `action` to be executed by `handle(Throwable)`, if the thrown error matches the `matcher`.
`<T> ErrorHandler`	`on(T errorCode, Action action)` Register `action` to be executed by `handle(Throwable)`, if the thrown error is bound (associated) to `errorCode`.
`ErrorHandler`	`otherwise(Action action)` Register `action` to be executed in case no other conditional action gets executed.
`void`	`run(BlockExecutor blockExecutor)` Run a custom code block and assign current ErrorHandler instance to handle a possible exception throw in 'catch'.
`ErrorHandler`	`skipAlways()` Skip all actions registered via `always(Action)`
`ErrorHandler`	`skipDefaults()` Skip the default matching actions if any
`ErrorHandler`	`skipFollowing()` Skip all following actions registered via an `on` method

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

- Method Detail
  - createIsolated
```
public static ErrorHandler createIsolated()
```
    Create a new @{link ErrorHandler}, isolated from the default one.
    In other words, designed to handle all errors by itself without delegating to the default error handler.
    
    Returns:
    
    returns a new ErrorHandler instance
  - create
```
public static ErrorHandler create()
```
    Create a new @{link ErrorHandler}, that delegates to the default one.
    Any default actions, are always executed after the ones registered on this one.
    
    Returns:
    
    returns a new ErrorHandler instance
  - defaultErrorHandler
```
public static ErrorHandler defaultErrorHandler()
```
    Get the default @{link ErrorHandler}, a singleton object to which all other instances by default delegate to.
    
    Returns:
    
    the default @{link ErrorHandler} instance
  - on
```
public ErrorHandler on(Matcher matcher,
                       Action action)
```
    Register action to be executed by handle(Throwable), if the thrown error matches the matcher.
    
    Parameters:
    
    matcher - a matcher to match the thrown error
    
    action - the associated action
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - on
```
public ErrorHandler on(java.lang.Class<? extends java.lang.Exception> exceptionClass,
                       Action action)
```
    Register action to be executed by handle(Throwable), if the thrown error is an instance of exceptionClass.
    
    Parameters:
    
    exceptionClass - the class of the error
    
    action - the associated action
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - on
```
public <T> ErrorHandler on(T errorCode,
                           Action action)
```
    Register action to be executed by handle(Throwable), if the thrown error is bound (associated) to errorCode.
    See bindClass(Class, MatcherFactory) and bind(Object, MatcherFactory) on how to associate arbitrary error codes with actual Throwables via Matcher.
    
    Type Parameters:
    
    T - the error code type
    
    Parameters:
    
    errorCode - the error code
    
    action - the associated action
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - otherwise
```
public ErrorHandler otherwise(Action action)
```
    Register action to be executed in case no other conditional action gets executed.
    
    Parameters:
    
    action - the action
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - always
```
public ErrorHandler always(Action action)
```
    Register action to be executed on all errors.
    
    Parameters:
    
    action - the action
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - skipFollowing
```
public ErrorHandler skipFollowing()
```
    Skip all following actions registered via an on method
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - skipAlways
```
public ErrorHandler skipAlways()
```
    Skip all actions registered via always(Action)
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - skipDefaults
```
public ErrorHandler skipDefaults()
```
    Skip the default matching actions if any
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - handle
```
protected void handle(java.lang.Throwable error,
                      java.lang.ThreadLocal<com.workable.errorhandler.ErrorHandler.Context> context)
```
  - run
```
public void run(BlockExecutor blockExecutor)
```
    Run a custom code block and assign current ErrorHandler instance to handle a possible exception throw in 'catch'.
    
    Parameters:
    
    blockExecutor - functional interface containing Exception prone code
  - handle
```
public void handle(java.lang.Throwable error)
```
    Handle error by executing all matching actions.
    
    Parameters:
    
    error - the error as a Throwable
  - bind
```
public <T> ErrorHandler bind(T errorCode,
                             MatcherFactory<? super T> matcherFactory)
```
    Bind an errorCode to a Matcher, using a MatcherFactory.
    For example, when we need to catch a network timeout it's better to just write "timeout" instead of a train-wreck expression. So we need to bind this "timeout" error code to an actual condition that will check the actual error when it occurs to see if its a network timeout or not.
```
 
   ErrorHandler
      .defaultErrorHandler()
      .bind("timeout", errorCode -> throwable -> {
          return (throwable instanceof SocketTimeoutException) && throwable.getMessage().contains("Read timed out");
       });

   // ...

   ErrorHandler
      .build()
      .on("timeout", (throwable, handler) -> {
          showOfflineScreen();
      })
 
 
```
    Type Parameters:
    
    T - the error code type
    
    Parameters:
    
    errorCode - the errorCode value, can use a primitive for clarity and let it be autoboxed
    
    matcherFactory - a factory that given an error code, provides a matcher to match the error against it
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - bindClass
```
public <T> ErrorHandler bindClass(java.lang.Class<T> errorCodeClass,
                                  MatcherFactory<? super T> matcherFactory)
```
    Bind an errorCode Class to a Matcher, using a MatcherFactory.
    For example, when we prefer using plain integers to refer to HTTP errors instead of checking the HTTPException status code every time.
```
 
   ErrorHandler
      .defaultErrorHandler()
      .bindClass(Integer.class, errorCode -> throwable -> {
          return throwable instanceof HTTPException && ((HTTPException)throwable).getStatusCode() == errorCode;
       });

   // ...

   ErrorHandler
      .build()
      .on(404, (throwable, handler) -> {
          showResourceNotFoundError();
      })
      .on(500, (throwable, handler) -> {
          showServerError();
      })
 
 
```
    Type Parameters:
    
    T - the error code type
    
    Parameters:
    
    errorCodeClass - the errorCode class
    
    matcherFactory - a factory that given an error code, provides a matcher to match the error against it
    
    Returns:
    
    the current ErrorHandler instance - to use in command chains
  - getMatcherFactoryForErrorCode
```
protected <T> MatcherFactory<? super T> getMatcherFactoryForErrorCode(T errorCode)
```
  - clear
```
public void clear()
```
    Clear ErrorHandler instance from all its registered Actions and Matchers.

Class ErrorHandler

Method Summary

Methods inherited from class java.lang.Object

Method Detail

createIsolated

create

defaultErrorHandler

on

on

on

otherwise

always

skipFollowing

skipAlways

skipDefaults

handle

run

handle

bind

bindClass

getMatcherFactoryForErrorCode

clear