HashTreeTraverser 5.6.3 API

All Implemented Interfaces:
```
public interface HashTreeTraverser

                    
```
By implementing this interface, a class can easily traverse a HashTree object, and be notified via callbacks of certain events. There are three such events:
- When a node is first encountered, the traverser's addNode method is called. It is handed the object at that node, and the entire sub-tree of the node.
- When a leaf node is encountered, the traverser is notified that a full path has been finished via the processPath method. It is the traversing class's responsibility to know the path that has just finished (this can be done by keeping a simple stack of all added nodes).
- When a node is retraced, the traverser's subtractNode is called. Again, it is the traverser's responsibility to know which node has been retraced.
To summarize, as the traversal goes down a tree path, nodes are added. When the end of the path is reached, the processPath call is sent. As the traversal backs up, nodes are subtracted.
The traversal is a depth-first traversal.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description

Constructor Summary

Constructors
Constructor	Description

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`abstract void`	`addNode(Object node, HashTree subTree)`	The tree traverses itself depth-first, calling addNode for each object it encounters as it goes.
`abstract void`	`subtractNode()`	Indicates traversal has moved up a step, and the visitor should remove the top node from its stack structure.
`abstract void`	`processPath()`	Process path is called when a leaf is reached.

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

- Constructor Detail
- Method Detail
  - addNode
```
 abstract 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.
    
    Parameters:
    
    node - the node currently encountered
    
    subTree - the HashTree under the node encountered
  - subtractNode
```
 abstract 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.
  - processPath
```
 abstract 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 subtractNode call. This is a callback method, and should not be called except by a HashTree during traversal.