View Javadoc
   package org.masukomi.tools.utils;
   
   import java.io.*;
   
   import java.sql.Clob;
   import java.sql.Date;
   
   import java.util.*;
   
  
  /***
   * A class the simplifies working with Hashtables of Hashtables by allowing the
   * user to work directly on the sub-Hashtables.
   * 
   * <p>
   * Over Time this class has grown and is now beginning to accomidate things
   * other than Hashtables. As a result new getXXX methods are being added as
   * needed. Eventually I plan on adding complete Hashtable of Vector support
   * too, but I'll probably have to rename it at that point.
   * </p>
   * 
   * <p>
   * To Be Done The .toString() methods need to be improved to handle non-String
   * objects
   * </p>
   * 
   * <p>
   * This software is copyright 2002 Kate Rhodes. <br>
   * It is distributed under the MIT License which can be found at <a href="http://www.opensource.org/licenses/mit-license.php">http://www.opensource.org/licenses/mit-license.php</a><br>
   * Details on this package can be found at <a href="http://tools.masukomi.org/">http://tools.masukomi.org/</a><br>
   * e-mail <tt>masukomi at masukomi dot org</tt> for questions or details
   * </p>
   */
  public class HashtableOfHashtables implements Serializable {
      /*** DOCUMENT ME! */
      private Hashtable rootHashtable;
  
      /***
       * Constructs a new, empty hashtable of hashtables with a default initial
       * capacity (11) and load factor, which is 0.75.
       */
      public HashtableOfHashtables() {
          rootHashtable = new Hashtable();
      }
  
      /***
       * Constructs a new, empty hashtable of hashtables with the specified
       * initial capacity and default load factor, which is 0.75.
       *
       * @param initialCapacity the initial capacity of the root hashtable
       */
      public HashtableOfHashtables(int initialCapacity) {
          rootHashtable = new Hashtable(initialCapacity);
      }
  
      /***
       * Constructs a new, empty hashtable of hashtables with the specified
       * initial capacity and the specified load factor.
       *
       * @param initialCapacity the initial capacity of the root hashtable
       * @param loadFactor the load factor of the root hashtable
       */
      public HashtableOfHashtables(int initialCapacity, float loadFactor) {
          rootHashtable = new Hashtable(initialCapacity, loadFactor);
      }
  
      /***
       * Constructs a new hashtable of hashtables with the same mappings as the
       * given Map.
       *
       * @param theMap the Map you wish to use in creation of the root Hashtable
       */
      public HashtableOfHashtables(Map theMap) {
          rootHashtable = new Hashtable(theMap);
      }
  
      /***
       * Constructs a new hashtable of hashtables with the rootHashtable set to a
       * deep copy of the passed Hashtable.
       *
       * @param starterHashtable A Hashtable you wish to copy and use as the root
       *        Hashtable
       */
      public HashtableOfHashtables(Hashtable starterHashtable) {
          rootHashtable = new Hashtable();
  
          Enumeration keysEnum = starterHashtable.keys();
  
          while ((keysEnum != null) && keysEnum.hasMoreElements()) {
              Object currentKey = keysEnum.nextElement();
              rootHashtable.put(currentKey, starterHashtable.get(currentKey));
          }
  
          //whee :)
      }
  
      /***
       * removes <i>All</i> entries in the rootHashtable. This, of course,
       * includes the subHashtables
      */
     public void clear() {
         rootHashtable.clear();
     }
 
     /***
      * Clears the subHashtable specified by key so that it contains no keys.
      *
      * @param key the key of the sub Hashtable you wish to clear
      */
     public void clear(Object key) {
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             subHashtable.clear();
         }
     }
 
     /***
      * Creates a shallow copy of this hashtable.
      *
      * @return a shallow copy of the root hashtable
      */
     public Object clone() {
         return rootHashtable.clone();
     }
 
     /***
      * Creates a shallow copy of this subHashtable.
      *
      * @param key the key for the sub Hashtable you wish a shallow copy of
      *
      * @return a shallow copy of the specified sub Hashtable
      */
     public Object clone(Object key) {
         Hashtable subHashtable = get(key);
 
         return subHashtable.clone();
     }
 
     /***
      * Tests if some key maps into the specified value in the root Hashtable
      *
      * @param value the value you wish to test for in the root hashtable
      *
      * @return true if the value exists in the root Hashtable
      */
     public boolean contains(Object value) {
         return rootHashtable.contains(value);
     }
 
     /***
      * Tests if some key maps into the specified value in the subHashtable
      * specified by key.
      *
      * @param key the key of the sub Hashtable you wish to test for value in
      * @param value the value you wish to test for the presence of in the sub
      *        Hashtable
      *
      * @return true if the value exists in the specified Hashtable
      */
     public boolean contains(Object key, Object value) {
         Hashtable subHashtable = get(key);
 
         return subHashtable.contains(value);
     }
 
     /***
      * Tests if some key maps into the specified value in this hashtable or any
      * of the subHashtables. This can be an expensive operation depending on
      * the size of this HashtableOfHashtables
      *
      * @param value the value you wish to test for the presence of
      *
      * @return true if the value exists in the root Hashtable or any of the sub
      *         Hashtables
      */
     public boolean containedAnywhere(Object value) {
         if (value == null) {
             value = this;
         }
 
         for (Enumeration enum = rootHashtable.keys(); enum.hasMoreElements();) {
             try {
                 Hashtable subHashtable =
                     (Hashtable) rootHashtable.get(enum.nextElement());
 
                 if (subHashtable.contains(value)) {
                     return true;
                 }
             } catch (Exception e) {
                 // just in case one of those sub elements isn't a Hashtable
             }
         }
 
         return false;
     }
 
     /***
      * Tests if the specified object is a key in the root Hashtable.
      *
      * @param key the key you wish to test for in the root Hashtable
      *
      * @return true if the root Hashtable contains the specified key
      */
     public boolean containsKey(Object key) {
         if (key == null) {
             return false;
         }
 
         return rootHashtable.containsKey(key);
     }
 
     /***
      * Tests if the specified object is a key in the subHashtable specified by
      * key.
      *
      * @param key the key of the sub Hashtable you wish to test for the subKey
      *        in
      * @param subKey the key you wish to test for the presence of in the sub
      *        Hashtable specified by Key
      *
      * @return true if the subKey was found in the sub Hashtable specified by
      *         key
      */
     public boolean containsKey(Object key, Object subKey) {
         if ((subKey == null) || (key == null)) {
             return false;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.containsKey(subKey);
         } else {
             return false;
         }
 
         //return (subHashtable != null) ? subHashtable.containsKey(subKey) : false;
     }
 
     /***
      * Returns true if this Hashtable maps one or more keys to this value. Note
      * that this method is identical in functionality to contains (which
      * predates the Map interface).
      *
      * @param value the value whose presence in the root Hashtable is to be
      *        tested.
      *
      * @return true if this map maps one or more keys to the specified value.
      */
     public boolean containsValue(Object value) {
         return rootHashtable.containsValue(value);
     }
 
     /***
      * Returns true if this Hashtable maps one or more keys to this value. Note
      * that this method is identical in functionality to contains (which
      * predates the Map interface).
      *
      * @param key the key of the subtable you wish to test for the value in.
      * @param value the value whose presence in the sub Hashtable indicated by
      *        key is to be tested.
      *
      * @return true if this map maps one or more keys to the specified value.
      */
     public boolean containsValue(Object key, Object value) {
         /*if ((value == null) || (key == null)) {
             return false;
         }*/
 
         // I'd prefer it to throw the exception myself
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.containsValue(key);
         } else {
             return false;
         }
     }
 
     /***
      * Returns an enumeration of the values in the root Hashtable.  Use the
      * Enumeration methods on the returned object to fetch the elements
      * sequentially.
      *
      * @return an enumeration of the values in the root Hashtable.
      */
     public Enumeration elements() {
         return rootHashtable.elements();
     }
 
     /***
      * Returns an enumeration of the values in the root Hashtable.  Use the
      * Enumeration methods on the returned object to fetch the elements
      * sequentially.
      *
      * @param key the key of the sub Hashtable you wish to get the values of
      *
      * @return an enumeration of the values in the root Hashtable.
      */
     public Enumeration elements(Object key) {
         if (key == null) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.elements();
         } else {
             return null;
         }
     }
 
     /***
      * Returns a Set view of the entries contained in the root Hashtable. Each
      * element in this collection is a Map.Entry. The Set is backed by the
      * Hashtable, so changes to the Hashtable are reflected in the Set, and
      * vice-versa. The Set supports element removal (which removes the
      * corresponding entry from the Hashtable), but not element addition.
      *
      * @return a set view of the mappings contained in the root Hashtable's
      *         map.
      */
     public Set entrySet() {
         return rootHashtable.entrySet();
     }
 
     /***
      * Returns a Set view of the entries contained in the subHashtable
      * indicated by key.
      *
      * @param key the key of the sub Hashtable you wish to retreive a Set view
      *        of.
      *
      * @return a set view of the mappings contained in the sub Hashtable's map.
      */
     public Set entrySet(Object key) {
         if (key == null) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.entrySet();
         } else {
             return null;
         }
     }
 
     /***
      * Compares the specified Object with this Map for equality, as per the
      * definition in the Map interface.
      *
      * @param anObject object to be compared for equality with the root
      *        Hashtable
      *
      * @return true if the specified Object is equal to the Root Hashtable's
      *         Map.
      */
     public boolean equals(Object anObject) {
         return rootHashtable.equals(anObject);
     }
 
     /***
      * Compares the specified Object with this Map for equality, as per the
      * definition in the Map interface.
      *
      * @param key the key indicating the sub Hashtable you wish to test for
      *        equality
      * @param anObject object to be compared for equality with the root
      *        Hashtable
      *
      * @return true if the specified Object is equal to the Root Hashtable's
      *         Map.
      */
     public boolean equals(Object key, Object anObject) {
         if (key == null) {
             return false;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.equals(anObject);
         } else {
             return false;
         }
     }
 
     /***
      * Returns the Hashtable indicated by key
      *
      * @param key the key of the subHashtable you wish to retreive
      *
      * @return the Hashtable indicated by key
      */
     public Hashtable get(Object key) {
         if (key == null) {
             return null;
         }
 
         return (Hashtable) rootHashtable.get(key);
     }
 
     /***
      * Returns the value associated with the specified key in the root
      * Hashtable
      *
      * @param key the key in the root Hashtable that coresponds to the value
      *        you wish to retreive
      *
      * @return an object from the rootHashtable that may or may not be a
      *         Hashtable. Just because it's called HashtableOfHashtables
      *         doesn't mean that's really all you can put in it if you're
      *         careful
      */
     public Object getObject(Object key) {
         if (key == null) {
             return null;
         }
 
         return rootHashtable.get(key);
     }
 
     /***
      * Returns an object from the sub hashtable specified by key and associated
      * with the the subKey key in the sub Hashtable
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key within the sub Hashtable
      *
      * @return the value to which the specified subKey is mapped in the
      *         subHashtable indicated by key. null if non-existent or null
      *         value was stored
      */
     public Object get(Object key, Object subKey) {
         if ((subKey == null) || (key == null)) {
             return null;
         }
 
         Hashtable tempHash = get(key);
 
         if (tempHash.containsKey(subKey)) {
             return tempHash.get(subKey);
         } else {
             return null;
         }
 
         //return (value == this) ? null : value;
     }
 
     /***
      * Tries to return you a Boolean object. If the object stored is a Boolean
      * it will just be cast from an Object to a Boolean and returned. If the
      * Object is not a Boolean it will try to create a new Boolean from it and
      * return that.
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a Boolean.
      */
     public Boolean getBoolean(Object key, Object subKey) {
         try {
             return (Boolean) get(key, subKey);
         } catch (ClassCastException e) {
             return new Boolean(getString(key, subKey));
         }
     }
 
     /***
      * Tries to return you a Boolean object. If the object stored is a Boolean
      * it will just be cast from an Object to a Boolena and returned. If the
      * Object is not a Boolean it will try to create a new Boolean from it and
      * return that.
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a Boolean
      */
     public Boolean getBoolean(Object key) {
         try {
             return (Boolean) getObject(key);
         } catch (ClassCastException e) {
             return new Boolean(getString(key));
         }
     }
 
     /***
      * Returns the specified object as a Clob
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a Clob
      */
     public Clob getClob(Object key, Object subKey) {
         return (Clob) get(key, subKey);
     }
 
     /***
      * Returns the specified object as a Clob
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a Clob
      */
     public Clob getClob(Object key) {
         return (Clob) getObject(key);
     }
 
     /***
      * Returns the specified object as a Double
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a Double
      */
     public Double getDate(Object key, Object subKey) {
         return (Double) get(key, subKey);
     }
 
     /***
      * Returns the specified object as a Date
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a Date
      */
     public Date getDate(Object key) {
         return (Date) getObject(key);
     }
 
     /***
      * Returns the specified object as a Double
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a Double
      */
     public Double getDouble(Object key, Object subKey) {
         return (Double) get(key, subKey);
     }
 
     /***
      * Returns the specified object as a Double
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a Double
      */
     public Double getDouble(Object key) {
         return (Double) getObject(key);
     }
 
     /***
      * Returns the specified object as a Float
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a Float
      */
     public Float getFloat(Object key, Object subKey) {
         return (Float) get(key, subKey);
     }
 
     /***
      * Returns the specified object as a Float
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a Float
      */
     public Float getFloat(Object key) {
         return (Float) getObject(key);
     }
     
 	/***
 	 * Returns the specified object as a Hashtable
 	 *
 	 * @param key the key of the sub Hashtable
 	 * @param subKey the key in the subtable of the object you wish to retreive
 	 *
 	 * @return the value of the subKey as a Float
 	 */
 	public Hashtable getHashtable(Object key, Object subKey) {
 		return (Hashtable) get(key, subKey);
 	}
 
 	/***
 	 * Returns the specified object as a Float
 	 *
 	 * @param key the key of the object in the root hashtable you wish to
 	 *        retreive
 	 *
 	 * @return the value of the key as a Float
 	 */
 	public Hashtable getHashtable(Object key) {
 		return (Hashtable) getObject(key);
 	}
 
 
     /***
      * Returns the specified object as an Integer
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as an Integer
      */
     public Integer getInteger(Object key, Object subKey) {
         return (Integer) get(key, subKey);
     }
 
     /***
      * Returns the specified object as an Integer
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as an Integer
      */
     public Integer getInteger(Object key) {
         return (Integer) getObject(key);
     }
 
     /***
      * Returns the specified object as a String
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a string
      */
     public String getString(Object key, Object subKey) {
         return (String) get(key, subKey);
     }
 
     /***
      * Returns the specified object as a String
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a String
      */
     public String getString(Object key) {
         return (String) getObject(key);
     }
 
     /***
      * Returns the specified object as a Vector
      *
      * @param key the key of the sub Hashtable
      * @param subKey the key in the subtable of the object you wish to retreive
      *
      * @return the value of the subKey as a Vector
      */
     public Vector getVector(Object key, Object subKey) {
         return (Vector) get(key, subKey);
     }
 
     /***
      * Returns the specified object as a Vector
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the value of the key as a Vector
      */
     public Vector getVector(Object key) {
         return (Vector) getObject(key);
     }
 
     /***
      * Returns the hash code value for the root Hashtable's Map as per the
      * definition in the Map interface.
      *
      * @return the hash code value for this Map in the subHashtable indicated
      *         by key as per the definition in the Map interface.
      */
     public int hashCode() {
         return rootHashtable.hashCode();
     }
 
     /***
      * Returns the hash code value for the specified Hashtable's Map as per the
      * definition in the Map interface.
      *
      * @param key the key of the object in the root hashtable you wish to
      *        retreive
      *
      * @return the hash code value for this Map as per the definition in the
      *         Map interface or -1 in the case of a missing subHashtable.
      */
     public int hashCode(Object key) {
         if (key == null) {
             return -1;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.hashCode();
         } else {
             return -1;
         }
     }
 
     /***
      * Tests if this hashtable maps no keys to values.
      *
      * @return true if table is empty
      */
     public boolean isEmpty() {
         return rootHashtable.isEmpty();
     }
 
     /***
      * Tests if this hashtable maps no keys to values.
      *
      * @param key the key of the sub Hashtable you wish to test
      *
      * @return true if the subHashtable indicated by key is empty, or true in
      *         the case of a missing subHashtable
      */
     public boolean isEmpty(Object key) {
         if (key == null) {
             return true;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.isEmpty();
         } else {
             return true;
         }
     }
 
     /***
      * Returns an enumeration of the keys in the root hashtable.
      *
      * @return an enumeration of the keys in the root Hashtable.
      */
     public Enumeration keys() {
         return rootHashtable.keys();
     }
 
     /***
      * Returns an enumeration of the keys in the specified hashtable.
      *
      * @param key the key of the sub Hashtable you wish to retreive the keys of
      *
      * @return an enumeration of the keys in the subHashtable indicated by key
      */
     public Enumeration keys(Object key) {
         if (key == null) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.keys();
         } else {
             return null;
         }
     }
 
     /***
      * Returns a Set view of the keys contained in the root Hashtable.
      *
      * @return a Set view of the keys contained in the root Hashtable.
      */
     public Set keySet() {
         return rootHashtable.keySet();
     }
 
     /***
      * Returns a Set view of the keys contained in the specified Hashtable.
      *
      * @param key the key of the sub Hashtable you wish to retreive the key Set
      *        for
      *
      * @return a Set view of the keys contained in the subHashtable indicated
      *         by key.
      */
     public Set keySet(Object key) {
         if (key == null) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.keySet();
         } else {
             return null;
         }
     }
 
     /***
      * Maps the specified key to the specified value in the root hashtable. if
      * the value passed is null it will put in an empty string
      *
      * @param key the key in the root Hashtable you wish to associate a value
      *        with
      * @param theObject wish wish to associate with the key
      */
     public void put(Object key, Object theObject) {
         if (key != null) {
             if (theObject != null) {
                 rootHashtable.put(key, theObject);
             } else {
                 rootHashtable.put(key, ""); //stupid hashtables not accepting null
             }
         }
     }
 
     /***
      * Maps the specified key to the specified value in the subHshtable
      * indicated by key
      *
      * @param key the key identifying the subHashtable to call put on.
      * @param subKey the key you want the value object mapped to
      * @param value the value you want mapped to subKey
      */
     public void put(Object key, Object subKey, Object value) {
         if (!rootHashtable.containsKey(key)) {
             rootHashtable.put(key, new Hashtable());
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable == null) {
             subHashtable = new Hashtable();
         }
 
         subHashtable.put(subKey, value);
     }
 
     /***
      * Copies all of the mappings from the specified Map to this Hashtable
      * These mappings will replace any mappings that this Hashtable had for
      * any of the keys currently in the specified Map.
      *
      * @param aMap Mappings to be stored in the root Hashtable's Map
      */
     public void putAll(Map aMap) {
         rootHashtable.putAll(aMap);
     }
 
     /***
      * Copies all of the mappings from the specified Map to the subHashtable
      * indicated by key These mappings will replace any mappings that this
      * Hashtable had for any of the keys currently in the specified Map.
      *
      * @param key the key of the subHashtable you wish to putAll in
      * @param aMap Mappings to be stored in the specified sub Hashtable
      */
     public void putAll(Object key, Map aMap) {
         if (key != null) {
             Hashtable subHashtable = get(key);
 
             if (subHashtable == null) {
                 subHashtable = new Hashtable();
                 subHashtable.putAll(aMap);
             } else {
                 subHashtable.putAll(aMap);
             }
         }
     }
 
     /***
      * Removes the key (and its corresponding value) from this hashtable.
      *
      * @param key the key of the object in the root Hashtable you wish to
      *        remove
      *
      * @return the value to which the key had been mapped in this hashtable, or
      *         null if the key did not have a mapping.
      */
     public Object remove(Object key) {
         return rootHashtable.remove(key);
     }
 
     /***
      * removes value from sub-table specified by key and subkey.
      *
      * @param key the key indicating which subHashtable to remove from
      * @param subKey the key in the subHashtable you wish to remove
      *
      * @return the value to which the key had been mapped in this hashtable, or
      *         null if the key did not have a mapping.
      */
     public Object remove(Object key, Object subKey) {
         if ((key == null) || (subKey == null)) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.remove(subKey);
         } else {
             return null;
         }
     }
 
     /***
      * Returns the number of keys in the root Hashtable.
      *
      * @return the number of keys in the root Hashtable.
      */
     public int size() {
         return rootHashtable.size();
     }
 
     /***
      * Returns the number of keys in the specified sub Hashtable
      *
      * @param key the key indicating which subHashtable you wish to get the
      *        size of
      *
      * @return the number of keys in the subHashtable indicated by key or -1 in
      *         the case of a null value.
      */
     public int size(Object key) {
         if (key == null) {
             return -1;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.size();
         } else {
             return -1;
         }
     }
 
     /***
      * Returns the number of keys in all the sub Hashtables
      *
      * @return the combined total size of all tables
      */
     public int totalSize() {
         int count = 0;
 
         for (Enumeration enum = rootHashtable.keys(); enum.hasMoreElements();) {
             Object    key          = enum.nextElement();
             Hashtable subHashtable = get(key);
             count += subHashtable.size();
         }
 
         return count;
     }
 
     /***
      * Returns a string representation of this Hashtable object and all its sub
      * Hashtables.
      *
      * @return Returns a string representation of this Hashtable object and all
      *         of its subHashtables in the form of a set of entries, enclosed
      *         in braces and separated by the ASCII characters ", " (comma and
      *         space). Each one will be preceded by the key of the hashtable
      *         that contains them followed bya space. ex. subHastableKey
      *         (this, that, etc.)
      */
     public String toString() {
         StringBuffer buffer = new StringBuffer();
 
         for (Enumeration e = rootHashtable.keys(); e.hasMoreElements();) {
             Object key = e.nextElement();
             buffer.append("\n");
             buffer.append(key.toString());
             buffer.append(" ");
 
             Hashtable subHashtable = get(key);
             buffer.append(subHashtable.toString());
         }
 
         buffer.deleteCharAt(1);
 
         return buffer.toString();
     }
 
     /***
      * Returns a string representation of the subHashtable indicated by key
      *
      * @param key the key indicating the sub Hashtable you wish to retreive a
      *        string representation of
      *
      * @return a string representation of the subHashtable indicated by key
      *         object in the form of a set of entries, enclosed in braces and
      *         separated by the ASCII characters ", " (comma and space).
      */
     public String toString(Object key) {
         if (key == null) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.toString();
         } else {
             return null;
         }
     }
 
     /***
      * return a Collection view of the values contained in the root Hashtable.
      *
      * @return a Collection view of the values contained in the root Hashtable.
      */
     public Collection values() {
         return rootHashtable.values();
     }
 
     /***
      * Returns a Collection view of the values contained in the specified sub
      * Hashtable indicated by key.
      *
      * @param key the key indicating the sub Hashtable whose values you wish to
      *        retreive a Collection of.
      *
      * @return a Collection view of the values contained in the specified sub
      *         Hashtable
      */
     public Collection values(Object key) {
         if (key == null) {
             return null;
         }
 
         Hashtable subHashtable = get(key);
 
         if (subHashtable != null) {
             return subHashtable.values();
         } else {
             return null;
         }
     }
 }