E
- the element typepublic interface Exceptional<E extends Exception>
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()
.
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. |
E |
lastException() |
Returns the last exception which was catchable via
catchException() . |
void catchException() throws E extends Exception, IllegalStateException
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!E
- 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.E extends Exception
E lastException()
catchException()
.catchException()
;Copyright © 2021. All rights reserved.