Module org.refcodes.exception

Package org.refcodes.exception

Interface Exceptional<EXC extends Throwable>

Type Parameters:

EXC - the Throwable type

public interface Exceptional<EXC extends Throwable>

The Exceptional interface provides means for threads to wait (sleep) when calling catchException() till a next Exception occurs or till the waiting (sleeping) threads are released.

Usually only Exception instances are exposed which are occurring inside daemon threads and are usually hidden from the (business) logic. Such Exception instances usually just get logged, no customizable reaction upon such exceptions is possible. This interface enables to react to such Exception instances without the need to overwrite an abstract class's method and without requiring the implementation of an observable interface.

It depends on the implementation on how waiting (sleeping) threads are released, this can be established for example upon disposal by invoking Disposable#dispose() or destruction by invoking Destroyable#destroy().

Method Summary

Modifier and Type	Method	Description
void	catchException()	This methods awaits an Exception, usually happening inside a daemon thread and therefore not directly accessible by some (business) logic.
EXC	lastException()	Returns the last exception which was catchable via catchException().

Method Details

catchException

void catchException()
             throws EXC

This methods awaits an Exception, usually happening inside a daemon thread and therefore not directly accessible by some (business) logic. It waits (sleeps) until an Exception arises which is then thrown by this method. Upon disposal (Disposable#dispose()) or destruction ( Destroyable.destroy()) all waiting threads are continued without throwing any exception. ------------------------------------------------------------------------- ATTENTION: In case waiting (sleeping) threads are released without throwing an Exception, then this means that the implementing instance intends to shut down so that in such as case, no more calls to this method are to be performed (are to be prevented), such looping threads would lead to endless looping and aCause consumption of calculation power. Implementing instances might throw an IllegalStateException exception in case such a status is detected!

Throws:

EXC - Thrown when a next exception has been provided via ExceptionWatchdog#throwException(Exception)

IllegalStateException - Thrown in case this method is being called even though the implementing instance has been shut down and has released all threads without throwing an exception.

lastException

EXC lastException()

Returns the last exception which was catchable via catchException().

Returns:

The last exception being catchable via catchException();