org.lsst.ccs.description

Class EffectiveNode

java.lang.Object

org.lsst.ccs.description.EffectiveNode

All Implemented Interfaces:

Serializable

public class EffectiveNode
extends Object

This class is to replace the initial ComponentNode class. Each node contains only an actual object that can be used by the application. (contrary to DescriptiveNode that contains only a description)

Author:

bamade

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected Map	attributes for a DescriptiveNode the description of parameters not used for EffectiveNode (but might be with a copy of parameters description)
protected ArrayList<T>	children
protected String	key the key of the node
protected static Logger	logger
protected String	name todo: righ now key and name should be the same ..
protected IndirectMap<String,org.lsst.ccs.description.ComponentNode>	nodeDict A dictionary of all nodes in the tree.
protected T	parent
protected Z	realValue for DescriptiveNode the Class of the future object for an EffectiveNode the actual object

Constructor Summary

Constructors

Constructor and Description
EffectiveNode(IndirectMap<String,org.lsst.ccs.description.ComponentNode> registry, String name, String key, Object value, DescriptiveNode descriptiveNode)

Method Summary

Modifier and Type	Method and Description
void	addChild(T child) adds a ComponentNode as a child of the current node
void	adoptOrphans(IndirectMap<String,org.lsst.ccs.description.ComponentNode> registry, ArrayList<EffectiveNode> children, EffectiveNode parent)
protected void	checkDict(T parent, String name, Map attributes) prepare the setDict call Beware should be used only in top-down build of the tree
Iterator<String>	getAllKeys()
Iterable<String>	getAllNames()
Map	getAttributes()
ArrayList<T>	getChildren()
Object	getIndirect(Object key)
String	getKey()
String	getName()
T	getNodeByName(String name)
IndirectMap	getNodeDict()
T	getParent()
Z	getRealValue()
void	proceduralNodeWalk(Consumer<T> pre, Consumer<T> post)
<V> void	proceduralWalk(Class<V> klass, Consumer<V> pre, Consumer<V> post)
protected void	setDict(IndirectMap<String,org.lsst.ccs.description.ComponentNode> registry, String name, Map attributes) set the dictionary of the node and set the entry of this Node in the Dictionary
String	toString()
<V> TreeWalkerDiag	treeWalk(Class<V> klass, Function<V,TreeWalkerDiag> func, Consumer<V> post) Walks the components tree recursively, applying rules of TreeWalkerDiag (the walk can be interrupted by HANDLING_CHILDREN (the code is not invoked on children) or STOP (the code abruptly ends)

Methods inherited from class java.lang.Object

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

Field Detail

logger

protected static final Logger logger

nodeDict

protected IndirectMap<String,org.lsst.ccs.description.ComponentNode> nodeDict

A dictionary of all nodes in the tree. name duplications should be detected

key

protected String key

the key of the node

parent

protected T extends org.lsst.ccs.description.ComponentNode<T,Z> parent

children

protected ArrayList<T extends org.lsst.ccs.description.ComponentNode<T,Z>> children

name

protected String name

todo: righ now key and name should be the same .. if separate one must change the use of the dictionary

realValue

protected Z realValue

for DescriptiveNode the Class of the future object for an EffectiveNode the actual object

attributes

protected Map attributes

for a DescriptiveNode the description of parameters not used for EffectiveNode (but might be with a copy of parameters description)

Constructor Detail

EffectiveNode

public EffectiveNode(IndirectMap<String,org.lsst.ccs.description.ComponentNode> registry,
                     String name,
                     String key,
                     Object value,
                     DescriptiveNode descriptiveNode)

Method Detail

adoptOrphans

public void adoptOrphans(IndirectMap<String,org.lsst.ccs.description.ComponentNode> registry,
                         ArrayList<EffectiveNode> children,
                         EffectiveNode parent)
                  throws NullPointerException,
                         IllegalArgumentException

Parameters:

registry -

children -

parent -

Throws:

NullPointerException

IllegalArgumentException

getNodeDict

public IndirectMap getNodeDict()

checkDict

protected void checkDict(T parent,
                         String name,
                         Map attributes)

prepare the setDict call Beware should be used only in top-down build of the tree

Parameters:

parent -

name -

attributes -

setDict

protected void setDict(IndirectMap<String,org.lsst.ccs.description.ComponentNode> registry,
                       String name,
                       Map attributes)

set the dictionary of the node and set the entry of this Node in the Dictionary

Parameters:

registry -

name -

attributes -

getName

public String getName()

getRealValue

public Z getRealValue()

getNodeByName

public T getNodeByName(String name)

getIndirect

public Object getIndirect(Object key)

getAllKeys

public Iterator<String> getAllKeys()

getAllNames

public Iterable<String> getAllNames()

getAttributes

public Map getAttributes()

getKey

public String getKey()

getChildren

public ArrayList<T> getChildren()

Returns:

the list of child nodes, null if there aren't any

addChild

public void addChild(T child)
              throws NullPointerException

adds a ComponentNode as a child of the current node

Parameters:

child - to be added to the node

Throws:

NullPointerException - if child is null

toString

public String toString()

Overrides:

toString in class Object

getParent

public T getParent()

proceduralWalk

public <V> void proceduralWalk(Class<V> klass,
                               Consumer<V> pre,
                               Consumer<V> post)

proceduralNodeWalk

public void proceduralNodeWalk(Consumer<T> pre,
                               Consumer<T> post)

treeWalk

public <V> TreeWalkerDiag treeWalk(Class<V> klass,
                                   Function<V,TreeWalkerDiag> func,
                                   Consumer<V> post)

Walks the components tree recursively, applying rules of TreeWalkerDiag (the walk can be interrupted by HANDLING_CHILDREN (the code is not invoked on children) or STOP (the code abruptly ends)

Parameters:

func -

post -

Returns:

a TreeWalkerDiag indicating how the next Configurable should be handled