AbstractStage (TeeTime 3.0 API)

java.lang.Object
- teetime.framework.AbstractStage

Direct Known Subclasses:

AbstractConsumerStage, AbstractProducerStage, Delay, DivideAndConquerStage, Merger, StatelessCounter
```
public abstract class AbstractStage
extends Object
```
Represents a minimal Stage, with some pre-defined methods. Implemented stages need to adapt all abstract methods with own implementations.

Field Summary

Fields
Modifier and Type Field and Description

protected org.slf4j.Logger logger
This stage's unique logger

Fields
Modifier and Type	Field and Description
`protected org.slf4j.Logger`	`logger` This stage's unique logger

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractStage()

protected AbstractStage(org.slf4j.Logger logger)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractStage()`
`protected`	`AbstractStage(org.slf4j.Logger logger)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`abort()`
`protected void`	`addInputPortRemovedListener(PortRemovedListener<InputPort<?>> inputPortRemovedListener)`
`protected void`	`addOutputPortRemovedListener(PortRemovedListener<OutputPort<?>> outputPortRemovedListener)`
`boolean`	`compareAndSetBeingExecuted(boolean newValue)`
`protected <T> InputPort<T>`	`createInputPort()` Creates and adds an InputPort to the stage
`protected <T> InputPort<T>`	`createInputPort(Class<T> type)` Creates and adds an InputPort to the stage
`protected <T> InputPort<T>`	`createInputPort(Class<T> type, String name)` Creates and adds an InputPort to the stage
`protected <T> InputPort<T>`	`createInputPort(String name)` Creates and adds an InputPort to the stage
`protected <T> OutputPort<T>`	`createOutputPort()` Creates and adds an OutputPort to the stage
`protected <T> OutputPort<T>`	`createOutputPort(Class<T> type)` Creates and adds an OutputPort to the stage
`protected <T> OutputPort<T>`	`createOutputPort(Class<T> type, String name)` Creates and adds an OutputPort to the stage
`protected <T> OutputPort<T>`	`createOutputPort(String name)` Creates and adds an OutputPort to the stage
`void`	`declareActive()` Declares this stage to be executed by an own thread.
`void`	`declarePassive()` Declares this stage to be executed by the thread of its predecessor stage.
`protected abstract void`	`execute()` Contains the logic of this stage and is invoked (possibly multiple times) by the framework.
`void`	`executeByFramework()` This method is internally called by the framework.
`StageState`	`getCurrentState()` This method is thread-safe.
`String`	`getId()`
`protected List<InputPort<?>>`	`getInputPorts()`
`protected List<OutputPort<?>>`	`getOutputPorts()`
`protected Thread`	`getOwningThread()`
`protected TerminationStrategy`	`getTerminationStrategy()` Deprecated. since 3.0. We will completely remove framework-backed support for infinite producers since it has never worked correctly in all (corner) cases. Instead, please use finite producers and implement an appropriate termination condition by your own.
`boolean`	`isActive()`
`boolean`	`isBeingExecuted()`
`boolean`	`isPaused()`
`boolean`	`isProducer()`
`boolean`	`isStateless()` This method is used by some schedulers to improve parallelism and thus to improve the overall performance.
`void`	`onSignal(ISignal signal, InputPort<?> inputPort)` May not be invoked outside of IPipe implementations
`protected void`	`onStarting()` Event that is triggered, if all of the following conditions hold: after passing the validation phase and after the threads are ready-to-run and just before the threads execute any stage.
`protected void`	`onTerminating()` Event that is triggered, if all of the following conditions hold: while executing the P&F configuration and after receiving the termination signal.
`void`	`onValidating(List<InvalidPortConnection> invalidPortConnections)` Event that is triggered, if all of the following conditions hold: after constructing this stage and before starting the analysis.
`protected void`	`removeDynamicPort(InputPort<?> inputPort)`
`protected void`	`removeDynamicPort(OutputPort<?> outputPort)`
`void`	`setPaused(boolean newValue)`
`protected void`	`setStateless(boolean stateless)`
`protected boolean`	`shouldBeTerminated()`
`protected boolean`	`signalAlreadyReceived(ISignal signal, InputPort<?> inputPort)`
`protected void`	`terminateStage()` Deprecated. since 3.0. Use `workCompleted()` instead.
`String`	`toString()` Returns a string representation of this stage including its unique identifier.
`protected void`	`workCompleted()` Marks this stage as having finished its work such that it will not be scheduled anymore.

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

- Field Detail
  - logger
```
protected final org.slf4j.Logger logger
```
    This stage's unique logger
- Constructor Detail
  - AbstractStage
```
protected AbstractStage()
```
  - AbstractStage
```
protected AbstractStage(org.slf4j.Logger logger)
```
    Parameters:
    
    logger - a custom logger (potentially shared by multiple stage instances)
- Method Detail
  - isBeingExecuted
```
public boolean isBeingExecuted()
```
  - compareAndSetBeingExecuted
```
public boolean compareAndSetBeingExecuted(boolean newValue)
```
  - setPaused
```
public void setPaused(boolean newValue)
```
  - isPaused
```
public boolean isPaused()
```
  - getId
```
public String getId()
```
    Returns:
    
    an identifier that is unique among all stage instances. It is especially unique among all instances of the same stage type.
  - toString
```
public String toString()
```
    Returns a string representation of this stage including its unique identifier.
    
    Overrides:
    
    toString in class Object
  - executeByFramework
```
public final void executeByFramework()
                              throws TerminateException
```
    This method is internally called by the framework. It must not be executed by user code. In particular, it must not be invoked from within any stage.
    
    Throws:
    
    TerminateException
  - execute
```
protected abstract void execute()
                         throws Exception
```
    Contains the logic of this stage and is invoked (possibly multiple times) by the framework.
    
    Throws:
    
    Exception - arbitrary exception triggered by the logic of this stage
  - getOwningThread
```
protected Thread getOwningThread()
```
  - isActive
```
public boolean isActive()
```
  - declareActive
```
public void declareActive()
```
    Declares this stage to be executed by an own thread.
  - declarePassive
```
public void declarePassive()
```
    Declares this stage to be executed by the thread of its predecessor stage.
  - getInputPorts
```
protected List<InputPort<?>> getInputPorts()
```
  - getOutputPorts
```
protected List<OutputPort<?>> getOutputPorts()
```
  - getCurrentState
```
public StageState getCurrentState()
```
    This method is thread-safe.
    
    Returns:
    
    the current state of this stage (one of StageState)
  - onSignal
```
public void onSignal(ISignal signal,
                     InputPort<?> inputPort)
```
    May not be invoked outside of IPipe implementations
    
    Parameters:
    
    signal - The incoming signal
    
    inputPort - The port which received the signal
  - signalAlreadyReceived
```
protected boolean signalAlreadyReceived(ISignal signal,
                                        InputPort<?> inputPort)
```
    Parameters:
    
    signal - arriving signal
    
    inputPort - which received the signal
    
    Returns:
    
    true if this stage has already received the given signal, false otherwise
  - onValidating
```
public void onValidating(List<InvalidPortConnection> invalidPortConnections)
```
    Event that is triggered, if all of the following conditions hold:
    - after constructing this stage and
    - before starting the analysis.
    If stage developers want to override this method, they must always call the super implementation first:
```
 @Override
 public void onValidating() {
        super.onValidating();
        // insert your code here
 }
 
```
    To throw a checked exception, wrap it to an unchecked exception, e.g. to an IllegalArgumentException.IllegalArgumentException(String, Throwable). Always pass the original exception to the new unchecked exception to allow easy debugging.
    Parameters:
    
    invalidPortConnections -
  - onStarting
```
protected void onStarting()
```
    Event that is triggered, if all of the following conditions hold:
    - after passing the validation phase and
    - after the threads are ready-to-run and
    - just before the threads execute any stage.
    If stage developers want to override this method, they must always call the super implementation first:
```
 @Override
 protected void onStarting() {
        super.onStarting();
        // insert your code here
 }
 
```
    To throw a checked exception, wrap it to an unchecked exception, e.g. to an IllegalArgumentException.IllegalArgumentException(String, Throwable). Always pass the original exception to the new unchecked exception to allow easy debugging.
  - onTerminating
```
protected void onTerminating()
```
    Event that is triggered, if all of the following conditions hold:
    - while executing the P&F configuration and
    - after receiving the termination signal.
    If stage developers want to override this method, they must always call the super implementation last:
```
 @Override
 protected void onTerminating() {
        // insert your code here
        super.onTerminating();
 }
 
```
    To throw a checked exception, wrap it to an unchecked exception, e.g. to an IllegalArgumentException.IllegalArgumentException(String, Throwable). Always pass the original exception to the new unchecked exception to allow easy debugging.
  - createInputPort
```
protected <T> InputPort<T> createInputPort()
```
    Creates and adds an InputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be received
    
    Returns:
    
    the newly added InputPort
  - createInputPort
```
protected <T> InputPort<T> createInputPort(Class<T> type)
```
    Creates and adds an InputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be received
    
    Parameters:
    
    type - class of elements to be received
    
    Returns:
    
    the newly added InputPort
  - createInputPort
```
protected <T> InputPort<T> createInputPort(String name)
```
    Creates and adds an InputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be received
    
    Parameters:
    
    name - a specific name for the new port
    
    Returns:
    
    the newly added InputPort
  - createInputPort
```
protected <T> InputPort<T> createInputPort(Class<T> type,
                                           String name)
```
    Creates and adds an InputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be received
    
    Parameters:
    
    type - class of elements to be received
    
    name - a specific name for the new port
    
    Returns:
    
    the newly added InputPort
  - createOutputPort
```
protected <T> OutputPort<T> createOutputPort()
```
    Creates and adds an OutputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be sent
    
    Returns:
    
    the newly added OutputPort
  - createOutputPort
```
protected <T> OutputPort<T> createOutputPort(Class<T> type)
```
    Creates and adds an OutputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be sent
    
    Parameters:
    
    type - class of elements to be sent
    
    Returns:
    
    the newly added OutputPort
  - createOutputPort
```
protected <T> OutputPort<T> createOutputPort(String name)
```
    Creates and adds an OutputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be sent
    
    Parameters:
    
    name - a specific name for the new port
    
    Returns:
    
    the newly added OutputPort
  - createOutputPort
```
protected <T> OutputPort<T> createOutputPort(Class<T> type,
                                             String name)
```
    Creates and adds an OutputPort to the stage
    
    Type Parameters:
    
    T - the type of elements to be sent
    
    Parameters:
    
    name - a specific name for the new port
    
    type - class of elements to be sent
    
    Returns:
    
    the newly added OutputPort
  - terminateStage
```
@Deprecated
protected void terminateStage()
```
    Deprecated. since 3.0. Use workCompleted() instead.
    
    Terminates the execution of the stage. After terminating, this stage sends a signal to all its direct and indirect successor stages to terminate.
  - workCompleted
```
protected void workCompleted()
```
    Marks this stage as having finished its work such that it will not be scheduled anymore. The framework then automatically propagates a termination signal to the direct and indirect successor stages. In this way, each stage terminates itself after having processed all of its remaining input elements. Thus, the framework automatically terminates the whole P&F configuration in a graceful way when all of its producer stages have finished their work. The user does not need to implement any additional or alternative termination logic.
    This method may only be invoked by producers. Otherwise an UnsupportedOperationException is thrown.
    
    Since:
    
    3.0
  - abort
```
protected void abort()
```
  - shouldBeTerminated
```
protected boolean shouldBeTerminated()
```
  - getTerminationStrategy
```
@Deprecated
protected TerminationStrategy getTerminationStrategy()
```
    Deprecated. since 3.0. We will completely remove framework-backed support for infinite producers since it has never worked correctly in all (corner) cases. Instead, please use finite producers and implement an appropriate termination condition by your own.
    
    Returns:
    
    the termination strategy of this stage
  - removeDynamicPort
```
protected void removeDynamicPort(OutputPort<?> outputPort)
```
  - removeDynamicPort
```
protected void removeDynamicPort(InputPort<?> inputPort)
```
  - addOutputPortRemovedListener
```
protected final void addOutputPortRemovedListener(PortRemovedListener<OutputPort<?>> outputPortRemovedListener)
```
  - addInputPortRemovedListener
```
protected final void addInputPortRemovedListener(PortRemovedListener<InputPort<?>> inputPortRemovedListener)
```
  - isProducer
```
public boolean isProducer()
```
    Returns:
    
    true iff this stage has no input ports, false otherwise.
  - isStateless
```
public boolean isStateless()
```
    This method is used by some schedulers to improve parallelism and thus to improve the overall performance.
    
    Returns:
    
    true iff this stage has no internal fields which represent some kind of state; false otherwise.
  - setStateless
```
protected void setStateless(boolean stateless)
```

Class AbstractStage

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

AbstractStage

AbstractStage

Method Detail

isBeingExecuted

compareAndSetBeingExecuted

setPaused

isPaused

getId

toString

executeByFramework

execute

getOwningThread

isActive

declareActive

declarePassive

getInputPorts

getOutputPorts

getCurrentState

onSignal

signalAlreadyReceived

onValidating

onStarting

onTerminating

createInputPort

createInputPort

createInputPort

createInputPort

createOutputPort

createOutputPort

createOutputPort

createOutputPort

terminateStage

workCompleted

abort

shouldBeTerminated

getTerminationStrategy

removeDynamicPort

removeDynamicPort

addOutputPortRemovedListener

addInputPortRemovedListener

isProducer

isStateless

setStateless