public ListedHashTree() 
{
        super();
        order = new LinkedList();
}

 public ListedHashTree(Object key) 
{
        super();
        order = new LinkedList();
        data.put(key, new ListedHashTree());
        order.add(key);
}

 public ListedHashTree(Collection keys) 
{
        super();
        order = new LinkedList();
        Iterator it = keys.iterator();
        while (it.hasNext()) {
            Object temp = it.next();
            data.put(temp, new ListedHashTree());
            order.add(temp);
        }
}

 public ListedHashTree(Object[] keys) 
{
        super();
        order = new LinkedList();
        for (int x = 0; x <  keys.length; x++) {
            data.put(keys[x], new ListedHashTree());
            order.add(keys[x]);
        }
}

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

 public  void clear() 
{
        super.clear();
        order.clear();
}

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

 public HashTree createNewTree() 
{
        return new ListedHashTree();
}

 public HashTree createNewTree(Object key) 
{
        return new ListedHashTree(key);
}

 public HashTree createNewTree(Collection values) 
{
        return new ListedHashTree(values);
}

 public boolean equals(Object o) 
{
        if (!(o instanceof ListedHashTree)) {
            return false;
        }
        ListedHashTree lht = (ListedHashTree) o;
        return (super.equals(lht) && order.equals(lht.order));
        // boolean flag = true;
        // if (o instanceof ListedHashTree)
        // {
        // ListedHashTree oo = (ListedHashTree) o;
        // Iterator it = order.iterator();
        // Iterator it2 = oo.order.iterator();
        // if (size() != oo.size())
        // {
        // flag = false;
        // }
        // while (it.hasNext() && it2.hasNext() && flag)
        // {
        // if (!it.next().equals(it2.next()))
        // {
        // flag = false;
        // }
        // }
        // if (flag)
        // {
        // it = order.iterator();
        // while (it.hasNext() && flag)
        // {
        // Object temp = it.next();
        // flag = get(temp).equals(oo.get(temp));
        // }
        // }
        // }
        // else
        // {
        // flag = false;
        // }
        // return flag;
}

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

 public int hashCode() 
{
        int hc = 17;
        hc = hc * 37 + (order == null ? 0 : order.hashCode());
        hc = hc * 37 + super.hashCode();
        return hc;
}

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

 public Collection list() 
{
        return order;
}

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

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

 public  void set(Object key,
    Object value) 
{
        if (!data.containsKey(key)) {
            order.add(key);
        }
        super.set(key, value);
}

 public  void set(Object key,
    HashTree t) 
{
        if (!data.containsKey(key)) {
            order.add(key);
        }
        super.set(key, t);
}

 public  void set(Object key,
    Object[] values) 
{
        if (!data.containsKey(key)) {
            order.add(key);
        }
        super.set(key, values);
}

 public  void set(Object key,
    Collection values) 
{
        if (!data.containsKey(key)) {
            order.add(key);
        }
        super.set(key, values);
}

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