Package org.apache.jorphan.collections

# Class SearchByClass<T>

java.lang.Object
org.apache.jorphan.collections.SearchByClass<T>

Type Parameters:
  `T` - Class that should be searched for

All Implemented Interfaces:
  `HashTreeTraverser`

public class SearchByClass<T> extends Object implements HashTreeTraverser
Useful for finding all nodes in the tree that represent objects of a particular type. For instance, if your tree contains all strings, and a few StringBuilder objects, you can use the SearchByClass traverser to find all the StringBuilder objects in your tree.

Usage is simple. Given a `HashTree` object "tree", and a SearchByClass object:

     HashTree tree = new HashTree();
     // ... tree gets filled with objects
     SearchByClass searcher = new SearchByClass(StringBuilder.class);
     tree.traverse(searcher);
     Iterator iter = searcher.getSearchResults().iterator();
     while (iter.hasNext()) {
         StringBuilder foundNode = (StringBuilder) iter.next();
         HashTree subTreeOfFoundNode = searcher.getSubTree(foundNode);
         // .... do something with node and subTree...
     }

See Also:
  - `HashTree`
  - `HashTreeTraverser`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `SearchByClass(Class<T> searchClass)`
  Creates an instance of SearchByClass, and sets the Class to be searched for.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addNode(Object node, HashTree subTree)`
  The tree traverses itself depth-first, calling addNode for each object it encounters as it goes.
  `Collection<T>`
  `getSearchResults()`
  After traversing the HashTree, call this method to get a collection of the nodes that were found.
  `HashTree`
  `getSubTree(Object root)`
  Given a specific found node, this method will return the sub tree of that node.
  `void`
  `processPath()`
  Process path is called when a leaf is reached.
  `void`
  `subtractNode()`
  Indicates traversal has moved up a step, and the visitor should remove the top node from its stack structure.

  ### Methods inherited from class java.lang.Object

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

- ## Constructor Details

  - ### SearchByClass

    public SearchByClass(Class<T> searchClass)
    Creates an instance of SearchByClass, and sets the Class to be searched for.
    Parameters:
      `searchClass` - class to be searched for

- ## Method Details

  - ### getSearchResults

    public Collection<T> getSearchResults()
    After traversing the HashTree, call this method to get a collection of the nodes that were found.
    Returns:
      Collection All found nodes of the requested type

  - ### getSubTree

    public HashTree getSubTree(Object root)
    Given a specific found node, this method will return the sub tree of that node.
    Parameters:
      `root` - the node for which the sub tree is requested
    Returns:
      HashTree

  - ### addNode

    public void addNode(Object node, HashTree subTree)
    The tree traverses itself depth-first, calling addNode for each object it encounters as it goes. This is a callback method, and should not be called except by a HashTree during traversal.
    Specified by:
      `addNode` in interface `HashTreeTraverser`
    Parameters:
      `node` - the node currently encountered
      `subTree` - the HashTree under the node encountered

  - ### subtractNode

    public void subtractNode()
    Indicates traversal has moved up a step, and the visitor should remove the top node from its stack structure. This is a callback method, and should not be called except by a HashTree during traversal.
    Specified by:
      `subtractNode` in interface `HashTreeTraverser`

  - ### processPath

    public void processPath()
    Process path is called when a leaf is reached. If a visitor wishes to generate Lists of path elements to each leaf, it should keep a Stack data structure of nodes passed to it with addNode, and removing top items for every `HashTreeTraverser.subtractNode()` call. This is a callback method, and should not be called except by a HashTree during traversal.
    Specified by:
      `processPath` in interface `HashTreeTraverser`