re PR libgcj/1758 (java.util package lacks TreeMap)

* java/util/TreeMap.java: New file.
        * java/util/TreeSet.java: New file.
        * Makefile.am: Add TreeMap and TreeSet. Enable WeakHashMap.
        * Makefile.in: Rebuilt.
        * java/util/HashSet.java (clone): Use constructor instead of calling
        clone on itself.
        * java/util/SortedSet.java: Sync with classpath.
        * java/util/HashMap.java (hash): Use if statement instead of ternary,
        for clarity.
	Resolves PR libgcj/1758.
	Resolves PR java/1684.

From-SVN: r39657

libjava/ChangeLog

@@ -1,3 +1,15 @@
+2001-02-14  Bryce McKinlay  <bryce@albatross.co.nz>
+
+	* java/util/TreeMap.java: New file.
+	* java/util/TreeSet.java: New file.
+	* Makefile.am: Add TreeMap and TreeSet. Enable WeakHashMap.
+	* Makefile.in: Rebuilt.
+	* java/util/HashSet.java (clone): Use constructor instead of calling
+	clone on itself.
+	* java/util/SortedSet.java: Sync with classpath.
+	* java/util/HashMap.java (hash): Use if statement instead of ternary,
+	for clarity.
+
 2001-02-13  Tom Tromey  <tromey@redhat.com>
 
 	* java/io/PipedReader.java (ready): Throw IOException if pipe

libjava/Makefile.am

@@ -980,9 +980,11 @@ java/util/StringTokenizer.java \
 java/util/TimeZone.java	\
 java/util/Timer.java \
 java/util/TimerTask.java \
+java/util/TreeMap.java \
+java/util/TreeSet.java \
 java/util/TooManyListenersException.java \
-java/util/Vector.java
+java/util/Vector.java \
-#java/util/WeakHashMap.java \
+java/util/WeakHashMap.java
 
 
 ## List of all .java files to be compiled.  Please keep this list

libjava/Makefile.in

@@ -724,10 +724,12 @@ java/util/StringTokenizer.java \
 java/util/TimeZone.java	\
 java/util/Timer.java \
 java/util/TimerTask.java \
+java/util/TreeMap.java \
+java/util/TreeSet.java \
 java/util/TooManyListenersException.java \
-java/util/Vector.java
+java/util/Vector.java \
+java/util/WeakHashMap.java
 
-#java/util/WeakHashMap.java \
 
 ordinary_java_source_files = $(core_java_source_files) \
 gnu/gcj/RawData.java \
@@ -1702,10 +1704,11 @@ DEP_FILES =  .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
 .deps/java/util/SortedSet.P .deps/java/util/Stack.P \
 .deps/java/util/StringTokenizer.P .deps/java/util/TimeZone.P \
 .deps/java/util/Timer.P .deps/java/util/TimerTask.P \
-.deps/java/util/TooManyListenersException.P .deps/java/util/Vector.P \
+.deps/java/util/TooManyListenersException.P .deps/java/util/TreeMap.P \
-.deps/java/util/jar/Attributes.P .deps/java/util/jar/JarEntry.P \
+.deps/java/util/TreeSet.P .deps/java/util/Vector.P \
-.deps/java/util/jar/JarException.P .deps/java/util/jar/JarFile.P \
+.deps/java/util/WeakHashMap.P .deps/java/util/jar/Attributes.P \
-.deps/java/util/jar/JarInputStream.P \
+.deps/java/util/jar/JarEntry.P .deps/java/util/jar/JarException.P \
+.deps/java/util/jar/JarFile.P .deps/java/util/jar/JarInputStream.P \
 .deps/java/util/jar/JarOutputStream.P .deps/java/util/jar/Manifest.P \
 .deps/java/util/natGregorianCalendar.P .deps/java/util/zip/Adler32.P \
 .deps/java/util/zip/CRC32.P .deps/java/util/zip/CheckedInputStream.P \

libjava/java/util/HashMap.java

@@ -60,8 +60,8 @@ import java.io.ObjectOutputStream;
  * @author         Jon Zeppieri
  * @author         Jochen Hoenicke
  * @author	   Bryce McKinlay
- * @version        $Revision: 1.3 $
+ * @version        $Revision: 1.4 $
- * @modified       $Id: HashMap.java,v 1.3 2000/12/17 09:15:51 bryce Exp $
+ * @modified       $Id: HashMap.java,v 1.4 2000/12/21 02:00:15 bryce Exp $
  */
 public class HashMap extends AbstractMap
   implements Map, Cloneable, Serializable
@@ -500,7 +500,10 @@ public class HashMap extends AbstractMap
   /** Return an index in the buckets array for `key' based on its hashCode() */
   private int hash(Object key)
   {
-    return (key == null ? 0 : Math.abs(key.hashCode() % buckets.length));
+    if (key == null)
+      return 0;
+    else
+      return Math.abs(key.hashCode() % buckets.length);
   }
 
   /** Return an Entry who's key and value equal the supplied Map.Entry. 
@@ -611,15 +614,13 @@ public class HashMap extends AbstractMap
   }
 
   /**
-   * a class which implements the Iterator interface and is used for
+   * Iterate over HashMap's entries.
-   * iterating over HashMaps;
+   * This implementation is parameterized to give a sequential view of
-   * this implementation is parameterized to give a sequential view of
+   * keys, values, or entries.
-   * keys, values, or entries; it also allows the removal of elements, 
-   * as per the Javasoft spec.
    *
    * @author       Jon Zeppieri
-   * @version      $Revision: 1.3 $
+   * @version      $Revision: 1.4 $
-   * @modified     $Id: HashMap.java,v 1.3 2000/12/17 09:15:51 bryce Exp $
+   * @modified     $Id: HashMap.java,v 1.4 2000/12/21 02:00:15 bryce Exp $
    */
   class HashIterator implements Iterator
   {

libjava/java/util/HashSet.java

@@ -45,8 +45,8 @@ import java.io.ObjectOutputStream;
  * HashSet is a part of the JDK1.2 Collections API.
  *
  * @author      Jon Zeppieri
- * @version     $Revision: 1.5 $
+ * @version     $Revision: 1.1 $
- * @modified    $Id: HashSet.java,v 1.5 2000/10/26 10:19:00 bryce Exp $
+ * @modified    $Id: HashSet.java,v 1.1 2000/12/11 03:47:47 bryce Exp $
  */
 public class HashSet extends AbstractSet
   implements Set, Cloneable, Serializable
@@ -128,10 +128,9 @@ public class HashSet extends AbstractSet
    */
   public Object clone()
   {
-    HashSet copy = null;
+    HashSet copy = new HashSet();
     try
       {
-	copy = (HashSet) super.clone();
 	copy.map = (HashMap) map.clone();
       }
     catch (CloneNotSupportedException ex)

libjava/java/util/SortedSet.java

@@ -31,7 +31,8 @@ executable file might be covered by the GNU General Public License. */
 
 package java.util;
 
-public interface SortedSet extends Set {
+public interface SortedSet extends Set
+{
   Comparator comparator();
   Object first();
   SortedSet headSet(Object toElement);

libjava/java/util/TreeSet.java

@@ -0,0 +1,289 @@
+/* TreeSet.java -- a class providing a TreeMap-backet SortedSet
+   Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package java.util;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/**
+ * This class provides a TreeMap-backed implementation of the 
+ * SortedSet interface.
+ *
+ * Each element in the Set is a key in the backing TreeMap; each key
+ * maps to a static token, denoting that the key does, in fact, exist.
+ *
+ * Most operations are O(log n).
+ *
+ * TreeSet is a part of the JDK1.2 Collections API.
+ *
+ * @author      Jon Zeppieri
+ * @version     $Revision: 1.7 $
+ * @modified    $Id: TreeSet.java,v 1.7 2000/10/26 10:19:01 bryce Exp $
+ */
+
+public class TreeSet extends AbstractSet
+  implements SortedSet, Cloneable, Serializable
+{
+  /** The TreeMap which backs this Set */
+  transient SortedMap map;
+
+  static final long serialVersionUID = -2479143000061671589L;
+
+  /**
+   * Construct a new TreeSet whose backing TreeMap using the "natural" 
+   * ordering of keys.
+   */
+  public TreeSet()
+  {
+    map = new TreeMap();
+  }
+
+  /** 
+   * Construct a new TreeSet whose backing TreeMap uses the supplied 
+   * Comparator.
+   *
+   * @param     oComparator      the Comparator this Set will use
+   */
+  public TreeSet(Comparator comparator)
+  {
+    map = new TreeMap(comparator);
+  }
+
+  /** 
+   * Construct a new TreeSet whose backing TreeMap uses the "natural"
+   * orering of the keys and which contains all of the elements in the
+   * supplied Collection.
+   *
+   * @param     oCollection      the new Set will be initialized with all
+   *                             of the elements in this Collection
+   */
+  public TreeSet(Collection collection)
+  {
+    map = new TreeMap();
+    addAll(collection);
+  }
+
+  /**
+   * Construct a new TreeSet, using the same key ordering as the supplied
+   * SortedSet and containing all of the elements in the supplied SortedSet.
+   * This constructor runs in linear time.
+   *
+   * @param     sortedSet       the new TreeSet will use this SortedSet's
+   *                            comparator and will initialize itself
+   *                            with all of the elements in this SortedSet
+   */
+  public TreeSet(SortedSet sortedSet)
+  {
+    TreeMap map = new TreeMap(sortedSet.comparator());
+    int i = 0;
+    Iterator itr = sortedSet.iterator();
+    map.putKeysLinear(itr, sortedSet.size());
+    this.map = map;
+  }
+  
+  /* This private constructor is used to implement the subSet() calls around
+    a backing TreeMap.SubMap. */
+  TreeSet(SortedMap backingMap)
+  {
+    map = backingMap;
+  }
+
+  /** 
+   * Adds the spplied Object to the Set if it is not already in the Set;
+   * returns true if the element is added, false otherwise
+   *
+   * @param       obj       the Object to be added to this Set
+   */
+  public boolean add(Object obj)
+  {
+    return (map.put(obj, Boolean.TRUE) == null);
+  }
+
+  /**
+   * Adds all of the elements in the supplied Collection to this TreeSet.
+   *
+   * @param        c         All of the elements in this Collection
+   *                         will be added to the Set.
+   *
+   * @return       true if the Set is altered, false otherwise
+   */
+  public boolean addAll(Collection c)
+  {
+    boolean result = false;
+    int size = c.size();
+    Iterator itr = c.iterator();
+
+    for (int i = 0; i < size; i++)
+      result |= (map.put(itr.next(), Boolean.TRUE) == null);
+
+    return result;
+  }
+
+  /**
+   * Removes all elements in this Set.
+   */
+  public void clear()
+  {
+    map.clear();
+  }
+
+  /** Returns a shallow copy of this Set. */
+  public Object clone()
+  {
+    TreeSet copy = new TreeSet();
+    try
+      {
+	copy.map = (TreeMap) map.clone();
+      }
+    catch (CloneNotSupportedException ex)
+      {
+      }
+
+    return copy;
+  }
+
+  /** Returns this Set's comparator */
+  public Comparator comparator()
+  {
+    return map.comparator();
+  }
+
+  /** 
+   * Returns true if this Set contains the supplied Object, 
+   * false otherwise 
+   *
+   * @param       oObject        the Object whose existence in the Set is
+   *                             being tested
+   */
+  public boolean contains(Object obj)
+  {
+    return map.containsKey(obj);
+  }
+
+  /** Returns true if this Set has size 0, false otherwise */
+  public boolean isEmpty()
+  {
+    return map.isEmpty();
+  }
+
+  /** Returns the number of elements in this Set */
+  public int size()
+  {
+    return map.size();
+  }
+
+  /** 
+   * If the supplied Object is in this Set, it is removed, and true is
+   * returned; otherwise, false is returned.
+   *
+   * @param         obj        the Object we are attempting to remove
+   *                           from this Set
+   */
+  public boolean remove(Object obj)
+  {
+    return (map.remove(obj) != null);
+  }
+
+  /** Returns the first (by order) element in this Set */
+  public Object first()
+  {
+    return map.firstKey();
+  }
+
+  /** Returns the last (by order) element in this Set */
+  public Object last()
+  {
+    return map.lastKey();
+  }
+
+  /**
+   * Returns a view of this Set including all elements in the interval
+   * [oFromElement, oToElement).
+   *
+   * @param       from  the resultant view will contain all
+   *                    elements greater than or equal to this element
+   * @param       to    the resultant view will contain all
+   *                    elements less than this element
+   */
+  public SortedSet subSet(Object from, Object to)
+  {
+    return new TreeSet(map.subMap(from, to));
+  }
+
+  /**
+   * Returns a view of this Set including all elements less than oToElement
+   *
+   * @param       toElement    the resultant view will contain all
+   *                            elements less than this element
+   */
+  public SortedSet headSet(Object to)
+  {
+    return new TreeSet(map.headMap(to));
+  }
+
+  /**
+   * Returns a view of this Set including all elements greater than or
+   * equal to oFromElement.
+   *
+   * @param       from  the resultant view will contain all
+   *              elements greater than or equal to this element
+   */
+  public SortedSet tailSet(Object from)
+  {
+    return new TreeSet(map.tailMap(from));
+  }
+
+  /** Returns in Iterator over the elements in this TreeSet */
+  public Iterator iterator()
+  {
+    return map.keySet().iterator();
+  }
+
+  private void writeObject(ObjectOutputStream out) throws IOException
+  {
+    Iterator itr = map.keySet().iterator();
+
+    out.writeObject(map.comparator());
+    out.writeInt(map.size());
+
+    while (itr.hasNext())
+      out.writeObject(itr.next());
+  }
+
+  private void readObject(ObjectInputStream in)
+    throws IOException, ClassNotFoundException
+  {
+    Comparator comparator = (Comparator) in.readObject();
+    int size = in.readInt();
+    TreeMap map = new TreeMap(comparator);    
+    map.putFromObjStream(in, size, false);
+    this.map = map;
+  }
+}