Tree (ds 1.2 API)

java.lang.Object
- de.agentlab.ds.tree.Tree<T>

All Implemented Interfaces:

java.io.Serializable
```
public class Tree<T>
extends java.lang.Object
implements java.io.Serializable
```
A collection container that arranges the elements in a tree-like structure. Each element can only be added to the tree once (as in a set). The elements that are managed by the container do not have to implement a particular interface or extend a given base class. Instead, the container internally wraps each element within a Node object that manages the relationships with other elements.
A tree can have multiple root nodes, thus making it effectively a forrest. Since this denomination is far less known than the term tree, we will stick with the latter term.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static long serialVersionUID

Fields
Modifier and Type	Field and Description
`static long`	`serialVersionUID`

Constructor Summary

Constructors
Constructor and Description

Tree()

Constructors
Constructor and Description
`Tree()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`T`	`add(T data)` Adds the given element to the tree.
`T`	`addChild(T parent, T data)` Adds the a new element as child of the parent element.
`T`	`addChildAfter(T sibling, T data)` Adds the given element to the parent of the sibling after the sibling.
`T`	`addChildAt(T parent, int index, T data)` Adds the given element to the parent at the specified position.
`T`	`addChildBefore(T sibling, T data)` Adds the given element to the parent of the sibling before the sibling.
`T`	`addParent(T data, T newParent)` Adds an element as parent of the given element.
`void`	`addSubtree(Tree<T> subtree)` Adds the given tree as subtree starting at the root.
`void`	`addSubtree(T parent, Tree<T> subtree)` Adds the given tree as subtree starting at the given parent node.
`static <T> Tree<T>`	`asDegeneratedTree(T... l)` Helper method to build a degenerated tree (i.e. a tree with only a single path) from the given list of elements.
`java.util.List<T>`	`asList()` Returns the elements of the tree as pre-ordered list.
`static <T> Tree<T>`	`asTree(T... l)` Helper method to build a tree from the given list of elements.
`int`	`childIndexOf(T data)` Returns the index of the first occurrence of the specified element within the list of children of its parent node or -1 if this list does not contain the element.
`void`	`clear()` Removes all elements from the tree.
`T`	`closest(T data, Filter<T> filter)` Returns either the element itself or the closest parent element that satisfies the filter condition.
`boolean`	`contains(T data)` Checks if the tree contains a particular element.
`Tree<T>`	`copy()` Returns a copy of this tree.
`Tree<T>`	`copy(Filter<T> filter)` Returns a copy of this tree that results from applying the `filter(Filter)` method after the copy is made.
`Tree<T>`	`filter(Filter<T> filter)` Retains all elements from the tree that are accepted by the `Filter`.
`Tree<T>`	`filter(Filter<T> filter, boolean retainSubTree)` See `filter(de.agentlab.ds.tree.Filter<T>)`
`Tree<T>`	`filterEager(Filter<T> filter)` Retains all elements from the tree that are accepted by the `Filter`.
`T`	`find(Filter<T> filter)` Returns the first element that is accepted by the given `Filter`.
`java.util.List<T>`	`findAll(Filter<T> filter)` Returns a list of elements that are accepted by the given `Filter`.
`java.util.Set<T>`	`getAll()` Returns a set of all elements of the tree.
`java.util.List<java.util.List<T>>`	`getBranches()` Return a list of all branches of the tree.
`java.util.Iterator<java.util.List<T>>`	`getBranchesIterator()`
`java.util.List<T>`	`getBreadthFirstList()` Returns the elements of the tree as list using a breath first traversal.
`java.util.List<T>`	`getChildren(T parent)` Returns the list of children of the given element.
`int`	`getDepth()` Returns the depth of the tree.
`int`	`getDepth(T data)` Returns the depth of the element.
`java.util.List<T>`	`getDescendants(T data)` Returns a list of descendants for a given node
`java.util.List<T>`	`getLeafs()` Returns all leaf elements of the tree.
`java.util.List<T>`	`getLevel(int level)` Returns a list of all nodes on the given level.
`java.util.Set<T>`	`getMatchSet(Filter<T> filter)` Returns the elements of the tree accepted by the given filter as set.
`T`	`getParent(T data)` Returns the parent element for the given element.
`java.util.List<T>`	`getPath(T data)` Returns the path (including the element itself) to the given element as list.
`Tree<T>`	`getPathTree(T data)` Returns the path (including the element itself) to the given element as (degenerated) tree.
`java.util.List<T>`	`getPreorderList()` Returns the elements of the tree as pre-ordered list.
`java.util.List<T>`	`getPreorderList(Filter<T> filter)` Returns the elements of the tree accepted by the given filter as pre-ordered list.
`java.util.List<T>`	`getPreorderList(T data)` Returns the elements of the subtree rooted at the given element as pre-ordered list.
`java.util.List<T>`	`getRoots()` Returns all root elements of the tree.
`java.util.List<T>`	`getSiblings(T data)` Returns the list of siblings of the given element.
`java.util.List<T>`	`getSiblings(T data, boolean includeSelf)` Returns the list of siblings of the given element.
`Tree<T>`	`getSubtree(T data)` Returns the subtree underneath the given element.
`long`	`getVersion()` A tree instance carries a version information which can be used to track changes of the tree.
`boolean`	`hasChildren(T parent)` Tests if the given element has children.
`int`	`indexOf(T data)` Returns the index of the first occurrence of the specified element in this tree or -1 if this list does not contain the element.
`boolean`	`isAncestor(T data, T data2)` Checks, if an element is an ancestor of another element.
`boolean`	`isChild(T data, T data2)` Checks if an element is a child element of another element.
`boolean`	`isDescendant(T data, T data2)` Checks if an element is a descendant of another element.
`boolean`	`isFirstChild(T data)` Checks if a given element is the first child of its parent node.
`boolean`	`isLastChild(T data)` Checks if a given element is the last child of its parent node.
`boolean`	`isLeaf(T data)`
`boolean`	`isRoot(T data)`
`T`	`leastCommonSubsumer(T data1, T data2)` Returns the least common subsumer for the given elements.
`void`	`limit(int count)` Removes all but the first `count` elements of the tree
`<S> Tree<S>`	`map(Mapper<T,S> mapper)` Maps this tree of generic type `T` to a homomorphous tree of type `S` using the given `Mapper`.
`<S> Tree<S>`	`map(T data, Mapper<T,S> mapper)` Maps the subtree from a given element of generic type `T` to a homomorphous tree of type `S` using the given `Mapper`.
`void`	`move(T data, T newParent)` Moves the element to a new parent, removing it from its current parent.
`void`	`prune(T data)` Prunes the tree to the given element.
`Tree<T>`	`pruneCopy(T data)` Copies the tree and prunes it to the given element.
`boolean`	`pull(T data)` Pulls the given element from the tree, i.e. the node is removed from the tree and all children of the node (if any) are moved to the parent of the element.
`T`	`push(T data)` Adds the given element to the tree.
`boolean`	`remove(Filter<T> f)` Removes all elements that are accepted by the given filter.
`boolean`	`remove(T data)` Removes the given element from the tree.
`void`	`replace(T data, T replacement)` Replaces the given element with another element.
`Tree<ItemWrapper<T>>`	`reverse()`
`void`	`shrink(Filter<T> filter)` Retains all elements from the tree that are accepted by the `Filter`.
`void`	`shrinkSubtree(T data, Filter<T> filter)` Retains all elements from the given subtree that are accepted by the `Filter`.
`int`	`size()` Returns the size of the tree (i.e. the number of elements in the tree).
`void`	`sort(java.util.Comparator<T> comparator)` Sorts the tree with the given `Comparator`.
`Tree<T>`	`stabilize(Filter<T> filter)` Applies the specified filter repeatedly to the tree until no more elements are removed by the filter.
`java.util.stream.Stream<T>`	`stream()` Returns an unordered stream of the elements of the tree.
`java.lang.String`	`toString()`
`java.lang.String`	`toString(ElementFormatter<T> formatter)`
`void`	`visit(PrePostVisitor<T> visitor)` Visits the elements of the tree in pre-order, starting at the root nodes.
`boolean`	`visit(T data, Visitor<T> visitor)` Visits the elements of a subtree in pre-order.
`void`	`visit(Visitor<T> visitor)` Visits the elements of the tree in pre-order, starting at the root nodes.
`void`	`visitDescendants(T data, Visitor<T> visitor)` Visits the descendants of an element in pre-order.
`void`	`visitSiblings(T data, Visitor<T> visitor)` Visits the siblings of an element in pre-order.

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

- Field Detail
  - serialVersionUID
```
public static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Tree
```
public Tree()
```
- Method Detail
  - asTree
```
public static <T> Tree<T> asTree(T... l)
```
    Helper method to build a tree from the given list of elements. The elements are added as root elements of the tree.
    
    Type Parameters:
    
    T - the target type for the new tree
    
    Parameters:
    
    l - the list of elements
    
    Returns:
    
    a tree with all elements in the list
  - asDegeneratedTree
```
public static <T> Tree<T> asDegeneratedTree(T... l)
```
    Helper method to build a degenerated tree (i.e. a tree with only a single path) from the given list of elements. The first element becomes the root node, all subsequent elements are added below their respective predecessors.
    
    Type Parameters:
    
    T - the target type for the new tree
    
    Parameters:
    
    l - the list of elements
    
    Returns:
    
    a tree with all elements in the list
  - add
```
public T add(T data)
```
    Adds the given element to the tree. The element is added as the last root node.
    
    Parameters:
    
    data - the element to add
    
    Returns:
    
    the added element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element has already been added to the tree
  - addChild
```
public T addChild(T parent,
                  T data)
```
    Adds the a new element as child of the parent element. The new element is appended to the current list of children of the parent node.
    
    Parameters:
    
    parent - the parent element
    
    data - the element to add
    
    Returns:
    
    the newly added element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element has already been added to the tree
    
    java.lang.IllegalArgumentException - if the parent element is not found in the tree
  - push
```
public T push(T data)
```
    Adds the given element to the tree. The element is added as the first root node.
    
    Parameters:
    
    data - the element to add
    
    Returns:
    
    the added element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element has already been added to the tree
  - addParent
```
public T addParent(T data,
                   T newParent)
```
    Adds an element as parent of the given element. The new parent element is inserted between the data element and its current parent element. If the data element is a root node, the new parent is added as root node.
    
    Parameters:
    
    data - the data element
    
    newParent - the new parent
    
    Returns:
    
    the newly added element
  - addSubtree
```
public void addSubtree(Tree<T> subtree)
```
    Adds the given tree as subtree starting at the root.
    
    Parameters:
    
    subtree - the subtree to add
  - addSubtree
```
public void addSubtree(T parent,
                       Tree<T> subtree)
```
    Adds the given tree as subtree starting at the given parent node.
    
    Parameters:
    
    parent - the parent node to add the subtree to
    
    subtree - the subtree to add
  - addChildAt
```
public T addChildAt(T parent,
                    int index,
                    T data)
```
    Adds the given element to the parent at the specified position.
    
    Parameters:
    
    parent - the sibling element
    
    index - the insert position
    
    data - the element to add
    
    Returns:
    
    the newly added element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element has already been added to the tree
    
    java.lang.IllegalArgumentException - if the parent element is not found in the tree
    
    java.lang.IndexOutOfBoundsException - if the position is not valid
  - addChildBefore
```
public T addChildBefore(T sibling,
                        T data)
```
    Adds the given element to the parent of the sibling before the sibling.
    
    Parameters:
    
    sibling - the sibling element
    
    data - the element to add
    
    Returns:
    
    the newly added element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element has already been added to the tree
    
    java.lang.IllegalArgumentException - if the sibling element is not found in the tree
  - addChildAfter
```
public T addChildAfter(T sibling,
                       T data)
```
    Adds the given element to the parent of the sibling after the sibling.
    
    Parameters:
    
    sibling - the sibling element
    
    data - the element to add
    
    Returns:
    
    the newly added element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element has already been added to the tree
    
    java.lang.IllegalArgumentException - if the sibling element is not found in the tree
  - move
```
public void move(T data,
                 T newParent)
```
    Moves the element to a new parent, removing it from its current parent. If the new parent is null, the element is moved to the root node.
    
    Parameters:
    
    data - the element to move
    
    newParent - the new parent for the element or null for the root node
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
    
    java.lang.IllegalArgumentException - if the parent is not found in the tree
  - remove
```
public boolean remove(T data)
```
    Removes the given element from the tree. The children of the element (if any) are recursively removed from the tree as well.
    
    Parameters:
    
    data - the element to remove
    
    Returns:
    
    true if the element was been removed, false if the tree did not contain the element
  - replace
```
public void replace(T data,
                    T replacement)
```
    Replaces the given element with another element. The structural integrity of the tree is preserved.
    
    Parameters:
    
    data - the element to replace
    
    replacement - the replacement
  - prune
```
public void prune(T data)
```
    Prunes the tree to the given element. After applying this operation, the tree contains only the element itself along with its ancestors and descendants.
    
    Parameters:
    
    data - the element to prune to
  - pruneCopy
```
public Tree<T> pruneCopy(T data)
```
    Copies the tree and prunes it to the given element. After applying this operation, the result contains only the element itself along with its ancestors and descendants.
    
    Parameters:
    
    data - the element to prune to
    
    Returns:
    
    the pruned tree
  - clear
```
public void clear()
```
    Removes all elements from the tree.
  - pull
```
public boolean pull(T data)
```
    Pulls the given element from the tree, i.e. the node is removed from the tree and all children of the node (if any) are moved to the parent of the element.
    
    Parameters:
    
    data - the element to pull
    
    Returns:
    
    true if the element was been pulled, false if the tree does not contain the element
  - remove
```
public boolean remove(Filter<T> f)
```
    Removes all elements that are accepted by the given filter. The elements that are accepted are removed using the remove(T) method.
    
    Parameters:
    
    f - the Filter to apply
    
    Returns:
    
    true if at least one element has been removed, false otherwise
  - getAll
```
public java.util.Set<T> getAll()
```
    Returns a set of all elements of the tree.
    
    Returns:
    
    the set of tree elements
  - getLeafs
```
public java.util.List<T> getLeafs()
```
    Returns all leaf elements of the tree. A leaf is an element that has no children.
    
    Returns:
    
    the leaf elements
  - getDescendants
```
public java.util.List<T> getDescendants(T data)
```
    Returns a list of descendants for a given node
    
    Parameters:
    
    data - the subtree root
    
    Returns:
    
    the list of descendants
  - hasChildren
```
public boolean hasChildren(T parent)
```
    Tests if the given element has children.
    
    Parameters:
    
    parent - the element to test
    
    Returns:
    
    true if the given node has children, false otherwise
  - getSiblings
```
public java.util.List<T> getSiblings(T data)
```
    Returns the list of siblings of the given element.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    the siblings of the element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - getSiblings
```
public java.util.List<T> getSiblings(T data,
                                     boolean includeSelf)
```
    Returns the list of siblings of the given element. Optionally includes the element itself.
    
    Parameters:
    
    data - the element
    
    includeSelf - include the element itself in the collection of siblings
    
    Returns:
    
    the siblings of the element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - getSubtree
```
public Tree<T> getSubtree(T data)
```
    Returns the subtree underneath the given element.
    
    Parameters:
    
    data - the root of the subtree
    
    Returns:
    
    the subtree
  - isFirstChild
```
public boolean isFirstChild(T data)
```
    Checks if a given element is the first child of its parent node.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    true if the element is the first child of its parent, false otherwise
  - getParent
```
public T getParent(T data)
```
    Returns the parent element for the given element.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    the parent element or null if the parent element is a root element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - getRoots
```
public java.util.List<T> getRoots()
```
    Returns all root elements of the tree.
    
    Returns:
    
    the root elements
  - getChildren
```
public java.util.List<T> getChildren(T parent)
```
    Returns the list of children of the given element.
    
    Parameters:
    
    parent - the parent element
    
    Returns:
    
    the list of children
    
    Throws:
    
    java.lang.IllegalArgumentException - if the parent element is not found in the tree
  - isLastChild
```
public boolean isLastChild(T data)
```
    Checks if a given element is the last child of its parent node.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    true if the element is the last child of its parent, false otherwise
  - getDepth
```
public int getDepth(T data)
```
    Returns the depth of the element. The depth of an element is defined as the distance to a root node. Thus, a root node has depth of 0, children of root nodes have a depth of 1 and so forth.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    the depth of the element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - getDepth
```
public int getDepth()
```
    Returns the depth of the tree. The tree depth is defined as the maximum of all element depths.
    
    Returns:
    
    the depth of the tree
  - getPathTree
```
public Tree<T> getPathTree(T data)
```
    Returns the path (including the element itself) to the given element as (degenerated) tree. The result tree is degenerated such that each element (except for the last) has exactly one child element.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    a tree of elements that represents the path to the element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - getPath
```
public java.util.List<T> getPath(T data)
```
    Returns the path (including the element itself) to the given element as list.
    
    Parameters:
    
    data - the element
    
    Returns:
    
    a list of elements that represents the path to the element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - visit
```
public void visit(Visitor<T> visitor)
```
    Visits the elements of the tree in pre-order, starting at the root nodes.
    
    Parameters:
    
    visitor - the Visitor to apply
  - visit
```
public void visit(PrePostVisitor<T> visitor)
```
    Visits the elements of the tree in pre-order, starting at the root nodes.
    
    Parameters:
    
    visitor - the Visitor to apply
  - visit
```
public boolean visit(T data,
                     Visitor<T> visitor)
```
    Visits the elements of a subtree in pre-order.
    
    Parameters:
    
    data - the root of the subtree to visit
    
    visitor - the Visitor to apply
    
    Returns:
    
    true if all elements have been visited, false otherwise (i.e. the Visitor.visit(Object) method returned false for some object)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - visitDescendants
```
public void visitDescendants(T data,
                             Visitor<T> visitor)
```
    Visits the descendants of an element in pre-order. The element itself is not processed by the Visitor.
    
    Parameters:
    
    data - the root of the subtree to visit
    
    visitor - the Visitor to apply
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - visitSiblings
```
public void visitSiblings(T data,
                          Visitor<T> visitor)
```
    Visits the siblings of an element in pre-order. The element itself is not processed by the Visitor.
    
    Parameters:
    
    data - the element which siblings to visit
    
    visitor - the Visitor to apply
  - contains
```
public boolean contains(T data)
```
    Checks if the tree contains a particular element.
    
    Parameters:
    
    data - the element to check on
    
    Returns:
    
    true if the tree contains the given element, false otherwise
  - isChild
```
public boolean isChild(T data,
                       T data2)
```
    Checks if an element is a child element of another element.
    
    Parameters:
    
    data - the element to test
    
    data2 - the parent to check against
    
    Returns:
    
    true if the element is a child element, false otherwise
  - isDescendant
```
public boolean isDescendant(T data,
                            T data2)
```
    Checks if an element is a descendant of another element.
    
    Parameters:
    
    data - the element to test
    
    data2 - the predecessor to check against
    
    Returns:
    
    true if the element is a descendant, false otherwise
  - isAncestor
```
public boolean isAncestor(T data,
                          T data2)
```
    Checks, if an element is an ancestor of another element.
    
    Parameters:
    
    data - the ancestor to check against
    
    data2 - the item to check
    
    Returns:
    
    true if the element is an ancestor, false otherwise
  - size
```
public int size()
```
    Returns the size of the tree (i.e. the number of elements in the tree).
    
    Returns:
    
    the size of the tree
  - stream
```
public java.util.stream.Stream<T> stream()
```
    Returns an unordered stream of the elements of the tree.
    
    Returns:
    
    an unordered stream of the elements of the tree
  - asList
```
public java.util.List<T> asList()
```
    Returns the elements of the tree as pre-ordered list.
    
    Returns:
    
    the element list in pre-order
  - getPreorderList
```
public java.util.List<T> getPreorderList()
```
    Returns the elements of the tree as pre-ordered list.
    
    Returns:
    
    the element list in pre-order
  - getPreorderList
```
public java.util.List<T> getPreorderList(Filter<T> filter)
```
    Returns the elements of the tree accepted by the given filter as pre-ordered list.
    
    Parameters:
    
    filter - the Filter to use
    
    Returns:
    
    the elements of the tree accepted by the given filter as pre-ordered list
  - getPreorderList
```
public java.util.List<T> getPreorderList(T data)
```
    Returns the elements of the subtree rooted at the given element as pre-ordered list.
    
    Parameters:
    
    data - the subtree root
    
    Returns:
    
    the element list in pre-order
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - getMatchSet
```
public java.util.Set<T> getMatchSet(Filter<T> filter)
```
    Returns the elements of the tree accepted by the given filter as set.
    
    Parameters:
    
    filter - the Filter to use
    
    Returns:
    
    the elements of the tree accepted by the given filter as set
  - getBreadthFirstList
```
public java.util.List<T> getBreadthFirstList()
```
    Returns the elements of the tree as list using a breath first traversal.
    
    Returns:
    
    the element list
  - getBranches
```
public java.util.List<java.util.List<T>> getBranches()
```
    Return a list of all branches of the tree. A branch is a list of of elements from a root to a leaf.
    
    Returns:
    
    a list of all branches
  - getBranchesIterator
```
public java.util.Iterator<java.util.List<T>> getBranchesIterator()
```
    Returns:
    
    an iterator for all branches of the tree
  - getLevel
```
public java.util.List<T> getLevel(int level)
```
    Returns a list of all nodes on the given level.
    
    Parameters:
    
    level - the target level for the result elements
    
    Returns:
    
    a list of all nodes on the given level
  - sort
```
public void sort(java.util.Comparator<T> comparator)
```
    Sorts the tree with the given Comparator. Sorting the tree is defined as sorting the children of each element according to the comparator.
    
    Parameters:
    
    comparator - the Comparator used to sort the children
  - filter
```
public Tree<T> filter(Filter<T> filter)
```
    Retains all elements from the tree that are accepted by the Filter. If an element is retained, all elements on the path to a root element are retained as well. The elements that are rejected are removed using the remove(T) method.
    
    Parameters:
    
    filter - the Filter to use
    
    Returns:
    
    the filtered tree
  - filter
```
public Tree<T> filter(Filter<T> filter,
                      boolean retainSubTree)
```
    See filter(de.agentlab.ds.tree.Filter<T>)
    
    Parameters:
    
    filter - the Filter to use
    
    retainSubTree - retain also the Sub-Tree of a matching element.
    
    Returns:
    
    the filtered tree
  - filterEager
```
public Tree<T> filterEager(Filter<T> filter)
```
    Retains all elements from the tree that are accepted by the Filter. If an element is rejected, all children are rejected as well. The elements that are rejected are removed using the remove(T) method.
    
    Parameters:
    
    filter - the Filter to use
    
    Returns:
    
    the tree
  - stabilize
```
public Tree<T> stabilize(Filter<T> filter)
```
    Applies the specified filter repeatedly to the tree until no more elements are removed by the filter.
    
    Parameters:
    
    filter - the filter to apply
    
    Returns:
    
    the tree
  - shrink
```
public void shrink(Filter<T> filter)
```
    Retains all elements from the tree that are accepted by the Filter. The elements that are rejected are removed using the pull(T) method.
    
    Parameters:
    
    filter - the Filter to use
  - shrinkSubtree
```
public void shrinkSubtree(T data,
                          Filter<T> filter)
```
    Retains all elements from the given subtree that are accepted by the Filter. The elements that are rejected are removed using the pull(T) method.
    
    Parameters:
    
    data - the subtree root
    
    filter - the Filter to use
  - limit
```
public void limit(int count)
```
    Removes all but the first count elements of the tree
    
    Parameters:
    
    count - the number of elements (in pre-order) to keep
  - copy
```
public Tree<T> copy(Filter<T> filter)
```
    Returns a copy of this tree that results from applying the filter(Filter) method after the copy is made.
    
    Parameters:
    
    filter - the Filter to use
    
    Returns:
    
    the tree copy
  - map
```
public <S> Tree<S> map(Mapper<T,S> mapper)
```
    Maps this tree of generic type T to a homomorphous tree of type S using the given Mapper.
    
    Type Parameters:
    
    S - the target type
    
    Parameters:
    
    mapper - the Mapper to use
    
    Returns:
    
    a homomorphous tree of type S
  - map
```
public <S> Tree<S> map(T data,
                       Mapper<T,S> mapper)
```
    Maps the subtree from a given element of generic type T to a homomorphous tree of type S using the given Mapper.
    
    Type Parameters:
    
    S - the target type
    
    Parameters:
    
    data - the subtree root
    
    mapper - the Mapper to use
    
    Returns:
    
    a homomorphous tree of type S
    
    Throws:
    
    java.lang.IllegalArgumentException - if the element is not found in the tree
  - find
```
public T find(Filter<T> filter)
```
    Returns the first element that is accepted by the given Filter.
    
    Parameters:
    
    filter - the Filter to apply
    
    Returns:
    
    the first element that is accepted by the Filter, null if no element is accepted
  - findAll
```
public java.util.List<T> findAll(Filter<T> filter)
```
    Returns a list of elements that are accepted by the given Filter.
    
    Parameters:
    
    filter - the Filter to apply
    
    Returns:
    
    the list of elements that is accepted by the Filter or an empty list if none is accepted
  - closest
```
public T closest(T data,
                 Filter<T> filter)
```
    Returns either the element itself or the closest parent element that satisfies the filter condition.
    
    Parameters:
    
    data - the elem to start from
    
    filter - the Filter to apply
    
    Returns:
    
    the element closest to the element that satisfies the filter condition. This can be the element itself.
  - leastCommonSubsumer
```
public T leastCommonSubsumer(T data1,
                             T data2)
```
    Returns the least common subsumer for the given elements. The least common subsumer is defined as the closest common ancestor to both arguments.
    
    Parameters:
    
    data1 - the first data element
    
    data2 - the second data element
    
    Returns:
    
    the least common subsuber for the given arguments
  - indexOf
```
public int indexOf(T data)
```
    Returns the index of the first occurrence of the specified element in this tree or -1 if this list does not contain the element.
    
    Parameters:
    
    data - the element to look for
    
    Returns:
    
    the index of the first occurrence of the specified element in this tree or -1 if this list does not contain the element
  - childIndexOf
```
public int childIndexOf(T data)
```
    Returns the index of the first occurrence of the specified element within the list of children of its parent node or -1 if this list does not contain the element.
    
    Parameters:
    
    data - the element to look for
    
    Returns:
    
    the index of the first occurrence of the specified element in the list of children of its parent node or -1 if this list does not contain the element
  - copy
```
public Tree<T> copy()
```
    Returns a copy of this tree.
    
    Returns:
    
    a copy of the tree
  - reverse
```
public Tree<ItemWrapper<T>> reverse()
```
  - isRoot
```
public boolean isRoot(T data)
```
    Parameters:
    
    data - the element to check
    
    Returns:
    
    true if the item is a root node, false otherwise
  - isLeaf
```
public boolean isLeaf(T data)
```
    Parameters:
    
    data - the element to check
    
    Returns:
    
    true if the item is a leaf node, false otherwise
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
public java.lang.String toString(ElementFormatter<T> formatter)
```
  - getVersion
```
public long getVersion()
```
    A tree instance carries a version information which can be used to track changes of the tree. Each method that adds or removes at least one element increases the version number by one.
    
    Returns:
    
    the version of the tree

Class Tree<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

serialVersionUID

Constructor Detail

Tree

Method Detail

asTree

asDegeneratedTree

add

addChild

push

addParent

addSubtree

addSubtree

addChildAt

addChildBefore

addChildAfter

move

remove

replace

prune

pruneCopy

clear

pull

remove

getAll

getLeafs

getDescendants

hasChildren

getSiblings

getSiblings

getSubtree

isFirstChild

getParent

getRoots

getChildren

isLastChild

getDepth

getDepth

getPathTree

getPath

visit

visit

visit

visitDescendants

visitSiblings

contains

isChild

isDescendant

isAncestor

size

stream

asList

getPreorderList

getPreorderList

getPreorderList

getMatchSet

getBreadthFirstList

getBranches

getBranchesIterator

getLevel

sort

filter

filter

filterEager

stabilize

shrink

shrinkSubtree

limit

copy

map

map

find

findAll

closest

leastCommonSubsumer