AbstractCollection.java (addAll): Use size() instead of hasNext() in iterator loop.

2000-10-29  Bryce McKinlay  <bryce@albatross.co.nz>

	* java/util/AbstractCollection.java (addAll): Use size() instead of
	hasNext() in iterator loop.
	(clear): Ditto.
	(contains): Ditto. Simplify loop.
	(containsAll): Ditto.
	(remove): Ditto.
	(removeAll): Ditto.
	(retainAll): Ditto.
	(toArray): Ditto.
	(toString): Ditto. Use string concatenation operators, not
	StringBuffer.
	* java/util/AbstractList.java (addAll): Use size() instead of
	hasNext() in iterator loop.
	(equals): Ditto.
	(hashCode): Ditto.
	(indexOf): Ditto. Don't take null check outside of the loop.
	(iterator): Return an AbstractListItr instead of anonymous class.
	(lastIndexOf): Use a for loop bounded by size() instead of
	hasPrevious() in iterator loop.
	(listIterator): Return an AbstractListItr.
	(removeRange): Remove bounds checking code and docs.
	(AbstractListItr): New inner class. Code moved here from
	listIterator().
	(SubList.iterator): Removed. Use default implementation from
	AbstractList instead.
	(SubList.listIterator): As above.
	* java/util/AbstractMap.java (clear): Use a for loop bounded by size()
	instead of hasNext() in iterator loop.
	(containsValue): Ditto.
	(equals): Ditto.
	(get): Ditto.
	(put): Ditto.
	(putAll): Ditto.
	(remove): Ditto.
	(toString): Ditto. Use string concatenation operators, not
	StringBuffer.
	* java/util/AbstractSequentialList.java (addAll): Use a for loop
	bounded by size() instead of hasNext() in iterator loop.
	* java/util/AbstractSet.java (hashCode): Don't catch exception as
	part of normal execution flow. Do an explicit null check instead.
	* java/util/ArrayList.java (_iSize): Rename to `size'.
	(_arData): Rename to `data'.
	(get): Check lower bounds also. Simplify IndexOutOfBoundsException
	message.
	(remove): Ditto.
	(removeRange): Make protected. Don't check bounds.
	(add): Check lower bounds also. Simplify IndexOutOfBoundsException
	message.
	(addAll (Collection)): Use a size-bounded for loop instead of hasNext()
	check.
	(addAll (int, Collection)): Check lower bounds. Simplify exception
	string.
	(clone): Clone the data array too.
	(indexOf): Inline doesEqual().
	(lastIndexOf): Ditto.
	(clear): Don't set array data to null.
	(set): Check lower bounds. Simplify exception string.
	(toArray): Correct comment.
	(trimToSize): Don't update modCount, this is not a structural change.
	Add comment.

	* java/util/BitSet.java: Merged with classpath, new JDK 1.2 methods
	implemented.
	(toString): Declare `bit' as long, not int.
	(data): Made package-private, not private.

From-SVN: r37116

1 files changed, 220 insertions, 343 deletions

diff --git a/libjava/java/util/AbstractList.java b/libjava/java/util/AbstractList.java
index da76a8b3104..89d9a1e1e1b 100644
--- a/libjava/java/util/AbstractList.java
+++ b/libjava/java/util/AbstractList.java
@@ -7,7 +7,7 @@ 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
@@ -44,8 +44,8 @@ package java.util;
  * AbstractList is documented, so that subclasses can tell which methods could
  * be implemented more efficiently.
  */
-public abstract class AbstractList extends AbstractCollection implements List {
-
+public abstract class AbstractList extends AbstractCollection implements List
+{
   /**
    * A count of the number of structural modifications that have been made to
    * the list (that is, insertions and removals).
@@ -54,238 +54,112 @@ public abstract class AbstractList extends AbstractCollection implements List {
 
   public abstract Object get(int index);
 
-  public void add(int index, Object o) {
+  public void add(int index, Object o)
+  {
     throw new UnsupportedOperationException();
   }
 
-  public boolean add(Object o) {
+  public boolean add(Object o)
+  {
     add(size(), o);
     return true;
   }
 
-  public boolean addAll(int index, Collection c) {
-    Iterator i = c.iterator();
-    if (i.hasNext()) {
-      do {
-        add(index++, i.next());
-      } while (i.hasNext());
-      return true;
-    } else {
-      return false;
-    }
+  public boolean addAll(int index, Collection c)
+  {
+    Iterator itr = c.iterator();
+    int size = c.size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	add(index++, itr.next());
+      }
+    return (size > 0);
   }
 
-  public void clear() {
+  public void clear()
+  {
     removeRange(0, size());
   }
 
-  public boolean equals(Object o) {
-    if (o == this) {
+  public boolean equals(Object o)
+  {
+    if (o == this)
       return true;
-    } else if (!(o instanceof List)) {
+    if (!(o instanceof List))
       return false;
-    } else {
-      Iterator i1 = iterator();
-      Iterator i2 = ((List)o).iterator();
-      while (i1.hasNext()) {
-        if (!i2.hasNext()) {
-          return false;
-        } else {
-          Object e = i1.next();
-          if (e == null ? i2.next() != null : !e.equals(i2.next())) {
-            return false;
-          }
-        }
-      }
-      if (i2.hasNext()) {
-        return false;
-      } else {
-        return true;
+    int size = size();
+    if (size != ((List) o).size())
+      return false;
+
+    Iterator itr1 = iterator();
+    Iterator itr2 = ((List) o).iterator();
+
+    for (int pos = 0; pos < size; pos++)
+      {
+	Object e = itr1.next();
+	if (e == null ? itr2.next() != null : !e.equals(itr2.next()))
+	  return false;
       }
-    }
+    return true;
   }
 
-  public int hashCode() {
+  public int hashCode()
+  {
     int hashCode = 1;
-    Iterator i = iterator();
-    while (i.hasNext()) {
-      Object obj = i.next();
-      hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
-    }
+    Iterator itr = iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	Object obj = itr.next();
+	hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
+      }
     return hashCode;
   }
 
-  public int indexOf(Object o) {
-    int index = 0;
-    ListIterator i = listIterator();
-    if (o == null) {
-      while (i.hasNext()) {
-        if (i.next() == null) {
-          return index;
-        }
-        index++;
-      }
-    } else {
-      while (i.hasNext()) {
-        if (o.equals(i.next())) {
-          return index;
-        }
-        index++;
+  public int indexOf(Object o)
+  {
+    ListIterator itr = listIterator(0);
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (o == null ? itr.next() == null : o.equals(itr.next()))
+	  return pos;
       }
-    }
     return -1;
   }
 
-  public Iterator iterator() {
-    return new Iterator() {
-      private int knownMod = modCount;
-      private int position = 0;
-      boolean removed = true;
-
-      private void checkMod() {
-        if (knownMod != modCount) {
-          throw new ConcurrentModificationException();
-        }
-      }
-
-      public boolean hasNext() {
-        checkMod();
-        return position < size();
-      }
-
-      public Object next() {
-        checkMod();
-        removed = false;
-        try {
-          return get(position++);
-        } catch (IndexOutOfBoundsException e) {
-          throw new NoSuchElementException();
-        }
-      }
-
-      public void remove() {
-        checkMod();
-        if (removed) {
-          throw new IllegalStateException();
-        }
-        AbstractList.this.remove(--position);
-        knownMod = modCount;
-        removed = true;
-      }
-    };
+  public Iterator iterator()
+  {
+    return new AbstractListItr(0);
   }
 
-  public int lastIndexOf(Object o) {
-    int index = size();
-    ListIterator i = listIterator(index);
-    if (o == null) {
-      while (i.hasPrevious()) {
-        index--;
-        if (i.previous() == null) {
-          return index;
-        }
-      }
-    } else {
-      while (i.hasPrevious()) {
-        index--;
-        if (o.equals(i.previous())) {
-          return index;
-        }
+  public int lastIndexOf(Object o)
+  {
+    int size = size();
+    ListIterator itr = listIterator(size);
+    for (int pos = size; pos > 0; pos--)
+      {
+	if (o == null ? itr.previous() == null : o.equals(itr.previous()))
+	  return pos - 1;
       }
-    }
     return -1;
   }
 
-  public ListIterator listIterator() {
-    return listIterator(0);
+  public ListIterator listIterator()
+  {
+    return new AbstractListItr(0);
   }
 
-  public ListIterator listIterator(final int index) {
-
-    if (index < 0 || index > size()) {
+  public ListIterator listIterator(int index)
+  {
+    if (index < 0 || index > size())
       throw new IndexOutOfBoundsException();
-    }
-
-    return new ListIterator() {
-      private int knownMod = modCount;
-      private int position = index;
-      private int lastReturned = -1;
 
-      private void checkMod() {
-        if (knownMod != modCount) {
-          throw new ConcurrentModificationException();
-        }
-      }
-
-      public boolean hasNext() {
-        checkMod();
-        return position < size();
-      }
-
-      public boolean hasPrevious() {
-        checkMod();
-        return position > 0;
-      }
-
-      public Object next() {
-        checkMod();
-        if (hasNext()) {
-          lastReturned = position++;
-          return get(lastReturned);
-        } else {
-          throw new NoSuchElementException();
-        }
-      }
-
-      public Object previous() {
-        checkMod();
-        if (hasPrevious()) {
-          lastReturned = --position;
-          return get(lastReturned);
-        } else {
-          throw new NoSuchElementException();
-        }
-      }
-
-      public int nextIndex() {
-        checkMod();
-        return position;
-      }
-
-      public int previousIndex() {
-        checkMod();
-        return position - 1;
-      }
-
-      public void remove() {
-        checkMod();
-        if (lastReturned < 0) {
-          throw new IllegalStateException();
-        }
-        AbstractList.this.remove(lastReturned);
-        knownMod = modCount;
-        position = lastReturned;
-        lastReturned = -1;
-      }
-
-      public void set(Object o) {
-        checkMod();
-        if (lastReturned < 0) {
-          throw new IllegalStateException();
-        }
-        AbstractList.this.set(lastReturned, o);
-      }
-
-      public void add(Object o) {
-        checkMod();
-        AbstractList.this.add(position++, o);
-        lastReturned = -1;
-        knownMod = modCount;
-      }
-    };
+    return new AbstractListItr(index);
   }
 
-  public Object remove(int index) {
+  public Object remove(int index)
+  {
     throw new UnsupportedOperationException();
   }
 
@@ -303,59 +177,145 @@ public abstract class AbstractList extends AbstractCollection implements List {
    *
    * @param fromIndex the index, inclusive, to remove from.
    * @param toIndex the index, exclusive, to remove to.
-   * @exception UnsupportedOperationException if this list does not support
-   *   the removeRange operation.
-   * @exception IndexOutOfBoundsException if fromIndex > toIndex || fromIndex <
-   *   0 || toIndex > size().
    */
-  protected void removeRange(int fromIndex, int toIndex) {
-    if (fromIndex > toIndex) {
-      throw new IllegalArgumentException();
-    } else if (fromIndex < 0 || toIndex > size()) {
-      throw new IndexOutOfBoundsException();
-    } else {
-      ListIterator i = listIterator(fromIndex);
-      for (int index = fromIndex; index < toIndex; index++) {
-        i.next();
-        i.remove();
+  protected void removeRange(int fromIndex, int toIndex)
+  {
+    ListIterator itr = listIterator(fromIndex);
+    for (int index = fromIndex; index < toIndex; index++)
+      {
+	itr.next();
+	itr.remove();
       }
-    }
   }
 
-  public Object set(int index, Object o) {
+  public Object set(int index, Object o)
+  {
     throw new UnsupportedOperationException();
   }
 
-  public List subList(final int fromIndex, final int toIndex) {
+  public List subList(final int fromIndex, final int toIndex)
+  {
     if (fromIndex > toIndex)
       throw new IllegalArgumentException();
     if (fromIndex < 0 || toIndex > size())
       throw new IndexOutOfBoundsException();
+
     return new SubList(this, fromIndex, toIndex);
   }
 
-  static class SubList extends AbstractList {
+  class AbstractListItr implements ListIterator
+  {
+    private int knownMod = modCount;
+    private int position;
+    private int lastReturned = -1;
 
+    AbstractListItr(int start_pos)
+    {
+      this.position = start_pos;
+    }
+
+    private void checkMod()
+    {
+      if (knownMod != modCount)
+	throw new ConcurrentModificationException();
+    }
+
+    public boolean hasNext()
+    {
+      checkMod();
+      return position < size();
+    }
+
+    public boolean hasPrevious()
+    {
+      checkMod();
+      return position > 0;
+    }
+
+    public Object next()
+    {
+      checkMod();
+      if (position < size())
+	{
+	  lastReturned = position++;
+	  return get(lastReturned);
+	}
+      else
+	{
+	  throw new NoSuchElementException();
+	}
+    }
+
+    public Object previous()
+    {
+      checkMod();
+      if (position > 0)
+	{
+	  lastReturned = --position;
+	  return get(lastReturned);
+	}
+      else
+	{
+	  throw new NoSuchElementException();
+	}
+    }
+
+    public int nextIndex()
+    {
+      checkMod();
+      return position;
+    }
+
+    public int previousIndex()
+    {
+      checkMod();
+      return position - 1;
+    }
+
+    public void remove()
+    {
+      checkMod();
+      if (lastReturned < 0)
+	{
+	  throw new IllegalStateException();
+	}
+      AbstractList.this.remove(lastReturned);
+      knownMod = modCount;
+      position = lastReturned;
+      lastReturned = -1;
+    }
+
+    public void set(Object o)
+    {
+      checkMod();
+      if (lastReturned < 0)
+	throw new IllegalStateException();
+      AbstractList.this.set(lastReturned, o);
+    }
+
+    public void add(Object o)
+    {
+      checkMod();
+      AbstractList.this.add(position++, o);
+      lastReturned = -1;
+      knownMod = modCount;
+    }
+  }				// AbstractList.Iterator
+
+  static class SubList extends AbstractList
+  {
     private AbstractList backingList;
     private int offset;
     private int size;
 
-    public SubList(AbstractList backing, int fromIndex, int toIndex) {
+    public SubList(AbstractList backing, int fromIndex, int toIndex)
+    {
       backingList = backing;
       upMod();
       offset = fromIndex;
       size = toIndex - fromIndex;
     }
 
-    // Note that within this class two fields called modCount are inherited -
-    // one from the superclass, and one from the outer class. 
-    // The code uses both these two fields and *no other* to provide fail-fast
-    // behaviour. For correct operation, the two fields should contain equal
-    // values. Therefore, if this.modCount != backingList.modCount, there
-    // has been a concurrent modification. This is all achieved purely by using
-    // the modCount field, precisely according to the docs of AbstractList.
-    // See the methods upMod and checkMod.
-
     /**
      * This method checks the two modCount fields to ensure that there has
      * not been a concurrent modification. It throws an exception if there
@@ -365,22 +325,23 @@ public abstract class AbstractList extends AbstractCollection implements List {
      * @exception ConcurrentModificationException if there has been a
      *   concurrent modification.
      */
-    private void checkMod() {
-      if (this.modCount != backingList.modCount) {
+    private void checkMod()
+    {
+      if (this.modCount != backingList.modCount)
 	throw new ConcurrentModificationException();
-      }
     }
-    
+
     /**
      * This method is called after every method that causes a structural
      * modification to the backing list. It updates the local modCount field
      * to match that of the backing list.
      * Note that since this method is private, it will be inlined.
      */
-    private void upMod() {
+    private void upMod()
+    {
       this.modCount = backingList.modCount;
     }
-    
+
     /**
      * This method checks that a value is between 0 and size (inclusive). If
      * it is not, an exception is thrown.
@@ -388,12 +349,12 @@ public abstract class AbstractList extends AbstractCollection implements List {
      *
      * @exception IndexOutOfBoundsException if the value is out of range.
      */
-    private void checkBoundsInclusive(int index) {
-      if (index < 0 || index > size) {
+    private void checkBoundsInclusive(int index)
+    {
+      if (index < 0 || index > size)
 	throw new IndexOutOfBoundsException();
-      }
     }
-    
+
     /**
      * This method checks that a value is between 0 (inclusive) and size
      * (exclusive). If it is not, an exception is thrown.
@@ -401,131 +362,45 @@ public abstract class AbstractList extends AbstractCollection implements List {
      *
      * @exception IndexOutOfBoundsException if the value is out of range.
      */
-    private void checkBoundsExclusive(int index) {
-      if (index < 0 || index >= size) {
+    private void checkBoundsExclusive(int index)
+    {
+      if (index < 0 || index >= size)
 	throw new IndexOutOfBoundsException();
-      }
     }
-    
-    public int size() {
+
+    public int size()
+    {
       checkMod();
       return size;
     }
-    
-    public Iterator iterator() {
-      return listIterator();
-    }
-    
-    public ListIterator listIterator(final int index) {
-      
-      checkMod();
-      checkBoundsInclusive(index);
-      
-      return new ListIterator() {
-	ListIterator i = backingList.listIterator(index + offset);
-	int position = index;
-	
-	public boolean hasNext() {
-	  checkMod();
-	  return position < size;
-	}
-	
-	public boolean hasPrevious() {
-	  checkMod();
-	  return position > 0;
-	}
-	
-	public Object next() {
-	  if (position < size) {
-	    Object o = i.next();
-	    position++;
-	    return o;
-	  } else {
-	    throw new NoSuchElementException();
-	  }
-	}
-	
-	public Object previous() {
-	  if (position > 0) {
-	    Object o = i.previous();
-	    position--;
-	    return o;
-	  } else {
-	    throw new NoSuchElementException();
-	  }
-	}
-	
-	public int nextIndex() {
-	  return offset + i.nextIndex();
-	}
-	
-	public int previousIndex() {
-	  return offset + i.previousIndex();
-	}
-
-	public void remove() {
-	  i.remove();
-	  upMod();
-	  size--;
-	  position = nextIndex();
-	}
-	
-	public void set(Object o) {
-	  i.set(o);
-	}
-	
-	public void add(Object o) {
-	  i.add(o);
-	  upMod();
-	  size++;
-	  position++;
-	}
 
-	// Here is the reason why the various modCount fields are mostly
-	// ignored in this wrapper listIterator.
-	// IF the backing listIterator is failfast, then the following holds:
-	//   Using any other method on this list will call a corresponding
-	//   method on the backing list *after* the backing listIterator
-	//   is created, which will in turn cause a ConcurrentModException
-	//   when this listIterator comes to use the backing one. So it is
-	//   implicitly failfast.
-	// If the backing listIterator is NOT failfast, then the whole of
-	//   this list isn't failfast, because the modCount field of the
-	//   backing list is not valid. It would still be *possible* to
-	//   make the iterator failfast wrt modifications of the sublist
-	//   only, but somewhat pointless when the list can be changed under
-	//   us.
-	// Either way, no explicit handling of modCount is needed.
-	// However upMod() must be called in add and remove, and size
-	// must also be updated in these two methods, since they do not go
-	// through the corresponding methods of the subList.
-
-      };
-    }
-
-    public Object set(int index, Object o) {
+    public Object set(int index, Object o)
+    {
       checkMod();
       checkBoundsExclusive(index);
       o = backingList.set(index + offset, o);
       upMod();
       return o;
     }
-    
-    public Object get(int index) {
+
+    public Object get(int index)
+    {
       checkMod();
       checkBoundsExclusive(index);
       return backingList.get(index + offset);
     }
 
-    public void add(int index, Object o) {
+    public void add(int index, Object o)
+    {
       checkMod();
       checkBoundsInclusive(index);
       backingList.add(index + offset, o);
       upMod();
       size++;
     }
-    
-    public Object remove(int index) {
+
+    public Object remove(int index)
+    {
       checkMod();
       checkBoundsExclusive(index);
       Object o = backingList.remove(index + offset);
@@ -534,18 +409,20 @@ public abstract class AbstractList extends AbstractCollection implements List {
       return o;
     }
 
-    public void removeRange(int fromIndex, int toIndex) {
+    public void removeRange(int fromIndex, int toIndex)
+    {
       checkMod();
       checkBoundsExclusive(fromIndex);
       checkBoundsInclusive(toIndex);
-      
+
       // this call will catch the toIndex < fromIndex condition
       backingList.removeRange(offset + fromIndex, offset + toIndex);
       upMod();
       size -= toIndex - fromIndex;
     }
-    
-    public boolean addAll(int index, Collection c) {
+
+    public boolean addAll(int index, Collection c)
+    {
       checkMod();
       checkBoundsInclusive(index);
       int s = backingList.size();
@@ -554,5 +431,5 @@ public abstract class AbstractList extends AbstractCollection implements List {
       size += backingList.size() - s;
       return result;
     }
-  }
+  }				// AbstractList.SubList
 }