DefaultDexecutorState (Dependent Tasks Executor Core 2.0.0 API)

java.lang.Object
- com.github.dexecutor.core.DefaultDexecutorState<T,R>

All Implemented Interfaces:: DexecutorState<T,R>, DependencyAware<T>

public class DefaultDexecutorState<T extends Comparable<T>,R>
extends Object
implements DexecutorState<T,R>

Constructor Summary

Constructors
Constructor and Description

DefaultDexecutorState()

Constructors
Constructor and Description
`DefaultDexecutorState()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAsDependencyToAllInitialNodes(T nodeValue)` Adds the node as dependency to all initial nodes (at the time of adding), meaning this given node would be evaluated first and then all initial nodes would run in parallel
`void`	`addAsDependentOnAllLeafNodes(T nodeValue)` Adds the node as dependent on all leaf nodes (at the time of adding), meaning all leaf nodes would be evaluated first and then the given node
`void`	`addDependency(T evalFirstValue, T evalAfterValue)` Should add the two nodes in the datastructure in such a way that `evalFirstValue` should be evaluated before `evalAfterValue`.
`void`	`addErrored(T id)` Add to errored collection
`void`	`addIndependent(T nodeValue)` Adds the given node to the datastructure whith out any dependency Nodes should be created only if it is not already added.
`void`	`decrementUnProcessedNodesCount()` decrements the count of total number of unprocessed nodes
`int`	`erroredCount()`
`void`	`forcedStop()` called to force stop
`Phase`	`getCurrentPhase()`
`Collection<Node<T,R>>`	`getDiscontinuedNodes()`
`Node<T,R>`	`getGraphNode(T id)` Returns the node with the given id
`Set<Node<T,R>>`	`getInitialNodes()` Returns the Set of nodes for which there is no incoming dependencies.
`Set<Node<T,R>>`	`getNonProcessedRootNodes()`
`Collection<Node<T,R>>`	`getProcessedNodes()`
`int`	`getUnProcessedNodesCount()`
`int`	`graphSize()` Returns the total number of nodes in this graph
`void`	`incrementUnProcessedNodesCount()` increments the count of total number of unprocessed nodes
`boolean`	`isDiscontinuedNodesNotEmpty()`
`void`	`markDiscontinuedNodesProcessed()` clear (or marks) all the discontinued nodes till this point as processed
`void`	`markProcessingDone(Node<T,R> node)`
`void`	`print(Traversar<T,R> traversar, TraversarAction<T,R> action)` Prints the graph into the writer using the Traversar
`void`	`processAfterNoError(Collection<Node<T,R>> nodes)` Add to existing collection of discontinued nodes to be processed later, if system come to valid state.
`void`	`removeErrored(T id)` Remove errored collection
`void`	`setCurrentPhase(Phase currentPhase)` sets the phase to that of provided
`boolean`	`shouldProcess(Node<T,R> node)`
`void`	`validate(Validator<T,R> validator)` validates the graph using the validator

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

- Constructor Detail
  - DefaultDexecutorState
```
public DefaultDexecutorState()
```
- Method Detail
  - addIndependent
```
public void addIndependent(T nodeValue)
```
    Description copied from interface: DependencyAware
    
    Adds the given node to the datastructure whith out any dependency Nodes should be created only if it is not already added.
    
    Specified by:
    
    addIndependent in interface DependencyAware<T extends Comparable<T>>
    
    Parameters:
    
    nodeValue - Unique node id
  - addDependency
```
public void addDependency(T evalFirstValue,
                          T evalAfterValue)
```
    Description copied from interface: DependencyAware
    
    Should add the two nodes in the datastructure in such a way that evalFirstValue should be evaluated before evalAfterValue. Nodes should be created only if it is not already added.
    
    Specified by:
    
    addDependency in interface DependencyAware<T extends Comparable<T>>
    
    Parameters:
    
    evalFirstValue - Node which should be evaluated first
    
    evalAfterValue - Node which should be evaluated after evalFirstValue
  - addAsDependentOnAllLeafNodes
```
public void addAsDependentOnAllLeafNodes(T nodeValue)
```
    Description copied from interface: DependencyAware
    
    Adds the node as dependent on all leaf nodes (at the time of adding), meaning all leaf nodes would be evaluated first and then the given node
    
    Specified by:
    
    addAsDependentOnAllLeafNodes in interface DependencyAware<T extends Comparable<T>>
    
    Parameters:
    
    nodeValue - Node which should depend on all leaf nodes
  - addAsDependencyToAllInitialNodes
```
public void addAsDependencyToAllInitialNodes(T nodeValue)
```
    Description copied from interface: DependencyAware
    
    Adds the node as dependency to all initial nodes (at the time of adding), meaning this given node would be evaluated first and then all initial nodes would run in parallel
    
    Specified by:
    
    addAsDependencyToAllInitialNodes in interface DependencyAware<T extends Comparable<T>>
    
    Parameters:
    
    nodeValue - Node on which all initial nodes should depends on
  - setCurrentPhase
```
public void setCurrentPhase(Phase currentPhase)
```
    Description copied from interface: DexecutorState
    
    sets the phase to that of provided
    
    Specified by:
    
    setCurrentPhase in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    currentPhase - the phase that should be set to
  - getCurrentPhase
```
public Phase getCurrentPhase()
```
    Specified by:
    
    getCurrentPhase in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    the current phase of execution
  - getInitialNodes
```
public Set<Node<T,R>> getInitialNodes()
```
    Description copied from interface: DexecutorState
    
    Returns the Set of nodes for which there is no incoming dependencies.
    
    Specified by:
    
    getInitialNodes in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    set of initial nodes
  - getNonProcessedRootNodes
```
public Set<Node<T,R>> getNonProcessedRootNodes()
```
    Specified by:
    
    getNonProcessedRootNodes in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    the root non processed nodes
  - graphSize
```
public int graphSize()
```
    Description copied from interface: DexecutorState
    
    Returns the total number of nodes in this graph
    
    Specified by:
    
    graphSize in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    total number of nodes in this graph
  - getGraphNode
```
public Node<T,R> getGraphNode(T id)
```
    Description copied from interface: DexecutorState
    
    Returns the node with the given id
    
    Specified by:
    
    getGraphNode in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    id - The Unique node id
    
    Returns:
    
    the @Node with the given id
  - incrementUnProcessedNodesCount
```
public void incrementUnProcessedNodesCount()
```
    Description copied from interface: DexecutorState
    
    increments the count of total number of unprocessed nodes
    
    Specified by:
    
    incrementUnProcessedNodesCount in interface DexecutorState<T extends Comparable<T>,R>
  - decrementUnProcessedNodesCount
```
public void decrementUnProcessedNodesCount()
```
    Description copied from interface: DexecutorState
    
    decrements the count of total number of unprocessed nodes
    
    Specified by:
    
    decrementUnProcessedNodesCount in interface DexecutorState<T extends Comparable<T>,R>
  - getUnProcessedNodesCount
```
public int getUnProcessedNodesCount()
```
    Specified by:
    
    getUnProcessedNodesCount in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    the total number of unprocessed nodes(Waiting for execution result) at any given moment of time.
  - shouldProcess
```
public boolean shouldProcess(Node<T,R> node)
```
    Specified by:
    
    shouldProcess in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    node - on which test should happen
    
    Returns:
    
    weather the node should be processed by dexecutor or not
  - markProcessingDone
```
public void markProcessingDone(Node<T,R> node)
```
    Specified by:
    
    markProcessingDone in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    node - Mark the node as processed.
  - getProcessedNodes
```
public Collection<Node<T,R>> getProcessedNodes()
```
    Specified by:
    
    getProcessedNodes in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    processedNodes
  - isDiscontinuedNodesNotEmpty
```
public boolean isDiscontinuedNodesNotEmpty()
```
    Specified by:
    
    isDiscontinuedNodesNotEmpty in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    true if there nodes that should be processed, if some were discontinued due to error. false otherwise
  - getDiscontinuedNodes
```
public Collection<Node<T,R>> getDiscontinuedNodes()
```
    Specified by:
    
    getDiscontinuedNodes in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    the @nodes that are waiting to be processed, which were discontinued due to error
  - markDiscontinuedNodesProcessed
```
public void markDiscontinuedNodesProcessed()
```
    Description copied from interface: DexecutorState
    
    clear (or marks) all the discontinued nodes till this point as processed
    
    Specified by:
    
    markDiscontinuedNodesProcessed in interface DexecutorState<T extends Comparable<T>,R>
  - processAfterNoError
```
public void processAfterNoError(Collection<Node<T,R>> nodes)
```
    Description copied from interface: DexecutorState
    
    Add to existing collection of discontinued nodes to be processed later, if system come to valid state.
    
    Specified by:
    
    processAfterNoError in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    nodes - which should be processed after retry success
  - print
```
public void print(Traversar<T,R> traversar,
                  TraversarAction<T,R> action)
```
    Description copied from interface: DexecutorState
    
    Prints the graph into the writer using the Traversar
    
    Specified by:
    
    print in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    traversar - would traverse the graph
    
    action - callback which would be called based on traverse
  - validate
```
public void validate(Validator<T,R> validator)
```
    Description copied from interface: DexecutorState
    
    validates the graph using the validator
    
    Specified by:
    
    validate in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    validator - based on which validation would happen
  - addErrored
```
public void addErrored(T id)
```
    Description copied from interface: DexecutorState
    
    Add to errored collection
    
    Specified by:
    
    addErrored in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    id - id to add to errored collection
  - removeErrored
```
public void removeErrored(T id)
```
    Description copied from interface: DexecutorState
    
    Remove errored collection
    
    Specified by:
    
    removeErrored in interface DexecutorState<T extends Comparable<T>,R>
    
    Parameters:
    
    id - to remove from errored collection
  - erroredCount
```
public int erroredCount()
```
    Specified by:
    
    erroredCount in interface DexecutorState<T extends Comparable<T>,R>
    
    Returns:
    
    Number of errors at this instance of time
  - forcedStop
```
public void forcedStop()
```
    Description copied from interface: DexecutorState
    
    called to force stop
    
    Specified by:
    
    forcedStop in interface DexecutorState<T extends Comparable<T>,R>

Class DefaultDexecutorState<T extends Comparable<T>,R>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultDexecutorState

Method Detail

addIndependent

addDependency

addAsDependentOnAllLeafNodes

addAsDependencyToAllInitialNodes

setCurrentPhase

getCurrentPhase

getInitialNodes

getNonProcessedRootNodes

graphSize

getGraphNode

incrementUnProcessedNodesCount

decrementUnProcessedNodesCount

getUnProcessedNodesCount

shouldProcess

markProcessingDone

getProcessedNodes

isDiscontinuedNodesNotEmpty

getDiscontinuedNodes

markDiscontinuedNodesProcessed

processAfterNoError

print

validate

addErrored

removeErrored

erroredCount

forcedStop