org.refcodes.exception

Interface Exceptional<E extends Exception>

public interface Exceptional<E extends Exception>

The Exceptional interface provides means for threads to wait (sleep) when calling #onException() 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 and Description
void	catchException() This methods awaits an Exception, usually happening inside a daemon thread and therefore not directly accessible by some (business) logic.
E	lastException() Returns the last exception which was catchable via catchException().

Method Detail

catchException

void catchException()
             throws E extends Exception,
                    IllegalStateException

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 cause consumption of calculation power. Implementing instances might throw an IllegalStateException exception in case such a status is detected!

Throws:

E - Thrown when a next exception has been provided via #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.

E extends Exception

lastException

E lastException()

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

Returns:

The last exception being catchable via catchException();