TreeNodeBase

java.lang.Object
- org.vishia.util.TreeNodeBase<DerivedNode,Data,IfcType>

Type Parameters:: Data - The type of additional data which are referenced in this node. Use Object if data are not used.; DerivedNode - Type of the TreeNode which is build with this class as superclass. If one will only use the underived TreeNodeBase, use TreeNodeBase.TreeNode instead.

All Implemented Interfaces:: java.lang.Iterable<DerivedNode>, SortedTree<IfcType>, TreeNode_ifc<DerivedNode,Data>

Direct Known Subclasses:: TreeNodeBase.MetaNode, TreeNodeBase.TreeNode, XmlNodeSimple

public class TreeNodeBase<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data,IfcType extends SortedTree<IfcType>>
extends java.lang.Object
implements TreeNode_ifc<DerivedNode,Data>, SortedTree<IfcType>, java.lang.Iterable<DerivedNode>

This class is a base class for data, which are organized itself in a tree node structure. The difference to data which are organized in a TreeMap for example is: Members of a TreeMap are organized in a tree, but there are not nodes itself. The TreeMap is one of more possibly access forms. The same data may be organized in another TreeMap with another key at the same time, it may be organized in a List in the same time or in an array. The node of a TreeMap is not visible for usage.
Data which based on this class are intrinsic nodes which are beneficial and visible as node. Every node of them has one master key to search it in a tree of nodes.

A known example for such nodes are elements of a XML tree. Any element has its parent and some children. It is a node in an intrinsic modality. The master key is the tag name combined with the nameSpace key. The XPATH searches nodes in a tree with given tag names.

UML-Diagram, presentation style see Docu_UML_simpleNotation:

 
                                    TreeNodeBase
                                        |---data---> T (may be null)
       TreeNodeBase <---parent----------|
       (maybe null)                     |                    TreeNodeBase
                                        |                        |
                                        |------childNodes------*>|
                                        |                        |---data------> T 
                                        |<------------parent-----|        (a leaf if it hasn't 
                                        |                                  childNodes)
                                        |----leafData-----*> T (leafs)

The TreeNode refers to its node data.
The TreeNode refers to its children,
The TreeNode refers to its parent.

The data may refer its associated node. It may be a final reference (aggregation). That means, the data represents a node. Then both instances should be joined in the constructor of data: Sample:

 class MyData{
   final TreeNodeBase node;
   MyData(MyData parent){
     this.node = new TreeNodeBase(parent.node, this);
   }
 }

Children with key, sorted selection enabled:

*

 
                                    TreeNode
                                      -key
                                        |------data-------> T (data, may be null)
       TreeNode <---parent--------------|
       (maybe null)                     |------idxChildren-----------key*>|
                                        |                               TreeNode (children) unique
                                        |------unsortedChildren---------*>|
                                        |                                 |-------data-------> T 
                                        |<------------parent--------------|              (the leaf if another node 
                                                                                          is not referenced)

The TreeNode refers to its node data. It has a key.
The TreeNode refers to its children, both with its ambiguous key (sorted) and unsorted.
The TreeNode refers to its parent.

Usage for more as one data with the same key:

                                    !Meta-Node for all nodes 
             !parent                !with same key 
             TreeNodeBase           TreeNodeBase             TreeNodeBase  
                |                   -key                     !one of the children
                |                      |                     -key
                |---data-->T           |--data->null            |
   <---parent---|                      |--idxChildren-->null    |
                |--idxChildren----key*>|                        |---data-->T the data
                |                      |--childNodes----------*>|
                |                      |                        |--idxChildren--->maybe deeper nodes or null
                |                      |                        |--childNodes---->maybe deeper nodes or null
                |<-----------parent----|<---------parent--------|
                |                                               |
                |--childNodes---------------------------------*>|

Sometimes a container should refer more as one data with the same key. That is not possible if the java.util.TreeMap is used, it supports only one key per data. For example for XML data an element can contain more as one sub element with the same tag name

The parent TreeNodeBase refers to all children independent of their key with the childNodes() reference. That is because this list of children represents the creation order. For example for XML nodes it is the order in the XML file.
The parent TreeNodeBase refers to a TreeNodeBase which is a meta node for the key. It is referenced with the parent's nd_idxChildren. This meta node refers all children with the same key with its childNodes() list. The order is the creation order.
The field nd_data of the meta node is left empty, because the data are located in childNodes().nd_data. The field nd_idxChildren is left empty too because there are no children with other keys than the only one.
The child node refers the meta node as its parent. That is important for detach. The parent of the meta node refers the real parent.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`TreeNodeBase.IteratorDerivedImpl` It is similar like `TreeNodeBase.IteratorImpl` but with DerivedNode as return.
`protected class`	`TreeNodeBase.IteratorDerivedNode`
`protected class`	`TreeNodeBase.IteratorImpl`
`protected class`	`TreeNodeBase.IteratorMetaNode`
`protected class`	`TreeNodeBase.IteratorOneNode`
`protected static class`	`TreeNodeBase.MetaNode<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data,IfcType extends SortedTree<IfcType>>`
`static class`	`TreeNodeBase.TreeNode<Data>` This class provides a ready to use TreeNode without additional functionality like TreeNodeBase.

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.lang.String`	`metaNodeKey` This instance is used if the node is a meta node to refer more as one child with the same key.
`Data`	`nd_data` Any additional data associated with this node.
`protected DerivedNode`	`nd_firstChild` The List of child nodes in order of adding.
`protected java.util.Map<java.lang.String,TreeNodeBase<DerivedNode,Data,IfcType>>`	`nd_idxChildren` The child nodes sorted to the key.
`protected java.lang.String`	`nd_key` The key which is used in the `nd_idxChildren` of the parent.
`protected DerivedNode`	`nd_lastChild` The List of child nodes in order of adding.
`java.util.List<Data>`	`nd_leafData` Instances which are a leaf of this node.
`protected DerivedNode`	`nd_next` The List of child nodes in order of adding.
`protected int`	`nd_nrofChildren`
`protected TreeNodeBase<DerivedNode,Data,IfcType>`	`nd_parent` The parent is a metaNodeKey if there is more as one child with the same key.
`protected DerivedNode`	`nd_prev` The List of child nodes in order of adding.
`static int`	`version` Version, history and license.

Constructor Summary

Constructors
Modifier	Constructor and Description
	`TreeNodeBase(java.lang.String key, Data data)` Creates a new unbounded node.
`protected`	`TreeNodeBase(java.lang.String key, Data data, TreeNodeBase<DerivedNode,Data,IfcType> parent)` Creates a new unbounded node.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addLeaf(Data leaf)` Deprecated.
`void`	`addNode(DerivedNode childNode)` Adds a given child node.
`DerivedNode`	`addNode(java.lang.String itsKey, Data leaf)` create a child node and adds it.
`void`	`addNodeFirst(DerivedNode childNode)`
`private void`	`addNodeKeyed(DerivedNode childNode, TreeNodeBase<DerivedNode,Data,IfcType> prev)` Adds the child node in the index of nodes with key of this parent and set the parent of child.
`void`	`addSiblingNext(DerivedNode childNode)` Adds a new node behind the given node as sibling of this respectively child of this parent.
`void`	`addSiblingPrev(DerivedNode childNode)` Adds a new node before the given node as sibling of this respectively child of this parent.
`java.util.List<DerivedNode>`	`childNodes()` The List of child nodes in order of adding.
`protected java.util.List<DerivedNode>`	`childNodes(TreeNodeBase<DerivedNode,Data,IfcType> node)`
`void`	`detach()` Detaches the node from its tree.
`DerivedNode`	`firstChild()` Returns the first of all children.
`IfcType`	`getChild(java.lang.String sKey)` Returns the node with the given key.
`java.util.List<DerivedNode>`	`getContainerChildren(java.lang.String sKey)` Returns the container with children with the same key.
`java.lang.String`	`getKey()` Returns the key of this node.
`DerivedNode`	`getNode(java.lang.String path, java.lang.String separator)` Returns any selected node in the tree.
`DerivedNode`	`getOrCreateNode(java.lang.String path, java.lang.String separator)` Searches a node with the path, creates it if it is not found.
`IfcType`	`getParent()` Gets the parent of this node or null if it is the root node or it is `detach()`.
`Data`	`getParentData()`
`boolean`	`hasChildren()`
`IterableIterator<DerivedNode>`	`iterator()` It returns an instance which can used as both as `Iterator` and as `Iterable`.
`IterableIterator<DerivedNode>`	`iteratorChildren()` Returns an iterator through the list of all children of the node.
`IterableIterator<DerivedNode>`	`iteratorChildren(java.lang.String keyP)`
`java.util.Iterator<IfcType>`	`iterChildren()` Returns an iterator through the list of all children of the node.
`java.util.Iterator<IfcType>`	`iterChildren(java.lang.String sKey)` Returns an iterator through the list of all children with the given key.
`DerivedNode`	`lastChild()` Returns the last of all children.
`java.util.List<IfcType>`	`listChildren()` Returns a List of all children of the node.
`java.util.List<IfcType>`	`listChildren(java.lang.String sKey)` Searches the child node with the given key.
`void`	`movetoFirstChild(DerivedNode src)` Remove the dst node from its bough and add it as the first child of this.
`void`	`movetoSiblingNext(DerivedNode src)` Remove the dst node from its bough and add it as next sibling after this.
`void`	`movetoSiblingPrev(DerivedNode src)` Remove the dst node from its bough and add it as previous sibling before this.
`protected DerivedNode`	`newNode(java.lang.String keyP, Data dataP)` This method has to be overridden in the derived class.
`DerivedNode`	`nextSibling()`
`int`	`nrofChildren()` Returns the number of children.
`DerivedNode`	`parent()`
`boolean`	`parentEquals(TreeNode_ifc<DerivedNode,Data> cmp)` Checks whether the parent is a known node.
`DerivedNode`	`prevSibling()`
`void`	`removeChildren()` Remove all children of this node.
`void`	`swap(DerivedNode other)` Swaps two nodes, this and dst.
`java.lang.String`	`toString()`
`private TreeNodeCallback.Result`	`walkSubTree(DerivedNode node, int depth, TreeNodeCallback<DerivedNode> callback)`
`void`	`walkTree(DerivedNode root, int depth, TreeNodeCallback<DerivedNode> callback)` Walk through the tree.

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - version
```
public static final int version
```
    Version, history and license.
    - 2017-08-27 Hartmut chg: Rename all variables in TreeNodeBase with prefix nd_, better for debug, distinguish between super class variables nd_ and specific variables
    - 2017-08-27 Hartmut new: Implementation of iteratorChildren() but with TreeNodeBase.IteratorDerivedImpl which returns the next() as user type node TODO: iteratorChildren(String) gardening with documentation and test.
    - 2014-02-09 Hartmut preparing new methods: movetoSiblingNext(TreeNodeBase), swap(TreeNodeBase)
    - 2013-11-03 Hartmut bugfix: Problem on removeChildren() if an exception was before.
    - 2013-11-03 Hartmut bugfix: iterChildren() have to be return null, see its interface-definition. It had returned an Iterator, which first Iterator.hasNext() returns false. But with them it is not determined simply whether a node has children or not. The SimpleXmlOutputter has not worked correctly. There the decision whether the text() of a node should be output depends on the existence of children. If it has children, the children contains the text() already.
    - 2013-11-03 Hartmut chg: Restructuring: Don't use the ListNodes with index etc, Use a double queue. New TreeNodeBase.IteratorDerivedNode etc.
    - 2013-11-03 Hartmut new: firstChild(), lastChild(). Some methods returns the DerivedNode yet instead a reference of Type TreeNodeBase or IfcType. Only methods which are declared in SortedTree returns the IfcType. It is better for usage. A node is always type of DerivedNode because it is declared and known as forward reference.
    - 2013-11-03 Hartmut new: #addNode(TreeNodeBase, int) not on end.
    - 2013-11-03 Hartmut new: nd_next, nd_prev and nd_lastChild for sibling navigation.
    - 2013-03-02 Hartmut chg: Usage of ArrayList instead LinkedList for children- better ability to debug.
    - 2012-11-03 Hartmut new: Generic type DerivedNode and IfcType to support derived types of this. The returned container types have elements of this DerivedNode type or the IfcType. The IfcType is used on methods which are defined in SortedTree.
    - 2012-11-01 Hartmut Constructor with parent is faulty because the parent will be set on parent.addNode(...).
    - 2012-11-01 Hartmut This class contains the sorted and the unsorted management of nodes inclusive multiple nodes with the same key. This class is used for XmlNodeSimple and has reduced the complexity of that class.
    - 2012-07-20 Hartmut creation: it is the base class for a node which is unsorted firstly. The derived class TreeNodeUniqueKey is sorted than.
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL ist not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    
    Constant Field Values
  - metaNodeKey
```
private static java.lang.String metaNodeKey
```
    This instance is used if the node is a meta node to refer more as one child with the same key.
  - nd_key
```
protected final java.lang.String nd_key
```
    The key which is used in the nd_idxChildren of the parent. Note that a key need not be unique. A parent can have children with the same key.
  - nd_parent
```
protected TreeNodeBase<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data,IfcType extends SortedTree<IfcType>> nd_parent
```
    The parent is a metaNodeKey if there is more as one child with the same key. To get the real parent, use parent().
  - nd_prev
```
protected DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType> nd_prev
```
    The List of child nodes in order of adding. All nodes in this list are type of the DerivedNode. This order may be different from the sorted order in idxChildren. The sub nodes have to sorting orders. The order of adding and insertion with this elements and the order with a key. This is the primary list.
  - nd_next
```
protected DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType> nd_next
```
    The List of child nodes in order of adding. All nodes in this list are type of the DerivedNode. This order may be different from the sorted order in idxChildren. The sub nodes have to sorting orders. The order of adding and insertion with this elements and the order with a key. This is the primary list.
  - nd_firstChild
```
protected DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType> nd_firstChild
```
    The List of child nodes in order of adding. All nodes in this list are type of the DerivedNode. This order may be different from the sorted order in idxChildren. The sub nodes have to sorting orders. The order of adding and insertion with this elements and the order with a key. This is the primary list.
  - nd_lastChild
```
protected DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType> nd_lastChild
```
    The List of child nodes in order of adding. All nodes in this list are type of the DerivedNode. This order may be different from the sorted order in idxChildren. The sub nodes have to sorting orders. The order of adding and insertion with this elements and the order with a key. This is the primary list.
  - nd_idxChildren
```
protected java.util.Map<java.lang.String,TreeNodeBase<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data,IfcType extends SortedTree<IfcType>>> nd_idxChildren
```
    The child nodes sorted to the key. The key is given with the child itself, attribute nd_key. This index can contain a so named 'meta node' which holds more as one child with the same key. Note that the meta node is not registered in the childNodes(). The sorting with key may not be necessary in some kinds, then this element is null. Don't use it to get a list of children. Use nd_firstChild etc. instead.
  - nd_leafData
```
public java.util.List<Data> nd_leafData
```
    Instances which are a leaf of this node. That leafs should not need a node to wrap it. The tree is not visible from a leaf because such a leaf is not a TreeNode. If you want to refer from a leaf to its parent, use a node without childNodes and left this list empty.
  - nd_nrofChildren
```
protected int nd_nrofChildren
```
  - nd_data
```
public final Data nd_data
```
    Any additional data associated with this node.
- Constructor Detail
  - TreeNodeBase
```
public TreeNodeBase(java.lang.String key,
                    Data data)
```
    Creates a new unbounded node.
    
    Parameters:
    
    key - The key will be used if the tree is sorted. It can be null, then the tree is not sorted. The key is used to search this nodes by its key in the parent node or from any grandparent node with the path.
    
    data - User data of this node.
  - TreeNodeBase
```
protected TreeNodeBase(java.lang.String key,
                       Data data,
                       TreeNodeBase<DerivedNode,Data,IfcType> parent)
```
    Creates a new unbounded node.
    
    Parameters:
    
    key - The key will be used if the tree is sorted. It can be null, then the tree is not sorted. The key is used to search this nodes by its key in the parent node or from any grandparent node with the path.
    
    data - User data of this node.
- Method Detail
  - newNode
```
protected DerivedNode newNode(java.lang.String keyP,
                              Data dataP)
```
    This method has to be overridden in the derived class. It has to be created an instance of the DerivedNode type.
    
    Parameters:
    
    nd_key - see TreeNodeBase(String, Object)
    
    nd_data - see TreeNodeBase(String, Object)
    
    Returns:
    
    Instance of the DerivedNode class
  - addLeaf
```
@Deprecated
public void addLeaf(Data leaf)
```
    Deprecated.
    
    adds a leaf.
    
    Parameters:
    
    leaf - The data to add.
  - addNode
```
public DerivedNode addNode(java.lang.String itsKey,
                           Data leaf)
```
    create a child node and adds it. This method is only proper to use if the DerivedNode has not a more complex constructor. As opposite one can create a DerivedNode in the application level and invoke addNode(TreeNodeBase)
    
    Specified by:
    
    addNode in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Parameters:
    
    itsKey - The key may be free defined outside, independent of the content of the child. This key is used to find out children.
    
    leaf - The data of the node.
  - addNode
```
public void addNode(DerivedNode childNode)
```
    Adds a given child node.
    
    Specified by:
    
    addNode in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Parameters:
    
    itsKey - The key may be free defined outside, independent of the content of the child. This key is used to find out children.
    
    leaf - The data of the node.
  - addNodeFirst
```
public void addNodeFirst(DerivedNode childNode)
```
    Specified by:
    
    addNodeFirst in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - addSiblingNext
```
public void addSiblingNext(DerivedNode childNode)
```
    Adds a new node behind the given node as sibling of this respectively child of this parent.
    
    Specified by:
    
    addSiblingNext in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Parameters:
    
    childNode -
  - addSiblingPrev
```
public void addSiblingPrev(DerivedNode childNode)
```
    Adds a new node before the given node as sibling of this respectively child of this parent.
    
    Parameters:
    
    childNode - The yet not added new instance of node.
  - addNodeKeyed
```
private void addNodeKeyed(DerivedNode childNode,
                          TreeNodeBase<DerivedNode,Data,IfcType> prev)
```
    Adds the child node in the index of nodes with key of this parent and set the parent of child. The referenced parent of the child is the metaNode if the key is not unique.
    
    Parameters:
    
    childNode -
  - swap
```
public void swap(DerivedNode other)
```
    Swaps two nodes, this and dst. Both nodes are members of any treeNode bought. It is not necessary that both TreeNode have the same root. This and dst may be siblings.
    
    Parameters:
    
    dst - The tree node which is swapped with this.
  - movetoSiblingNext
```
public void movetoSiblingNext(DerivedNode src)
```
    Remove the dst node from its bough and add it as next sibling after this. It is not necessary that both TreeNode have the same root. This and dst may be siblings.
    
    Parameters:
    
    src - the tree node which should be removed and add as next sibling of this.
  - movetoSiblingPrev
```
public void movetoSiblingPrev(DerivedNode src)
```
    Remove the dst node from its bough and add it as previous sibling before this. It is not necessary that both TreeNode have the same root. This and dst may be siblings.
    
    Parameters:
    
    src - the tree node which should be removed and add as next sibling of this.
  - movetoFirstChild
```
public void movetoFirstChild(DerivedNode src)
```
    Remove the dst node from its bough and add it as the first child of this. If this has children already, at least one, it is the same like firstChild().movetoSiblingPrev(src). But if this has not children, it is the first one. It is not necessary that both TreeNode have the same root. This and dst may be siblings.
    
    Parameters:
    
    src - the tree node which should be removed and add as next sibling of this.
  - detach
```
public void detach()
```
    Detaches the node from its tree. A node can only be member of one tree of TreeNodeBase, not member of more as one. Any TreeNodeBase has its getParent(). Nevertheless you can refer any node within another structure of data.
    
    If a node is detached, it can be added in another tree of the same type.
    
    Specified by:
    
    detach in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - removeChildren
```
public void removeChildren()
```
    Remove all children of this node. The immediate children will be detached from this node. The children of that children would not be detached from its parent. But if the children are not referenced anyway other they are removed from space (garbage collected). Note: Use detach() for any child node if it and their sub tree should be used furthermore.
    
    Specified by:
    
    removeChildren in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - getKey
```
public java.lang.String getKey()
```
    Returns the key of this node.
    
    Specified by:
    
    getKey in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Returns:
    
    the key, null if the node is not sorted.
  - getParentData
```
public Data getParentData()
```
    Specified by:
    
    getParentData in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - getNode
```
public DerivedNode getNode(java.lang.String path,
                           java.lang.String separator)
```
    Returns any selected node in the tree.
    
    Specified by:
    
    getNode in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Parameters:
    
    path - The path may have more as one key to traverse into the boughs of the tree.
    
    separator - Separator between key elements in path. If null then only one level, since 2019-04.
    
    Returns:
  - getOrCreateNode
```
public DerivedNode getOrCreateNode(java.lang.String path,
                                   java.lang.String separator)
```
    Searches a node with the path, creates it if it is not found.
    
    Specified by:
    
    getOrCreateNode in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Parameters:
    
    path - path of keys, see getNode(String, String)
    
    separator - The separator in path.
    
    Returns:
    
    always a node with given key
  - getParent
```
public IfcType getParent()
```
    Gets the parent of this node or null if it is the root node or it is detach().
    
    Specified by:
    
    getParent in interface SortedTree<IfcType extends SortedTree<IfcType>>
    
    See Also:
    
    SortedTree.getParent()
  - parent
```
public DerivedNode parent()
```
    Specified by:
    
    parent in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - parentEquals
```
public boolean parentEquals(TreeNode_ifc<DerivedNode,Data> cmp)
```
    Description copied from interface: TreeNode_ifc
    
    Checks whether the parent is a known node. This test can be done for example to check whether the parent is the root node. Note that especially the root node may be from another type. Therefore parent() fails because a ClassCastException to the DerivedNode.
    
    Specified by:
    
    parentEquals in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Parameters:
    
    cmp - The node to compare with
    
    Returns:
    
    true if the parent node is the same instance as the given node.
  - nextSibling
```
public DerivedNode nextSibling()
```
    Specified by:
    
    nextSibling in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - prevSibling
```
public DerivedNode prevSibling()
```
    Specified by:
    
    prevSibling in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - childNodes
```
public java.util.List<DerivedNode> childNodes()
```
    The List of child nodes in order of adding. All nodes in this list are type of the DerivedNode.
  - nrofChildren
```
public int nrofChildren()
```
    Returns the number of children.
    
    Specified by:
    
    nrofChildren in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Returns:
    
    0 if the node has not children.
  - firstChild
```
public DerivedNode firstChild()
```
    Returns the first of all children.
    
    Specified by:
    
    firstChild in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Returns:
    
    null if the node has not children.
  - hasChildren
```
public boolean hasChildren()
```
    Specified by:
    
    hasChildren in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - lastChild
```
public DerivedNode lastChild()
```
    Returns the last of all children.
    
    Specified by:
    
    lastChild in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Returns:
    
    null if the node has not children.
  - getChild
```
public IfcType getChild(java.lang.String sKey)
```
    Returns the node with the given key. If there are more as one node with the same key, the first node is returned.
    
    Specified by:
    
    getChild in interface SortedTree<IfcType extends SortedTree<IfcType>>
    
    Parameters:
    
    sKey -
    
    Returns:
    
    null if a node with the key is not referred from this node directly.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - iterator
```
public IterableIterator<DerivedNode> iterator()
```
    It returns an instance which can used as both as Iterator and as Iterable. It means the routines Iterator.hasNext() etc. are able to call and Iterable.iterator() is able to call, which returns this. In this kind the method can be used in a for-container-loop.
    
    Specified by:
    
    iterator in interface java.lang.Iterable<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>>
  - iteratorChildren
```
public IterableIterator<DerivedNode> iteratorChildren(java.lang.String keyP)
```
    Specified by:
    
    iteratorChildren in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
  - iterChildren
```
public java.util.Iterator<IfcType> iterChildren()
```
    Description copied from interface: SortedTree
    
    Returns an iterator through the list of all children of the node.
    
    Specified by:
    
    iterChildren in interface SortedTree<IfcType extends SortedTree<IfcType>>
    
    Returns:
    
    The iterator or null if there isn't any children.
  - iteratorChildren
```
public IterableIterator<DerivedNode> iteratorChildren()
```
    Description copied from interface: TreeNode_ifc
    
    Returns an iterator through the list of all children of the node.
    
    Specified by:
    
    iteratorChildren in interface TreeNode_ifc<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data>
    
    Returns:
    
    The iterator or null if there isn't any children.
  - iterChildren
```
public java.util.Iterator<IfcType> iterChildren(java.lang.String sKey)
```
    Description copied from interface: SortedTree
    
    Returns an iterator through the list of all children with the given key.
    
    Specified by:
    
    iterChildren in interface SortedTree<IfcType extends SortedTree<IfcType>>
    
    Parameters:
    
    sKey - The key of the demanded child. The implementation may have extra possibilities, see getChild(String).
    
    Returns:
    
    A iterator through the list of all children with the given key or null if there is no such child.
  - listChildren
```
public java.util.List<IfcType> listChildren()
```
    Description copied from interface: SortedTree
    
    Returns a List of all children of the node.
    
    Specified by:
    
    listChildren in interface SortedTree<IfcType extends SortedTree<IfcType>>
    
    Returns:
    
    The List or null if there isn't any children.
  - listChildren
```
public java.util.List<IfcType> listChildren(java.lang.String sKey)
```
    Searches the child node with the given key. If the child node is a meta node for more as one child, its childNodes(TreeNodeBase) list is the proper return value. But if the child node refers only one child, a list with this one element is built temporary because this method should return a list anyway.
    
    Specified by:
    
    listChildren in interface SortedTree<IfcType extends SortedTree<IfcType>>
    
    Parameters:
    
    sKey - The key of the demanded child. The implementation may have extra possibilities, see getChild(String).
    
    Returns:
    
    A List of all children with the given key or null if there is no such child.
    
    See Also:
    
    SortedTree.listChildren(java.lang.String)
  - walkTree
```
public void walkTree(DerivedNode root,
                     int depth,
                     TreeNodeCallback<DerivedNode> callback)
```
    Walk through the tree. On any node one of the callback methods are invoked. Their return value determines whether child nodes are walked through or not or whether the walking should be aborted.
    
    Parameters:
    
    root - The start node
    
    depth - Maximum number of child levels, maybe Integer.MAX_VALUE
    
    callback - The callback should be implemented by the user to evaluate and control the walking.
  - walkSubTree
```
private TreeNodeCallback.Result walkSubTree(DerivedNode node,
                                            int depth,
                                            TreeNodeCallback<DerivedNode> callback)
```
  - getContainerChildren
```
public java.util.List<DerivedNode> getContainerChildren(java.lang.String sKey)
```
    Returns the container with children with the same key.
    
    Parameters:
    
    sKey -
    
    Returns:
    
    null if it is not a container.
  - childNodes
```
protected java.util.List<DerivedNode> childNodes(TreeNodeBase<DerivedNode,Data,IfcType> node)
```

Class TreeNodeBase<DerivedNode extends TreeNodeBase<DerivedNode,Data,IfcType> & SortedTree<IfcType>,Data,IfcType extends SortedTree<IfcType>>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

version

metaNodeKey

nd_key

nd_parent

nd_prev

nd_next

nd_firstChild

nd_lastChild

nd_idxChildren

nd_leafData

nd_nrofChildren

nd_data

Constructor Detail

TreeNodeBase

TreeNodeBase

Method Detail

newNode

addLeaf

addNode

addNode

addNodeFirst

addSiblingNext

addSiblingPrev

addNodeKeyed

swap

movetoSiblingNext

movetoSiblingPrev

movetoFirstChild

detach

removeChildren

getKey

getParentData

getNode

getOrCreateNode

getParent

parent

parentEquals

nextSibling

prevSibling

childNodes

nrofChildren

firstChild

hasChildren

lastChild

getChild

toString

iterator

iteratorChildren

iterChildren

iteratorChildren

iterChildren

listChildren

listChildren

walkTree

walkSubTree

getContainerChildren

childNodes