Index: java/util/DoubleEnumeration.java
===================================================================
RCS file: /cvs/classpath/java/util/DoubleEnumeration.java,v
retrieving revision 1.5
diff -u -r1.5 DoubleEnumeration.java
--- java/util/DoubleEnumeration.java	2000/10/26 10:19:00	1.5
+++ java/util/DoubleEnumeration.java	2001/01/09 22:46:49
@@ -1,5 +1,5 @@
-/* java.util.DoubleEnumeration
-   Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+/* gnu.java.util.DoubleEnumeration
+   Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -24,57 +24,68 @@
 This exception does not however invalidate any other reasons why the
 executable file might be covered by the GNU General Public License. */
 
+package gnu.java.util;
 
-package java.util;
 import java.io.*;
+import java.util.Enumeration;
+import java.util.NoSuchElementException;
 
+
 /**
- * This is a package private class that combines two Enumerations.
+ * This is a helper class that combines two Enumerations.
  * It returns the elements of the first Enumeration until it has
  * no more elements and then returns the elements of the second
  * Enumeration.<br>
  * 
  * In the default case:
  * <pre>
+ * doubleEnum = new DoubleEnumeration(enum1, enum2);
  * while (doubleEnum.hasMoreElements()) {
  *    Object o = doubleEnum.nextElement();
  *    do_something(o);
  * }
  * </pre>
- * it calls hasMoreElements of the first Enumeration as few times as
+ * it calls hasMoreElements of the Enumerations as few times as
  * possible.
+ * The references to the Enumerations are cleared as soon as they have no
+ * more elements to help garbage collecting.
  *
- * @author Jochen Hoenicke */
-class DoubleEnumeration implements Enumeration
+ * @author Jochen Hoenicke
+ * @author Mark Wielaard (address@hidden)
+ */
+public class DoubleEnumeration implements Enumeration
 {
   /**
-   * This is true as long as the first enumeration may have more
+   * This is true as long as one of the enumerations has more
    * elements.  
+   * Only valid when hasChecked is true.
+   * Set in <code>hasMoreElements()</code>
    */
-  boolean hasMore;
+  private boolean hasMore;
   /**
-   * This is true, if it is sure that the first enumeration has
+   * This is true, if it is sure that hasMore indicates wether there are
    * more elements.
+   * Set to true in <code>hasMoreElements()</code>.
+   * Set to false in <code>getNextElement()</code>.
    */
-  boolean hasChecked;
+  private boolean hasChecked;
   /**
    * The first enumeration.
    */
-  Enumeration e1;
+  private Enumeration e1;
   /**
    * The second enumeration.
    */
-  Enumeration e2;
+  private Enumeration e2;
 
   /**
    * Creates a new Enumeration combining the given two enumerations.
    * The enumerations mustn't be accessed by other classes.
    */
-  DoubleEnumeration(Enumeration e1, Enumeration e2)
+  public DoubleEnumeration(Enumeration e1, Enumeration e2)
   {
     this.e1 = e1;
     this.e2 = e2;
-    hasMore = true;
     hasChecked = false;
   }
 
@@ -84,21 +95,34 @@
    */
   public boolean hasMoreElements()
   {
-    if (hasMore)
-      hasChecked = hasMore = e1.hasMoreElements();
-    return hasMore ? true : e2.hasMoreElements();
+    if (hasChecked)
+      return hasMore;
+
+    hasMore = (e1 != null && e1.hasMoreElements());
+
+    if (!hasMore) {
+      e1 = e2;
+      e2 = null;
+      hasMore = (e1 != null && e1.hasMoreElements());
+    }
+
+    hasChecked = true;
+    return hasMore;
   }
 
   /**
    * Returns the next element.  This returns the next element of the
    * first enumeration, if it has more elements, otherwise the next
-   * element of the second enumeration.
+   * element of the second enumeration. If both enumeration don't have
+   * any elements it throws a <code>NoSuchElementException</code>.
    */
   public Object nextElement()
   {
-    if (hasMore && !hasChecked)
-      hasMore = e1.hasMoreElements();
-    hasChecked = false;
-    return hasMore ? e1.nextElement() : e2.nextElement();
+    if (!hasMoreElements())
+      throw new NoSuchElementException();
+    else {
+      hasChecked = false;
+      return e1.nextElement();
+    }
   }
 }