DefaultDexecutorState (Dependent Tasks Executor Core 1.1.2 API)

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

All Implemented Interfaces:: DexecutorState<T,R>

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

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)` Add Two dependent nodes into the graph, creating the nodes if not already present
`void`	`addIndependent(T nodeValue)` Add a node as independent, it does not require any dependent node
`void`	`decrementUnProcessedNodesCount()` decrements the count of total number of unprocessed nodes
`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.
`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
`void`	`initState()` Initialize the Dexecutor state, either to new or existing state
`boolean`	`isDiscontinuedNodesNotEmpty()`
`void`	`markDiscontinuedNodesProcessed()` clear (or marks) all the discontinued nodes till this point as processed
`void`	`markProcessingDone(Node<T,R> node)` Mark the `node` as processed.
`void`	`print(Traversar<T,R> traversar, Writer writer)` 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`	`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
  - initState
```
public void initState()
```
    Description copied from interface: DexecutorState
    
    Initialize the Dexecutor state, either to new or existing state
    
    Specified by:
    
    initState in interface DexecutorState<T extends Comparable<T>,R>
  - addIndependent
```
public void addIndependent(T nodeValue)
```
    Description copied from interface: DexecutorState
    
    Add a node as independent, it does not require any dependent node
    
    Specified by:
    
    addIndependent in interface DexecutorState<T extends Comparable<T>,R>
  - addDependency
```
public void addDependency(T evalFirstValue,
                 T evalAfterValue)
```
    Description copied from interface: DexecutorState
    
    Add Two dependent nodes into the graph, creating the nodes if not already present
    
    evalFirstValue would be executed first and then evalAfterValue
    
    Specified by:
    
    addDependency in interface DexecutorState<T extends Comparable<T>,R>
  - addAsDependentOnAllLeafNodes
```
public void addAsDependentOnAllLeafNodes(T nodeValue)
```
    Description copied from interface: DexecutorState
    
    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 DexecutorState<T extends Comparable<T>,R>
  - addAsDependencyToAllInitialNodes
```
public void addAsDependencyToAllInitialNodes(T nodeValue)
```
    Description copied from interface: DexecutorState
    
    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 DexecutorState<T extends Comparable<T>,R>
  - 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>
  - 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
  - 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>
    
    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>
    
    Returns:
    weather the node should be processed by dexecutor or not
  - markProcessingDone
```
public void markProcessingDone(Node<T,R> node)
```
    Description copied from interface: DexecutorState
    
    Mark the node as processed.
    
    Specified by:
    
    markProcessingDone in interface DexecutorState<T extends Comparable<T>,R>
  - 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>
  - print
```
public void print(Traversar<T,R> traversar,
         Writer writer)
```
    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>
  - 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>

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultDexecutorState

Method Detail

initState

addIndependent

addDependency

addAsDependentOnAllLeafNodes

addAsDependencyToAllInitialNodes

setCurrentPhase

getCurrentPhase

getInitialNodes

graphSize

getGraphNode

incrementUnProcessedNodesCount

decrementUnProcessedNodesCount

getUnProcessedNodesCount

shouldProcess

markProcessingDone

getProcessedNodes

isDiscontinuedNodesNotEmpty

getDiscontinuedNodes

markDiscontinuedNodesProcessed

processAfterNoError

print

validate