com.github.dexecutor.core.graph

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

java.lang.Object

com.github.dexecutor.core.graph.DefaultDag<T,R>

Type Parameters:

T - Type of Node/Task ID

R - Type of Node/Task result

All Implemented Interfaces:

Dag<T,R>, DependencyAware<T>, Serializable

public final class DefaultDag<T extends Comparable<T>,R>
extends Object
implements Dag<T,R>, Serializable

Default implementation of Graph

Author:

Nadeem Mohammad

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
DefaultDag()

Method Summary

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 evalFirstNode, T evalLaterNode) Should add the two nodes in the datastructure in such a way that evalFirstValue should be evaluated before evalAfterValue.
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.
Collection<Node<T,R>>	allNodes() Returns all nodes in this graph
Node<T,R>	get(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>>	getLeafNodes() Retruns the set of nodes for which there is no outgoing dependencies.
Set<Node<T,R>>	getNonProcessedRootNodes()
int	size() Returns the total number of nodes in this graph

Methods inherited from class java.lang.Object

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

Constructor Detail

DefaultDag

public DefaultDag()

Method Detail

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

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 evalFirstNode,
                          T evalLaterNode)

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:

evalFirstNode - Node which should be evaluated first

evalLaterNode - Node which should be evaluated after evalFirstValue

getInitialNodes

public Set<Node<T,R>> getInitialNodes()

Description copied from interface: Dag

Returns the Set of nodes for which there is no incoming dependencies.

Specified by:

getInitialNodes in interface Dag<T extends Comparable<T>,R>

Returns:

set of initial nodes

getNonProcessedRootNodes

public Set<Node<T,R>> getNonProcessedRootNodes()

Specified by:

getNonProcessedRootNodes in interface Dag<T extends Comparable<T>,R>

Returns:

the root non processed nodes

size

public int size()

Description copied from interface: Dag

Returns the total number of nodes in this graph

Specified by:

size in interface Dag<T extends Comparable<T>,R>

Returns:

total number of nodes in this graph

allNodes

public Collection<Node<T,R>> allNodes()

Description copied from interface: Dag

Returns all nodes in this graph

Specified by:

allNodes in interface Dag<T extends Comparable<T>,R>

Returns:

all nodes in this graph

getLeafNodes

public Set<Node<T,R>> getLeafNodes()

Description copied from interface: Dag

Retruns the set of nodes for which there is no outgoing dependencies.

Specified by:

getLeafNodes in interface Dag<T extends Comparable<T>,R>

Returns:

set of leaf nodes

get

public Node<T,R> get(T id)

Description copied from interface: Dag

Returns the node with the given id

Specified by:

get in interface Dag<T extends Comparable<T>,R>

Parameters:

id - unique node id

Returns:

the @Node with the given id