hashtree.java

测试工具

	 * 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.
	 * 
	 * @param treePath
	 *            list of keys to put into HashTree
	 * @param values
	 *            collection of values to be added as keys to bottom-most node
	 */
	public void set(Collection treePath, Collection values) {
		HashTree tree = addTreePath(treePath);
		tree.set(values);
	}

	/**
	 * Adds an key into the HashTree at the current level.
	 * 
	 * @param key
	 *            key to be added to HashTree
	 */
	public HashTree add(Object key) {
		if (!data.containsKey(key)) {
			HashTree newTree = createNewTree();
			data.put(key, newTree);
			return newTree;
		} else {
			return getTree(key);
		}
	}

	/**
	 * Adds all the given objects as nodes at the current level.
	 * 
	 * @param keys
	 *            Array of Keys to be added to HashTree.
	 */
	public void add(Object[] keys) {
		for (int x = 0; x < keys.length; x++) {
			add(keys[x]);
		}
	}

	/**
	 * Adds a bunch of keys into the HashTree at the current level.
	 * 
	 * @param keys
	 *            Collection of Keys to be added to HashTree.
	 */
	public void add(Collection keys) {
		Iterator it = keys.iterator();
		while (it.hasNext()) {
			add(it.next());
		}
	}

	/**
	 * 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.
	 * 
	 * @param key
	 *            key to be added
	 * @param value
	 *            value to be added as a key in the secondary node
	 */
	public HashTree add(Object key, Object value) {
		add(key);
		return getTree(key).add(value);
	}

	/**
	 * 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.
	 * 
	 * @param key
	 *            key to be added
	 * @param values
	 *            array of objects to be added as keys in the secondary node
	 */
	public void add(Object key, Object[] 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.
	 * 
	 * @param key
	 *            key to be added
	 * @param values
	 *            Collection of objects to be added as keys in the secondary
	 *            node
	 */
	public void add(Object key, Collection values) {
		add(key);
		getTree(key).add(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.
	 * 
	 * @param treePath
	 *            an array of objects representing a path
	 * @param values
	 *            array of values to be added as keys to bottom-most 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.
	 * 
	 * @param treePath
	 *            an array of objects representing a path
	 * @param values
	 *            collection of values to be added as keys to bottom-most node
	 */
	public void add(Object[] treePath, Collection values) {
		if (treePath != null) {
			add(Arrays.asList(treePath), values);
		}
	}

	public HashTree add(Object[] treePath, Object value) {
		return add(Arrays.asList(treePath), 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, all the objects in the second argument are
	 * added as nodes.
	 * 
	 * @param treePath
	 *            a list of objects representing a path
	 * @param values
	 *            array of values to be added as keys to bottom-most node
	 */
	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, the object in the second argument is added
	 * as a node.
	 * 
	 * @param treePath
	 *            a list of objects representing a path
	 * @param value
	 *            Object to add as a node to bottom-most node
	 */
	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 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.
	 * 
	 * @param treePath
	 *            a SortedSet of objects representing a path
	 * @param values
	 *            Collection of values to be added as keys to bottom-most node
	 */
	public void add(Collection treePath, Collection values) {
		HashTree tree = addTreePath(treePath);
		tree.add(values);
	}

	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;
	}

	/**
	 * Gets the HashTree mapped to the given key.
	 * 
	 * @param key
	 *            Key used to find appropriate HashTree()
	 */
	public HashTree getTree(Object key) {
		return (HashTree) data.get(key);
	}

	/**
	 * Returns the HashTree object associated with the given key. Same as
	 * calling {@link #getTree(Object)}.
	 * 
	 * @see java.util.Map#get(Object)
	 */
	public Object get(Object key) {
		return getTree(key);
	}

	/**
	 * Gets the HashTree object mapped to the last key in the array by recursing
	 * through the HashTree structure one key at a time.
	 * 
	 * @param treePath
	 *            array of keys.
	 * @return HashTree at the end of the recursion.
	 */
	public HashTree getTree(Object[] treePath) {
		if (treePath != null) {
			return getTree(Arrays.asList(treePath));
		} else {
			return this;
		}
	}

	/**
	 * Create a clone of this HashTree. This is not a deep clone (ie, the
	 * contents of the tree are not cloned).
	 * 
	 */
	public Object clone() {
		HashTree newTree = new HashTree();
		cloneTree(newTree);
		return newTree;
	}

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

	/**
	 * 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.
	 * 
	 * @return HashTree
	 */
	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.
	 * 
	 * @return 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.
	 * 
	 * @return HashTree
	 */
	protected HashTree createNewTree(Collection values) {
		return new HashTree(values);
	}

	/**
	 * Gets the HashTree object mapped to the last key in the SortedSet by
	 * recursing through the HashTree structure one key at a time.
	 * 
	 * @param treePath
	 *            Collection of keys
	 * @return HashTree at the end of the recursion
	 */
	public HashTree getTree(Collection treePath) {
		return getTreePath(treePath);
	}

	/**
	 * 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.
	 * 
	 * @return Set of all keys in this HashTree
	 */
	public Collection list() {
		return data.keySet();
	}

	/**
	 * 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.
	 * 
	 * @param key
	 *            key used to find HashTree to get list of
	 * @return Set of all keys in found HashTree.
	 */
	public Collection list(Object key) {
		HashTree temp = (HashTree) data.get(key);
		if (temp != null) {
			return temp.list();
		} else {
			return new LinkedList();
		}
	}

	/**
	 * Removes the entire branch specified by the given key.
	 * 
	 * @see java.util.Map#remove(Object)
	 */
	public Object remove(Object key) {
		return data.remove(key);
	}

	/**
	 * 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.
	 * 
	 * @param treePath