org.refcodes.controlflow

Class ExceptionWatchdogImpl<E extends Exception>

java.lang.Object

org.refcodes.controlflow.ExceptionWatchdogImpl<E>

Type Parameters:

E - the element type

All Implemented Interfaces:

ExceptionWatchdog<E>, org.refcodes.exception.Exceptional<E>, org.refcodes.mixin.Disposable, org.refcodes.mixin.Releaseable

public class ExceptionWatchdogImpl<E extends Exception>
extends Object
implements ExceptionWatchdog<E>

The ExceptionWatchdogImpl implements a plain ExceptionWatchdog not queuing any Exception instances. Just the Exception instances thrown via throwException(Exception) are caught in case there is an awaiting thread inside the catchException() method.

ATTENTION: This implementation is not 100% reliable whether very fast sequenced Exception instances fed to throwException(Exception) are all caught by threads awaiting the catchException() method calls! In cases you expect one exception and then "its over", this class does its job.

Nested Class Summary

Nested classes/interfaces inherited from interface org.refcodes.mixin.Disposable

org.refcodes.mixin.Disposable.Disposedable

Constructor Summary

Constructors

Constructor and Description
ExceptionWatchdogImpl()

Method Summary

Modifier and Type	Method and Description
void	catchException() This methods awaits an Exception.
void	dispose()
E	lastException() Returns the last exception which was pushed via ExceptionWatchdog.throwException(Exception).
void	releaseAll()
void	throwException(E aException) Passes an exception to the ExceptionWatchdog notifying all awaiting threads inside the ExceptionWatchdog.catchException() method to be provided with that Exception.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ExceptionWatchdogImpl

public ExceptionWatchdogImpl()

Method Detail

catchException

public void catchException()
                    throws E extends Exception

This methods awaits an Exception. It waits (sleeps) until an Exception arises via ExceptionWatchdog.throwException(Exception) which is then thrown by this ExceptionWatchdog.catchException() method. In case Releaseable.releaseAll() is being called, then 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 using instances 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.

Specified by:

catchException in interface ExceptionWatchdog<E extends Exception>

Specified by:

catchException in interface org.refcodes.exception.Exceptional<E extends Exception>

Throws:

E - Thrown when a next exception has been provided via ExceptionWatchdog.throwException(Exception);

E extends Exception

lastException

public E lastException()

Returns the last exception which was pushed via ExceptionWatchdog.throwException(Exception). THis might not be the same as being retrieved by ExceptionWatchdog.catchException(), as ExceptionWatchdog.catchException() might provide queued up Exception instances till all Exception instances have been processed.

Specified by:

lastException in interface ExceptionWatchdog<E extends Exception>

Specified by:

lastException in interface org.refcodes.exception.Exceptional<E extends Exception>

Returns:

The last exception being pushed via ExceptionWatchdog.throwException(Exception);

throwException

public void throwException(E aException)

Passes an exception to the ExceptionWatchdog notifying all awaiting threads inside the ExceptionWatchdog.catchException() method to be provided with that Exception.

Specified by:

throwException in interface ExceptionWatchdog<E extends Exception>

Parameters:

aException - The Exception to be passed to the awaiting threads inside the ExceptionWatchdog.catchException() method.

releaseAll

public void releaseAll()

Specified by:

releaseAll in interface org.refcodes.mixin.Releaseable

dispose

public void dispose()

Specified by:

dispose in interface org.refcodes.mixin.Disposable