org.jactr.core.module.asynch.delegate

Class AbstractAsynchronousModuleDelegate<M extends IAsynchronousModule,R>

java.lang.Object

org.jactr.core.module.asynch.delegate.AbstractAsynchronousModuleDelegate<M,R>

Type Parameters:

M -

R -

All Implemented Interfaces:

IAsynchronousModuleDelegate<M,R>

Direct Known Subclasses:

AbstractVocalDelegate

public abstract class AbstractAsynchronousModuleDelegate<M extends IAsynchronousModule,R>
extends java.lang.Object
implements IAsynchronousModuleDelegate<M,R>

abstract asynch delegate. This will manage the BlockingTimedEvent such that the synchronization will occurr minimumProcessingTime after the start of the request.

Author:

harrison

Constructor Summary

Constructors

Constructor and Description
AbstractAsynchronousModuleDelegate(M module, double minimumProcessingTime, R cantProcessResult)

Method Summary

Modifier and Type	Method and Description
protected void	blockingTimedEventCreated(BlockingTimedEvent bte) called on the asynch thread on the creation of the blocking timed event.
protected abstract double	computeHarvestTime(IRequest request, R result, double startTime, java.lang.Object... parameters) returns the time at which this result should be made available.
protected ITimedEvent	createHarvestTimedEvent(double start, double end, IRequest request, R result, java.lang.Object... parameters)
protected void	enqueue(ITimedEvent timedEvent) method to queue the timed event.
protected abstract void	finalizeProcessing(IRequest request, R result, java.lang.Object... parameters) called on the model thread, this handles the clean up
double	getMinimumProcessingTime()
M	getModule() get the module this is installed into
java.util.concurrent.Future<R>	process(IRequest request, double processTime, java.lang.Object... parameters) everything is based on a ChunkPattern.
protected abstract R	processInternal(IRequest request, java.lang.Object... parameters) called on the asynchronous thread, this does the actual processing, returning some result.
protected void	processInternalCompleted(IRequest request, R result, double startTime, double harvestAt) called on the asynch thread after processInternal has completed.
protected abstract boolean	shouldProcess(IRequest request, java.lang.Object... parameters) Called on the initiating thread (i.e.

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractAsynchronousModuleDelegate

public AbstractAsynchronousModuleDelegate(M module,
                                          double minimumProcessingTime,
                                          R cantProcessResult)

Method Detail

getModule

public M getModule()

Description copied from interface: IAsynchronousModuleDelegate

get the module this is installed into

Specified by:

getModule in interface IAsynchronousModuleDelegate<M extends IAsynchronousModule,R>

Returns:

getMinimumProcessingTime

public double getMinimumProcessingTime()

process

public java.util.concurrent.Future<R> process(IRequest request,
                                              double processTime,
                                              java.lang.Object... parameters)

Description copied from interface: IAsynchronousModuleDelegate

everything is based on a ChunkPattern. This will start the processing and return some result, usually an IChunk

Specified by:

process in interface IAsynchronousModuleDelegate<M extends IAsynchronousModule,R>

createHarvestTimedEvent

protected ITimedEvent createHarvestTimedEvent(double start,
                                              double end,
                                              IRequest request,
                                              R result,
                                              java.lang.Object... parameters)

blockingTimedEventCreated

protected void blockingTimedEventCreated(BlockingTimedEvent bte)

called on the asynch thread on the creation of the blocking timed event. this is useful if you need to snag a reference to it.

Parameters:

bte -

processInternalCompleted

protected void processInternalCompleted(IRequest request,
                                        R result,
                                        double startTime,
                                        double harvestAt)

called on the asynch thread after processInternal has completed. primarily used to output some logging info..

Parameters:

request -

result -

startTime -

harvestAt -

enqueue

protected void enqueue(ITimedEvent timedEvent)

method to queue the timed event. By default getModule().getModel().getTimedEventQueue().enqueue()

Parameters:

timedEvent -

shouldProcess

protected abstract boolean shouldProcess(IRequest request,
                                         java.lang.Object... parameters)

Called on the initiating thread (i.e. model thread), this checks the module and the buffers to be sure that the processing can proceed. If true, it will queue #processInternal(ChunkPattern) on the asynchronous executor and then execute #finalizeProcessing(ChunkPattern, Object) on the model thread once all is completed

Parameters:

request -

Returns:

processInternal

protected abstract R processInternal(IRequest request,
                                     java.lang.Object... parameters)

called on the asynchronous thread, this does the actual processing, returning some result. This method should handle all its own exceptions.

Parameters:

request -

Returns:

finalizeProcessing

protected abstract void finalizeProcessing(IRequest request,
                                           R result,
                                           java.lang.Object... parameters)

called on the model thread, this handles the clean up

Parameters:

request -

result -

computeHarvestTime

protected abstract double computeHarvestTime(IRequest request,
                                             R result,
                                             double startTime,
                                             java.lang.Object... parameters)

returns the time at which this result should be made available. In other words, after #processInternal(ChunkPattern) finishes, a new ITimedEvent is queued that will fire at the returned time. Upon firing it will call #finalizeProcessing(ChunkPattern, Object). This is called on the asynch thread

Parameters:

request -

result -

startTime -

Returns: