AAlgorithm (jaicore-basic 0.1.0 API)

java.lang.Object
- ai.libs.jaicore.basic.algorithm.AAlgorithm<I,O>

All Implemented Interfaces:

IAlgorithm<I,O>, Cancelable, ILoggingCustomizable, java.lang.Iterable<AlgorithmEvent>, java.util.concurrent.Callable<O>, java.util.Iterator<AlgorithmEvent>

Direct Known Subclasses:

ASolutionCandidateIterator, LDSRelationComputer
```
public abstract class AAlgorithm<I,O>
extends java.lang.Object
implements IAlgorithm<I,O>, ILoggingCustomizable
```

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AAlgorithm(I input)` C'tor providing the input for the algorithm already.
`protected`	`AAlgorithm(IAlgorithmConfig config, I input)` Internal c'tore overwriting the internal configuration and setting the input.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected AlgorithmInitializedEvent`	`activate()` This method - defines the definite deadline for when the algorithm must have finished - sets the algorithm state to ACTIVE - sends the mandatory AlgorithmInitializedEvent over the event bus.
`protected void`	`announceTimeoutDetected()`
`protected void`	`avoidReinterruptionOnShutdownOnCurrentThread()`
`void`	`cancel()`
`protected void`	`checkAndConductTermination()`
`protected void`	`checkTermination(boolean shutdownOnStoppingCriterion)`
`protected <T> T`	`computeTimeoutAware(java.util.concurrent.Callable<T> r, java.lang.String reasonToLogOnTimeout, boolean shutdownOnStoppingCriterionSatisfied)`
`long`	`getActivationTime()`
`IAlgorithmConfig`	`getConfig()`
`java.lang.String`	`getId()` globally unique identifier for the algorithm run
`I`	`getInput()`
`java.lang.String`	`getLoggerName()`
`int`	`getNumCPUs()`
`protected TimeOut`	`getRemainingTimeToDeadline()`
`AlgorithmState`	`getState()`
`TimeOut`	`getTimeout()`
`int`	`getTimeoutPrecautionOffset()`
`boolean`	`hasNext()`
`boolean`	`hasThreadBeenInterruptedDuringShutdown(java.lang.Thread t)`
`protected void`	`interruptThreadAsPartOfShutdown(java.lang.Thread t)`
`boolean`	`isCanceled()`
`boolean`	`isShutdownInitialized()`
`boolean`	`isStopCriterionSatisfied()`
`boolean`	`isTimeouted()`
`java.util.Iterator<AlgorithmEvent>`	`iterator()`
`AlgorithmEvent`	`next()`
`protected void`	`post(java.lang.Object e)` This methods allows for posting an event on the algorithm's event bus.
`protected void`	`registerActiveThread()`
`void`	`registerListener(java.lang.Object listener)` Registers a listener to the algorithm's event bus.
`protected void`	`resolveShutdownInterruptOnCurrentThread()`
`void`	`setConfig(IAlgorithmConfig config)` Sets the config object to the new config object.
`void`	`setLoggerName(java.lang.String name)`
`void`	`setMaxNumThreads(int maxNumberOfThreads)` While setNumCPUs aims at telling the algorithm how many CPUs should be used for parallelization, this method can be used to define a strict constraint on the number of threads that must be spawned by the algorithm itself at most.
`void`	`setNumCPUs(int numberOfCPUs)`
`protected void`	`setState(AlgorithmState state)`
`void`	`setTimeout(long timeout, java.util.concurrent.TimeUnit timeUnit)` Sets the timeout for the algorithm to the given value in the given time unit.
`void`	`setTimeout(TimeOut timeout)`
`void`	`setTimeoutPrecautionOffset(int timeoutPrecautionOffset)`
`protected void`	`shutdown()` This method does two things: 1. it interrupts all threads that are registered to be active inside this algorithm 2. it cancels the (possibly created) timeout thread This method should be called ALWAYS when the algorithm activity ceases.
`protected AlgorithmFinishedEvent`	`terminate()` This methods terminates the algorithm, setting the internal state to inactive and emitting the mandatory AlgorithmFinishedEvent over the event bus.
`protected void`	`unregisterActiveThread()`
`protected void`	`unregisterThreadAndShutdown()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface ai.libs.jaicore.basic.algorithm.IAlgorithm
call, nextWithException

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface java.util.Iterator
forEachRemaining, remove

- Constructor Detail
  - AAlgorithm
```
protected AAlgorithm(I input)
```
    C'tor providing the input for the algorithm already.
    
    Parameters:
    
    input - The input for the algorithm.
  - AAlgorithm
```
protected AAlgorithm(IAlgorithmConfig config,
                     I input)
```
    Internal c'tore overwriting the internal configuration and setting the input.
    
    Parameters:
    
    input - The input for the algorithm.
    
    config - The configuration to take as the internal configuration object.
- Method Detail
  - iterator
```
public java.util.Iterator<AlgorithmEvent> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<AlgorithmEvent>
  - hasNext
```
public boolean hasNext()
```
    Specified by:
    
    hasNext in interface java.util.Iterator<AlgorithmEvent>
  - next
```
public AlgorithmEvent next()
```
    Specified by:
    
    next in interface java.util.Iterator<AlgorithmEvent>
  - getInput
```
public I getInput()
```
    Specified by:
    
    getInput in interface IAlgorithm<I,O>
    
    Returns:
    
    The input that has been given to the algorithm.
  - registerListener
```
public void registerListener(java.lang.Object listener)
```
    Description copied from interface: IAlgorithm
    
    Registers a listener to the algorithm's event bus.
    
    Specified by:
    
    registerListener in interface IAlgorithm<I,O>
    
    Parameters:
    
    listener - The listener to register.
  - getNumCPUs
```
public int getNumCPUs()
```
    Specified by:
    
    getNumCPUs in interface IAlgorithm<I,O>
    
    Returns:
    
    The number of cpus (the amount of parallelization) that is allowed to be used by the algorithm.
  - setNumCPUs
```
public void setNumCPUs(int numberOfCPUs)
```
    Specified by:
    
    setNumCPUs in interface IAlgorithm<I,O>
    
    Parameters:
    
    numberOfCPUs - The numer of cpus that is allowed to be used by the algorithm.
  - setMaxNumThreads
```
public void setMaxNumThreads(int maxNumberOfThreads)
```
    Description copied from interface: IAlgorithm
    
    While setNumCPUs aims at telling the algorithm how many CPUs *should* be used for parallelization, this method can be used to define a strict constraint on the number of threads that must be spawned by the algorithm itself at most. The motivation for this functionality is that, on some systems, processes get killed if they consume too much CPU resources. This can usually be avoided if the number of threads is limited (e.g. to the number of cores that may be used). setNumCPUs does not put such a restriction, because this is unnecessarily limiting in environment where such constraints do not exist. If the value is set to 0, no own threads must be used at all. Note that this may not be possible for some algorithms that need observers in the background. If the value is set to -1, any restriction on the number of threads is removed. Note that different algorithms may have different default behaviors if this number is not set.
    
    Specified by:
    
    setMaxNumThreads in interface IAlgorithm<I,O>
    
    Parameters:
    
    maxNumberOfThreads - The maximum number of threads that may be spawned by the algorithm itself.
  - setTimeout
```
public void setTimeout(long timeout,
                       java.util.concurrent.TimeUnit timeUnit)
```
    Description copied from interface: IAlgorithm
    
    Sets the timeout for the algorithm to the given value in the given time unit.
    
    Specified by:
    
    setTimeout in interface IAlgorithm<I,O>
    
    Parameters:
    
    timeout - The number of e.g. ms, seconds, minutes according to the given time unit.
    
    timeUnit - The time unit for which the timeout variable will be interpreted.
  - setTimeout
```
public void setTimeout(TimeOut timeout)
```
    Specified by:
    
    setTimeout in interface IAlgorithm<I,O>
    
    Parameters:
    
    timeout - The timeout for the algorithm.
  - getTimeoutPrecautionOffset
```
public int getTimeoutPrecautionOffset()
```
  - setTimeoutPrecautionOffset
```
public void setTimeoutPrecautionOffset(int timeoutPrecautionOffset)
```
  - getTimeout
```
public TimeOut getTimeout()
```
    Specified by:
    
    getTimeout in interface IAlgorithm<I,O>
    
    Returns:
    
    The timeout for the algorithm.
  - isTimeouted
```
public boolean isTimeouted()
```
  - getRemainingTimeToDeadline
```
protected TimeOut getRemainingTimeToDeadline()
```
  - isStopCriterionSatisfied
```
public boolean isStopCriterionSatisfied()
```
  - isCanceled
```
public boolean isCanceled()
```
    Returns:
    
    Flag denoting whether this algorithm has been canceled.
  - getId
```
public java.lang.String getId()
```
    Description copied from interface: IAlgorithm
    
    globally unique identifier for the algorithm run
    
    Specified by:
    
    getId in interface IAlgorithm<I,O>
    
    Returns:
  - checkTermination
```
protected void checkTermination(boolean shutdownOnStoppingCriterion)
                         throws java.lang.InterruptedException,
                                AlgorithmExecutionCanceledException,
                                AlgorithmTimeoutedException
```
    Throws:
    
    java.lang.InterruptedException
    
    AlgorithmExecutionCanceledException
    
    AlgorithmTimeoutedException
  - checkAndConductTermination
```
protected void checkAndConductTermination()
                                   throws java.lang.InterruptedException,
                                          AlgorithmExecutionCanceledException,
                                          AlgorithmTimeoutedException
```
    Throws:
    
    java.lang.InterruptedException
    
    AlgorithmExecutionCanceledException
    
    AlgorithmTimeoutedException
  - shutdown
```
protected void shutdown()
```
    This method does two things: 1. it interrupts all threads that are registered to be active inside this algorithm 2. it cancels the (possibly created) timeout thread This method should be called ALWAYS when the algorithm activity ceases. This method takes effect only once. Further invocations will be ignored.
  - interruptThreadAsPartOfShutdown
```
protected void interruptThreadAsPartOfShutdown(java.lang.Thread t)
```
  - hasThreadBeenInterruptedDuringShutdown
```
public boolean hasThreadBeenInterruptedDuringShutdown(java.lang.Thread t)
```
  - resolveShutdownInterruptOnCurrentThread
```
protected void resolveShutdownInterruptOnCurrentThread()
                                                throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - avoidReinterruptionOnShutdownOnCurrentThread
```
protected void avoidReinterruptionOnShutdownOnCurrentThread()
```
  - isShutdownInitialized
```
public boolean isShutdownInitialized()
```
  - unregisterThreadAndShutdown
```
protected void unregisterThreadAndShutdown()
```
  - registerActiveThread
```
protected void registerActiveThread()
```
  - unregisterActiveThread
```
protected void unregisterActiveThread()
```
  - getActivationTime
```
public long getActivationTime()
```
  - getState
```
public AlgorithmState getState()
```
    Returns:
    
    The current state of the algorithm.
  - setState
```
protected void setState(AlgorithmState state)
```
    Parameters:
    
    state - The new state of the algorithm.
  - cancel
```
public void cancel()
```
    Specified by:
    
    cancel in interface Cancelable
  - activate
```
protected AlgorithmInitializedEvent activate()
```
    This method - defines the definite deadline for when the algorithm must have finished - sets the algorithm state to ACTIVE - sends the mandatory AlgorithmInitializedEvent over the event bus. Should only be called once and as before the state is set to something else.
  - terminate
```
protected AlgorithmFinishedEvent terminate()
```
    This methods terminates the algorithm, setting the internal state to inactive and emitting the mandatory AlgorithmFinishedEvent over the event bus.
    
    Returns:
    
    The algorithm finished event.
  - post
```
protected void post(java.lang.Object e)
```
    This methods allows for posting an event on the algorithm's event bus.
    
    Parameters:
    
    e - The event to post on the event bus.
  - getConfig
```
public IAlgorithmConfig getConfig()
```
    Specified by:
    
    getConfig in interface IAlgorithm<I,O>
    
    Returns:
    
    The config interface to store parameters to the algorithm in.
  - setConfig
```
public void setConfig(IAlgorithmConfig config)
```
    Sets the config object to the new config object.
    
    Parameters:
    
    config - The new config object.
  - setLoggerName
```
public void setLoggerName(java.lang.String name)
```
    Specified by:
    
    setLoggerName in interface ILoggingCustomizable
  - getLoggerName
```
public java.lang.String getLoggerName()
```
    Specified by:
    
    getLoggerName in interface ILoggingCustomizable
  - announceTimeoutDetected
```
protected void announceTimeoutDetected()
```
  - computeTimeoutAware
```
protected <T> T computeTimeoutAware(java.util.concurrent.Callable<T> r,
                                    java.lang.String reasonToLogOnTimeout,
                                    boolean shutdownOnStoppingCriterionSatisfied)
                             throws java.lang.InterruptedException,
                                    AlgorithmException,
                                    AlgorithmExecutionCanceledException,
                                    AlgorithmTimeoutedException
```
    Throws:
    
    java.lang.InterruptedException
    
    AlgorithmException
    
    AlgorithmExecutionCanceledException
    
    AlgorithmTimeoutedException

Class AAlgorithm<I,O>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface ai.libs.jaicore.basic.algorithm.IAlgorithm

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.Iterator

Constructor Detail

AAlgorithm

AAlgorithm

Method Detail

iterator

hasNext

next

getInput

registerListener

getNumCPUs

setNumCPUs

setMaxNumThreads

setTimeout

setTimeout

getTimeoutPrecautionOffset

setTimeoutPrecautionOffset

getTimeout

isTimeouted

getRemainingTimeToDeadline

isStopCriterionSatisfied

isCanceled

getId

checkTermination

checkAndConductTermination

shutdown

interruptThreadAsPartOfShutdown

hasThreadBeenInterruptedDuringShutdown

resolveShutdownInterruptOnCurrentThread

avoidReinterruptionOnShutdownOnCurrentThread

isShutdownInitialized

unregisterThreadAndShutdown

registerActiveThread

unregisterActiveThread

getActivationTime

getState

setState

cancel

activate

terminate

post

getConfig

setConfig

setLoggerName

getLoggerName

announceTimeoutDetected

computeTimeoutAware