Package org.apache.jorphan.collections
Class HashTree
- java.lang.Object
-
- org.apache.jorphan.collections.HashTree
-
- All Implemented Interfaces:
Serializable
,Cloneable
,Map<Object,HashTree>
- Direct Known Subclasses:
ListedHashTree
,SortedHashTree
public class HashTree extends Object implements Serializable, Map<Object,HashTree>, Cloneable
This class is used to create a tree structure of objects. Each element in the tree is also a key to the next node down in the tree. It provides many ways to add objects and branches, as well as many ways to retrieve.HashTree implements the Map interface for convenience reasons. The main difference between a Map and a HashTree is that the HashTree organizes the data into a recursive tree structure, and provides the means to manipulate that structure.
Of special interest is the
traverse(HashTreeTraverser)
method, which provides an expedient way to traverse any HashTree by implementing theHashTreeTraverser
interface in order to perform some operation on the tree, or to extract information from the tree.- See Also:
HashTreeTraverser
,SearchByClass
, Serialized Form
-
-
Constructor Summary
Constructors Modifier Constructor Description HashTree()
Creates an empty new HashTree.HashTree(Object key)
Creates a new HashTree and adds the given object as a top-level node.HashTree(Object[] keys)
Creates a new HashTree and adds all the objects in the given array as top-level nodes in the tree.HashTree(Collection<?> keys)
Creates a new HashTree and adds all the objects in the given collection as top-level nodes in the tree.protected
HashTree(Map<Object,HashTree> _map)
Allow subclasses to provide their own Map.
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description HashTree
add(Object key)
Adds an key into the HashTree at the current level.void
add(Object[] keys)
Adds all the given objects as nodes at the current level.HashTree
add(Object[] treePath, Object value)
void
add(Object[] treePath, Object[] values)
Adds a series of nodes into the HashTree using the given path.void
add(Object[] treePath, Collection<?> values)
Adds a series of nodes into the HashTree using the given path.HashTree
add(Object key, Object value)
Adds a key and it's value in the HashTree.void
add(Object key, Object[] values)
Adds a key and it's values in the HashTree.void
add(Object key, Collection<?> 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.void
add(Object key, HashTree subTree)
Adds a key as a node at the current level and then adds the given HashTree to that new node.void
add(Collection<?> keys)
Adds a bunch of keys into the HashTree at the current level.HashTree
add(Collection<?> treePath, Object value)
Adds a series of nodes into the HashTree using the given path.void
add(Collection<?> treePath, Object[] values)
Adds a series of nodes into the HashTree using the given path.void
add(Collection<?> treePath, Collection<?> values)
Adds a series of nodes into the HashTree using the given path.void
add(HashTree newTree)
Adds all the nodes and branches of the given tree to this tree.protected HashTree
addTreePath(Collection<?> treePath)
void
clear()
Clears the HashTree of all contents.Object
clone()
Create a clone of this HashTree.protected void
cloneTree(HashTree newTree)
boolean
containsKey(Object o)
If the HashTree contains the given object as a key at the top level, then a true result is returned, otherwise false.boolean
containsValue(Object value)
Implemented as required by the Map interface, but is not very useful here.protected HashTree
createNewTree()
Creates a new tree.protected HashTree
createNewTree(Object key)
Creates a new tree.protected HashTree
createNewTree(Collection<?> values)
Creates a new tree.Set<Map.Entry<Object,HashTree>>
entrySet()
Exists to satisfy the Map interface.boolean
equals(Object o)
Compares all objects in the tree and verifies that the two trees contain the same objects at the same tree levels.HashTree
get(Object key)
Returns the HashTree object associated with the given key.Object[]
getArray()
Gets an array of all keys in the current HashTree node.Object[]
getArray(Object key)
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).Object[]
getArray(Object[] treePath)
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.Object[]
getArray(Collection<?> treePath)
Recurses down into the HashTree structure using each subsequent key in the treePath argument, and returns an array of keys of the HashTree object at the end of the recursion.HashTree
getTree(Object key)
Gets the HashTree mapped to the given key.HashTree
getTree(Object[] treePath)
Gets the HashTree object mapped to the last key in the array by recursing through the HashTree structure one key at a time.HashTree
getTree(Collection<?> 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)
int
hashCode()
Returns a hashcode for this HashTree.boolean
isEmpty()
If the HashTree is empty, true is returned, false otherwise.Set<Object>
keySet()
Returns a Set of all the keys in the top-level of this HashTree.Collection<Object>
list()
Gets a Collection of all keys in the current HashTree node.Collection<?>
list(Object key)
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.Collection<?>
list(Object[] treePath)
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.Collection<?>
list(Collection<?> treePath)
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.HashTree
put(Object key, HashTree value)
This is the same as calling HashTree.add(key,value).void
putAll(Map<? extends Object,? extends HashTree> map)
The Map given must also be a HashTree, otherwise an UnsupportedOperationException is thrown.HashTree
remove(Object key)
Removes the entire branch specified by the given key.void
replaceKey(Object currentKey, Object newKey)
Finds the given current key, and replaces it with the given new key.HashTree
search(Object key)
Searches the HashTree structure for the given key.void
set(Object[] treePath, Object[] values)
Sets a series of keys into the HashTree.void
set(Object[] treePath, Collection<?> values)
Sets a series of keys into the HashTree.void
set(Object key, Object value)
Sets a key and it's value in the HashTree.void
set(Object key, Object[] values)
Sets a key and its values in the HashTree.void
set(Object key, Collection<?> values)
Sets a key and its values in the HashTree.void
set(Object key, HashTree t)
Sets a key into the current tree and assigns it a HashTree as its subtree.void
set(Collection<?> values)
Sets the nodes of the current tree to be the objects of the given collection.void
set(Collection<?> treePath, Object[] values)
Sets a series of keys into the HashTree.void
set(Collection<?> treePath, Collection<?> values)
Sets a series of keys into the HashTree.int
size()
Returns the number of top-level entries in the HashTree.String
toString()
Generate a printable representation of the tree.void
traverse(HashTreeTraverser visitor)
Allows any implementation of the HashTreeTraverser interface to easily traverse (depth-first) all the nodes of the HashTree.Collection<HashTree>
values()
Returns a collection of all the sub-trees of the current tree.-
Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait
-
Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll
-
-
-
-
Constructor Detail
-
HashTree
public HashTree()
Creates an empty new HashTree.
-
HashTree
protected HashTree(Map<Object,HashTree> _map)
Allow subclasses to provide their own Map.- Parameters:
_map
-Map
to use
-
HashTree
public HashTree(Object key)
Creates a new HashTree and adds the given object as a top-level node.- Parameters:
key
- name of the new top-level node
-
HashTree
public HashTree(Collection<?> keys)
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.
-
HashTree
public HashTree(Object[] keys)
Creates a new HashTree and adds all the objects in the given array as top-level nodes in the tree.- Parameters:
keys
- array with names for the new top-level nodes
-
-
Method Detail
-
putAll
public void putAll(Map<? extends Object,? extends HashTree> map)
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.- Specified by:
putAll
in interfaceMap<Object,HashTree>
- See Also:
add(HashTree)
,Map.putAll(Map)
-
entrySet
public Set<Map.Entry<Object,HashTree>> entrySet()
Exists to satisfy the Map interface.- Specified by:
entrySet
in interfaceMap<Object,HashTree>
- See Also:
Map.entrySet()
-
containsValue
public boolean containsValue(Object value)
Implemented as required by the Map interface, but is not very useful here. All 'values' in a HashTree are HashTree's themselves.- Specified by:
containsValue
in interfaceMap<Object,HashTree>
- Parameters:
value
- Object to be tested as a value.- Returns:
- True if the HashTree contains the value, false otherwise.
- See Also:
Map.containsValue(Object)
-
put
public HashTree put(Object key, HashTree value)
This is the same as calling HashTree.add(key,value).- Specified by:
put
in interfaceMap<Object,HashTree>
- Parameters:
key
- to usevalue
- to store against key- See Also:
Map.put(Object, Object)
-
clear
public void clear()
Clears the HashTree of all contents.- Specified by:
clear
in interfaceMap<Object,HashTree>
- See Also:
Map.clear()
-
values
public Collection<HashTree> values()
Returns a collection of all the sub-trees of the current tree.- Specified by:
values
in interfaceMap<Object,HashTree>
- See Also:
Map.values()
-
add
public void add(Object key, HashTree subTree)
Adds a key as a node at the current level and then adds the given HashTree to that new node.- Parameters:
key
- key to create in this treesubTree
- sub tree to add to the node created for the first argument.
-
add
public void add(HashTree newTree)
Adds all the nodes and branches of the given tree to this tree. Is like merging two trees. Duplicates are ignored.- Parameters:
newTree
- the tree to be added
-
containsKey
public boolean containsKey(Object o)
If the HashTree contains the given object as a key at the top level, then a true result is returned, otherwise false.- Specified by:
containsKey
in interfaceMap<Object,HashTree>
- Parameters:
o
- Object to be tested as a key.- Returns:
- True if the HashTree contains the key, false otherwise.
- See Also:
Map.containsKey(Object)
-
isEmpty
public boolean isEmpty()
If the HashTree is empty, true is returned, false otherwise.
-
set
public void set(Object key, Object 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.- Parameters:
key
- key to be set upvalue
- value to be set up as a key in the secondary node
-
set
public void set(Object key, HashTree 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.- Parameters:
key
- key to be set upt
- HashTree that the key maps to
-
set
public void set(Object key, Object[] 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.- Parameters:
key
- Key to be set upvalues
- Array of objects to be added as keys in the secondary node
-
set
public void set(Object key, Collection<?> 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.- Parameters:
key
- key to be set upvalues
- Collection of objects to be added as keys in the secondary node
-
set
public void set(Object[] treePath, Object[] 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.- Parameters:
treePath
- array of keys to put into HashTreevalues
- array of values to be added as keys to bottom-most node
-
set
public void set(Object[] treePath, Collection<?> 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.- Parameters:
treePath
- array of keys to put into HashTreevalues
- Collection of values to be added as keys to bottom-most node
-
set
public void set(Collection<?> treePath, Object[] 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.- Parameters:
treePath
- collection of keys to put into HashTreevalues
- array of values to be added as keys to bottom-most node
-
set
public void set(Collection<?> values)
Sets the nodes of the current tree to be the objects of the given collection. Any nodes previously in the tree are removed.- Parameters:
values
- Collection of objects to set as nodes.
-
set
public void set(Collection<?> treePath, Collection<?> 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.- Parameters:
treePath
- list of keys to put into HashTreevalues
- collection of values to be added as keys to bottom-most node
-
add
public HashTree add(Object key)
Adds an key into the HashTree at the current level. If a HashTree exists for the key already, no new tree will be added- Parameters:
key
- key to be added to HashTree- Returns:
- newly generated tree, if no tree was found for the given key; existing key otherwise
-
add
public void add(Object[] keys)
Adds all the given objects as nodes at the current level.- Parameters:
keys
- Array of Keys to be added to HashTree.
-
add
public void add(Collection<?> keys)
Adds a bunch of keys into the HashTree at the current level.- Parameters:
keys
- Collection of Keys to be added to HashTree.
-
add
public HashTree add(Object key, Object 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.- Parameters:
key
- key to be addedvalue
- value to be added as a key in the secondary node- Returns:
- HashTree for which
value
is the key
-
add
public void add(Object key, Object[] 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.- Parameters:
key
- key to be addedvalues
- array of objects to be added as keys in the secondary node
-
add
public void add(Object key, Collection<?> 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.- Parameters:
key
- key to be addedvalues
- Collection of objects to be added as keys in the secondary node
-
add
public void add(Object[] treePath, Object[] 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.- Parameters:
treePath
- an array of objects representing a pathvalues
- array of values to be added as keys to bottom-most node
-
add
public void add(Object[] treePath, Collection<?> 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.- Parameters:
treePath
- an array of objects representing a pathvalues
- collection of values to be added as keys to bottom-most node
-
add
public void add(Collection<?> treePath, Object[] 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.- Parameters:
treePath
- a list of objects representing a pathvalues
- array of values to be added as keys to bottom-most node
-
add
public HashTree add(Collection<?> treePath, Object 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.- Parameters:
treePath
- a list of objects representing a pathvalue
- Object to add as a node to bottom-most node- Returns:
- HashTree for which
value
is the key
-
add
public void add(Collection<?> treePath, Collection<?> 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.- Parameters:
treePath
- a SortedSet of objects representing a pathvalues
- Collection of values to be added as keys to bottom-most node
-
addTreePath
protected HashTree addTreePath(Collection<?> treePath)
-
getTree
public HashTree getTree(Object key)
Gets the HashTree mapped to the given key.- Parameters:
key
- Key used to find appropriate HashTree()- Returns:
- the HashTree for
key
-
get
public HashTree get(Object key)
Returns the HashTree object associated with the given key. Same as callinggetTree(Object)
.- Specified by:
get
in interfaceMap<Object,HashTree>
- See Also:
Map.get(Object)
-
getTree
public HashTree getTree(Object[] treePath)
Gets the HashTree object mapped to the last key in the array by recursing through the HashTree structure one key at a time.- Parameters:
treePath
- array of keys.- Returns:
- HashTree at the end of the recursion.
-
clone
public Object clone()
Create a clone of this HashTree. This is not a deep clone (ie, the contents of the tree are not cloned).
-
cloneTree
protected void cloneTree(HashTree newTree)
-
createNewTree
protected HashTree createNewTree()
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.- Returns:
- HashTree
-
createNewTree
protected HashTree createNewTree(Object 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.- Parameters:
key
- object to use as the key for the top level- Returns:
- newly created
HashTree
-
createNewTree
protected HashTree createNewTree(Collection<?> 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.
-
getTree
public HashTree getTree(Collection<?> treePath)
Gets the HashTree object mapped to the last key in the SortedSet by recursing through the HashTree structure one key at a time.- Parameters:
treePath
- Collection of keys- Returns:
- HashTree at the end of the recursion
-
list
public Collection<Object> list()
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.- Returns:
- Set of all keys in this HashTree
-
list
public Collection<?> list(Object key)
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.- Parameters:
key
- key used to find HashTree to get list of- Returns:
- Set of all keys in found HashTree.
-
remove
public HashTree remove(Object key)
Removes the entire branch specified by the given key.- Specified by:
remove
in interfaceMap<Object,HashTree>
- See Also:
Map.remove(Object)
-
list
public Collection<?> list(Object[] treePath)
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.- Parameters:
treePath
- Array of keys used to recurse into HashTree structure- Returns:
- Set of all keys found in end HashTree
-
list
public Collection<?> list(Collection<?> treePath)
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.- Parameters:
treePath
- List of keys used to recurse into HashTree structure- Returns:
- Set of all keys found in end HashTree
-
replaceKey
public void replaceKey(Object currentKey, Object newKey)
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.- Parameters:
currentKey
- name of the key to be replacednewKey
- name of the new key
-
getArray
public Object[] getArray()
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.- Returns:
- array of all keys in this HashTree.
-
getArray
public Object[] getArray(Object key)
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.- Parameters:
key
- key used to find HashTree to get list of- Returns:
- array of all keys in found HashTree
-
getArray
public Object[] getArray(Object[] treePath)
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.- Parameters:
treePath
- array of keys used to recurse into HashTree structure- Returns:
- array of all keys found in end HashTree
-
getArray
public Object[] getArray(Collection<?> treePath)
Recurses down into the HashTree structure 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.- Parameters:
treePath
- list of keys used to recurse into HashTree structure- Returns:
- array of all keys found in end HashTree
-
getTreePath
protected HashTree getTreePath(Collection<?> treePath)
-
hashCode
public int hashCode()
Returns a hashcode for this HashTree.
-
equals
public boolean equals(Object o)
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.
-
keySet
public Set<Object> keySet()
Returns a Set of all the keys in the top-level of this HashTree.- Specified by:
keySet
in interfaceMap<Object,HashTree>
- See Also:
Map.keySet()
-
search
public HashTree search(Object key)
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.- Parameters:
key
- Key to search for- Returns:
- HashTree mapped to key, if found, otherwise
null
-
size
public int size()
Returns the number of top-level entries in the HashTree.- Specified by:
size
in interfaceMap<Object,HashTree>
- See Also:
Map.size()
-
traverse
public void traverse(HashTreeTraverser 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.- Parameters:
visitor
- the visitor that wants to traverse the tree- See Also:
HashTreeTraverser
-
-