public HashTree() 
{
        data = new HashMap();
}

Creates an empty new HashTree.

 protected HashTree(Map _map) 
{
        data = _map;
}

Allow subclasses to provide their own Map.

 public HashTree(Object key) 
{
        data = new HashMap();
        data.put(key, new HashTree());
}

Creates a new HashTree and adds the given object as a top-level node.

Parameters:

key -

 public HashTree(Collection keys) 
{
        data = new HashMap();
        Iterator it = keys.iterator();
        while (it.hasNext()) {
            data.put(it.next(), new HashTree());
        }
}

Creates a new HashTree and adds all the objects in the given collection as top-level nodes in the tree.

Parameters:

keys - a collection of objects to be added to the created HashTree.

 public HashTree(Object[] keys) 
{
        data = new HashMap();
        for (int x = 0; x <  keys.length; x++) {
            data.put(keys[x], new HashTree());
        }
}

Creates a new HashTree and adds all the objects in the given array as top-level nodes in the tree.

 public  void add(HashTree newTree) 
{
        Iterator iter = newTree.list().iterator();
        while (iter.hasNext()) {
            Object item = iter.next();
            add(item);
            getTree(item).add(newTree.getTree(item));
        }
}

Adds all the nodes and branches of the given tree to this tree. Is like merging two trees. Duplicates are ignored.

 public HashTree add(Object key) 
{
        if (!data.containsKey(key)) {
            HashTree newTree = createNewTree();
            data.put(key, newTree);
            return newTree;
        }
        return getTree(key);
}

Adds an key into the HashTree at the current level.

 public  void add(Object[] keys) 
{
        for (int x = 0; x <  keys.length; x++) {
            add(keys[x]);
        }
}

Adds all the given objects as nodes at the current level.

 public  void add(Collection keys) 
{
        Iterator it = keys.iterator();
        while (it.hasNext()) {
            add(it.next());
        }
}

Adds a bunch of keys into the HashTree at the current level.

 public  void add(Object key,
    HashTree subTree) 
{
        add(key);
        getTree(key).add(subTree);
}

Adds a key as a node at the current level and then adds the given HashTree to that new node.

 public HashTree add(Object key,
    Object value) 
{
        add(key);
        return getTree(key).add(value);
}

Adds a key and it's value in the HashTree. The first argument becomes a node at the current level, and the second argument becomes a node of it.

 public  void add(Object key,
    Object[] values) 
{
        add(key);
        getTree(key).add(values);
}

Adds a key and it's values in the HashTree. The first argument becomes a node at the current level, and adds all the values in the array to the new node.

 public  void add(Object key,
    Collection values) 
{
        add(key);
        getTree(key).add(values);
}

Adds a key as a node at the current level and then adds all the objects in the second argument as nodes of the new node.

 public  void add(Object[] treePath,
    Object[] values) 
{
        if (treePath != null) {
            add(Arrays.asList(treePath), Arrays.asList(values));
        }
}

Adds a series of nodes into the HashTree using the given path. The first argument is an array that represents a path to a specific node in the tree. If the path doesn't already exist, it is created (the objects are added along the way). At the path, all the objects in the second argument are added as nodes.

 public  void add(Object[] treePath,
    Collection values) 
{
        if (treePath != null) {
            add(Arrays.asList(treePath), values);
        }
}

Adds a series of nodes into the HashTree using the given path. The first argument is an array that represents a path to a specific node in the tree. If the path doesn't already exist, it is created (the objects are added along the way). At the path, all the objects in the second argument are added as nodes.

 public HashTree add(Object[] treePath,
    Object value) 
{
        return add(Arrays.asList(treePath), value);
}

 public  void add(Collection treePath,
    Object[] values) 
{
        HashTree tree = addTreePath(treePath);
        tree.add(Arrays.asList(values));
}

Adds a series of nodes into the HashTree using the given path. The first argument is a List that represents a path to a specific node in the tree. If the path doesn't already exist, it is created (the objects are added along the way). At the path, all the objects in the second argument are added as nodes.

 public HashTree add(Collection treePath,
    Object value) 
{
        HashTree tree = addTreePath(treePath);
        return tree.add(value);
}

Adds a series of nodes into the HashTree using the given path. The first argument is a List that represents a path to a specific node in the tree. If the path doesn't already exist, it is created (the objects are added along the way). At the path, the object in the second argument is added as a node.

 public  void add(Collection treePath,
    Collection values) 
{
        HashTree tree = addTreePath(treePath);
        tree.add(values);
}

Adds a series of nodes into the HashTree using the given path. The first argument is a SortedSet that represents a path to a specific node in the tree. If the path doesn't already exist, it is created (the objects are added along the way). At the path, all the objects in the second argument are added as nodes.

 protected HashTree addTreePath(Collection treePath) 
{
        HashTree tree = this;
        Iterator iter = treePath.iterator();
        while (iter.hasNext()) {
            Object temp = iter.next();
            tree.add(temp);
            tree = tree.getTree(temp);
        }
        return tree;
}

 public  void clear() 
{
        data.clear();
}

Clears the HashTree of all contents.

 public Object clone() 
{
        HashTree newTree = new HashTree();
        cloneTree(newTree);
        return newTree;
}

Create a clone of this HashTree. This is not a deep clone (ie, the contents of the tree are not cloned).

 protected  void cloneTree(HashTree newTree) 
{
        Iterator iter = list().iterator();
        while (iter.hasNext()) {
            Object key = iter.next();
            newTree.set(key, (HashTree) getTree(key).clone());
        }
}

 public boolean containsKey(Object o) 
{
        return data.containsKey(o);
}

If the HashTree contains the given object as a key at the top level, then a true result is returned, otherwise false.

 public boolean containsValue(Object value) 
{
        return data.containsValue(value);
}

Implemented as required by the Map interface, but is not very useful here. All 'values' in a HashTree are HashTree's themselves.

 protected HashTree createNewTree() 
{
        return new HashTree();
}

Creates a new tree. This method exists to allow inheriting classes to generate the appropriate types of nodes. For instance, when a node is added, it's value is a HashTree. Rather than directly calling the HashTree() constructor, the createNewTree() method is called. Inheriting classes should override these methods and create the appropriate subclass of HashTree.

 protected HashTree createNewTree(Object key) 
{
        return new HashTree(key);
}

Creates a new tree. This method exists to allow inheriting classes to generate the appropriate types of nodes. For instance, when a node is added, it's value is a HashTree. Rather than directly calling the HashTree() constructor, the createNewTree() method is called. Inheriting classes should override these methods and create the appropriate subclass of HashTree.

 protected HashTree createNewTree(Collection values) 
{
        return new HashTree(values);
}

Creates a new tree. This method exists to allow inheriting classes to generate the appropriate types of nodes. For instance, when a node is added, it's value is a HashTree. Rather than directly calling the HashTree() constructor, the createNewTree() method is called. Inheriting classes should override these methods and create the appropriate subclass of HashTree.

 public Set entrySet() 
{
        return data.entrySet();
}

Exists to satisfy the Map interface.

 public boolean equals(Object o) 
{
        if (!(o instanceof HashTree)) {
            return false;
        }
        HashTree oo = (HashTree) o;
        if (oo.size() != this.size()) {
            return false;
        }
        return data.equals(oo.data);
        // boolean flag = true;
        // if (o instanceof HashTree)
        // {
        // HashTree oo = (HashTree) o;
        // Iterator it = data.keySet().iterator();
        // while (it.hasNext())
        // {
        // if (!oo.containsKey(it.next()))
        // {
        // flag = false;
        // break;
        // }
        // }
        // if (flag)
        // {
        // it = data.keySet().iterator();
        // while (it.hasNext())
        // {
        // Object temp = it.next();
        // flag = get(temp).equals(oo.get(temp));
        // if (!flag)
        // {
        // break;
        // }
        // }
        // }
        // }
        // else
        // {
        // flag = false;
        // }
        // return flag;
}

Compares all objects in the tree and verifies that the two trees contain the same objects at the same tree levels. Returns true if they do, false otherwise.

 public Object get(Object key) 
{
        return getTree(key);
}

Returns the HashTree object associated with the given key. Same as calling #getTree(Object) .

 public Object[] getArray() 
{
        return data.keySet().toArray();
}

Gets an array of all keys in the current HashTree node. If the HashTree represented a file system, this would be like getting an array of all the files in the current folder.

 public Object[] getArray(Object key) 
{
        HashTree t = getTree(key);
        if (t != null) {
            return t.getArray();
        }
        return null;
}

Gets an array of all keys in the HashTree mapped to the given key of the current HashTree object (in other words, one level down). If the HashTree represented a file system, this would like getting a list of all files in a sub-directory (of the current directory) specified by the key argument.

 public Object[] getArray(Object[] treePath) 
{
        if (treePath != null) {
            return getArray(Arrays.asList(treePath));
        }
        return getArray();
}

Recurses down into the HashTree stucture using each subsequent key in the array of keys, and returns an array of keys of the HashTree object at the end of the recursion. If the HashTree represented a file system, this would be like getting a list of all the files in a directory specified by the treePath, relative from the current directory.

 public Object[] getArray(Collection treePath) 
{
        HashTree tree = getTreePath(treePath);
        return (tree != null) ? tree.getArray() : null;
}

Recurses down into the HashTree stucture using each subsequent key in the treePath argument, and returns an array of keys of the HashTree object at the end of the recursion. If the HashTree represented a file system, this would be like getting a list of all the files in a directory specified by the treePath, relative from the current directory.

 public HashTree getTree(Object key) 
{
        return (HashTree) data.get(key);
}

Gets the HashTree mapped to the given key.

 public HashTree getTree(Object[] treePath) 
{
        if (treePath != null) {
            return getTree(Arrays.asList(treePath));
        }
        return this;
}

Gets the HashTree object mapped to the last key in the array by recursing through the HashTree structure one key at a time.

 public HashTree getTree(Collection treePath) 
{
        return getTreePath(treePath);
}

Gets the HashTree object mapped to the last key in the SortedSet by recursing through the HashTree structure one key at a time.

 protected HashTree getTreePath(Collection treePath) 
{
        HashTree tree = this;
        Iterator iter = treePath.iterator();
        while (iter.hasNext()) {
            if (tree == null) {
                return null;
            }
            Object temp = iter.next();
            tree = tree.getTree(temp);
        }
        return tree;
}

 public int hashCode() 
{
        return data.hashCode() * 7;
}

Returns a hashcode for this HashTree.

 public boolean isEmpty() 
{
        return data.isEmpty();
}

If the HashTree is empty, true is returned, false otherwise.

 public Set keySet() 
{
        return data.keySet();
}

Returns a Set of all the keys in the top-level of this HashTree.

 public Collection list() 
{
        return data.keySet();
}

Gets a Collection of all keys in the current HashTree node. If the HashTree represented a file system, this would be like getting a collection of all the files in the current folder.

 public Collection list(Object key) 
{
        HashTree temp = (HashTree) data.get(key);
        if (temp != null) {
            return temp.list();
        }
        return new LinkedList();
}

Gets a Set of all keys in the HashTree mapped to the given key of the current HashTree object (in other words, one level down. If the HashTree represented a file system, this would like getting a list of all files in a sub-directory (of the current directory) specified by the key argument.

 public Collection list(Object[] treePath) 
{
        if (treePath != null) {
            return list(Arrays.asList(treePath));
        }
        return list();
}

Recurses down into the HashTree stucture using each subsequent key in the array of keys, and returns the Set of keys of the HashTree object at the end of the recursion. If the HashTree represented a file system, this would be like getting a list of all the files in a directory specified by the treePath, relative from the current directory.

 public Collection list(Collection treePath) 
{
        HashTree tree = getTreePath(treePath);
        if (tree != null) {
            return tree.list();
        }
        return new LinkedList();
}

Recurses down into the HashTree stucture using each subsequent key in the List of keys, and returns the Set of keys of the HashTree object at the end of the recursion. If the HashTree represented a file system, this would be like getting a list of all the files in a directory specified by the treePath, relative from the current directory.

 public Object put(Object key,
    Object value) 
{
        Object previous = data.get(key);
        add(key, value);
        return previous;
}

This is the same as calling HashTree.add(key,value).

 public  void putAll(Map map) 
{
        if (map instanceof HashTree) {
            this.add((HashTree) map);
        } else {
            throw new UnsupportedOperationException("can only putAll other HashTree objects");
        }
}

The Map given must also be a HashTree, otherwise an UnsupportedOperationException is thrown. If it is a HashTree, this is like calling the add(HashTree) method.

 public Object remove(Object key) 
{
        return data.remove(key);
}

Removes the entire branch specified by the given key.

 public  void replace(Object currentKey,
    Object newKey) 
{
        HashTree tree = getTree(currentKey);
        data.remove(currentKey);
        data.put(newKey, tree);
}

Finds the given current key, and replaces it with the given new key. Any tree structure found under the original key is moved to the new key.

 public HashTree search(Object key) 
{
// TODO does not appear to be used
        HashTree result = getTree(key);
        if (result != null) {
            return result;
        }
        TreeSearcher searcher = new TreeSearcher(key);
        try {
            traverse(searcher);
        } catch (RuntimeException e) {
            if (!e.getMessage().equals(FOUND)){
                throw e;
            }
            // do nothing - means object is found
        }
        return searcher.getResult();
}

Searches the HashTree structure for the given key. If it finds the key, it returns the HashTree mapped to the key. If it finds nothing, it returns null.

 public  void set(Collection values) 
{
        clear();
        this.add(values);
}

Sets the nodes of the current tree to be the objects of the given collection. Any nodes previously in the tree are removed.

 public  void set(Object key,
    Object value) 
{
        data.put(key, createNewTree(value));
}

Sets a key and it's value in the HashTree. It actually sets up a key, and then creates a node for the key and sets the value to the new node, as a key. Any previous nodes that existed under the given key are lost.

 public  void set(Object key,
    HashTree t) 
{
        data.put(key, t);
}

Sets a key into the current tree and assigns it a HashTree as its subtree. Any previous entries under the given key are removed.

 public  void set(Object key,
    Object[] values) 
{
        data.put(key, createNewTree(Arrays.asList(values)));
}

Sets a key and its values in the HashTree. It sets up a key in the current node, and then creates a node for that key, and sets all the values in the array as keys in the new node. Any keys previously held under the given key are lost.

 public  void set(Object key,
    Collection values) 
{
        data.put(key, createNewTree(values));
}

Sets a key and its values in the HashTree. It sets up a key in the current node, and then creates a node for that key, and set all the values in the array as keys in the new node. Any keys previously held under the given key are removed.

 public  void set(Object[] treePath,
    Object[] values) 
{
        if (treePath != null && values != null) {
            set(Arrays.asList(treePath), Arrays.asList(values));
        }
}

Sets a series of keys into the HashTree. It sets up the first object in the key array as a key in the current node, recurses into the next HashTree node through that key and adds the second object in the array. Continues recursing in this manner until the end of the first array is reached, at which point all the values of the second array are set as keys to the bottom-most node. All previous keys of that bottom-most node are removed.

 public  void set(Object[] treePath,
    Collection values) 
{
        if (treePath != null) {
            set(Arrays.asList(treePath), values);
        }
}

Sets a series of keys into the HashTree. It sets up the first object in the key array as a key in the current node, recurses into the next HashTree node through that key and adds the second object in the array. Continues recursing in this manner until the end of the first array is reached, at which point all the values of the Collection of values are set as keys to the bottom-most node. Any keys previously held by the bottom-most node are lost.

 public  void set(Collection treePath,
    Object[] values) 
{
        HashTree tree = addTreePath(treePath);
        tree.set(Arrays.asList(values));
}

Sets a series of keys into the HashTree. It sets up the first object in the key list as a key in the current node, recurses into the next HashTree node through that key and adds the second object in the list. Continues recursing in this manner until the end of the first list is reached, at which point all the values of the array of values are set as keys to the bottom-most node. Any previously existing keys of that bottom node are removed.

 public  void set(Collection treePath,
    Collection values) 
{
        HashTree tree = addTreePath(treePath);
        tree.set(values);
}

Sets a series of keys into the HashTree. It sets up the first object in the key list as a key in the current node, recurses into the next HashTree node through that key and adds the second object in the list. Continues recursing in this manner until the end of the first list is reached, at which point all the values of the Collection of values are set as keys to the bottom-most node. Any previously existing keys of that bottom node are lost.

 public int size() 
{
        return data.size();
}

Returns the number of top-level entries in the HashTree.

 public String toString() 
{
        ConvertToString converter = new ConvertToString();
        try {
            traverse(converter);
        } catch (Exception e) { // Just in case
            converter.reportError(e);
        }
        return converter.toString();
}

Generate a printable representation of the tree.

 public  void traverse(HashTreeTraverser visitor) 
{
        Iterator iter = list().iterator();
        while (iter.hasNext()) {
            Object item = iter.next();
            visitor.addNode(item, getTree(item));
            getTree(item).traverseInto(visitor);
        }
}

Allows any implementation of the HashTreeTraverser interface to easily traverse (depth-first) all the nodes of the HashTree. The Traverser implementation will be given notification of each node visited.

 public Collection values() 
{
        return data.values();
}

Returns a collection of all the sub-trees of the current tree.