Jumbo patch:

* Imported beans and serialization
* Updated IA-64 port
* Miscellaneous bug fixes

From-SVN: r34028

libjava/java/util/AbstractCollection.java

@@ -0,0 +1,339 @@
+/* AbstractCollection.java -- Abstract implementation of most of Collection
+   Copyright (C) 1998 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.lang.reflect.Array;
+
+/**
+ * A basic implementation of most of the methods in the Collection interface to
+ * make it easier to create a collection. To create an unmodifiable Collection,
+ * just subclass AbstractCollection and provide implementations of the
+ * iterator() and size() methods. The Iterator returned by iterator() need only
+ * provide implementations of hasNext() and next() (that is, it may throw an
+ * UnsupportedOperationException if remove() is called). To create a modifiable
+ * Collection, you must in addition provide an implementation of the
+ * add(Object) method and the Iterator returned by iterator() must provide an
+ * implementation of remove(). Other methods should be overridden if the
+ * backing data structure allows for a more efficient implementation. The
+ * precise implementation used by AbstractCollection is documented, so that
+ * subclasses can tell which methods could be implemented more efficiently.
+ */
+public abstract class AbstractCollection implements Collection {
+
+  /**
+   * Return an Iterator over this collection. The iterator must provide the
+   * hasNext and next methods and should in addition provide remove if the
+   * collection is modifiable.
+   */
+  public abstract Iterator iterator();
+
+  /**
+   * Return the number of elements in this collection.
+   */
+  public abstract int size();
+
+  /**
+   * Add an object to the collection. This implementation always throws an
+   * UnsupportedOperationException - it should be overridden if the collection
+   * is to be modifiable.
+   *
+   * @param o the object to add
+   * @return true if the add operation caused the Collection to change
+   * @exception UnsupportedOperationException if the add operation is not
+   *   supported on this collection
+   */
+  public boolean add(Object o) {
+    throw new java.lang.UnsupportedOperationException();
+  }
+
+  /**
+   * Add all the elements of a given collection to this collection. This
+   * implementation obtains an Iterator over the given collection and iterates
+   * over it, adding each element with the add(Object) method (thus this method
+   * will fail with an UnsupportedOperationException if the add method does).
+   *
+   * @param c the collection to add the elements of to this collection
+   * @return true if the add operation caused the Collection to change
+   * @exception UnsupportedOperationException if the add operation is not
+   *   supported on this collection
+   */
+  public boolean addAll(Collection c) {
+    Iterator i = c.iterator();
+    boolean modified = false;
+    while (i.hasNext()) {
+      modified |= add(i.next());
+    }
+    return modified;
+  }
+
+  /**
+   * Remove all elements from the collection. This implementation obtains an
+   * iterator over the collection and calls next and remove on it repeatedly
+   * (thus this method will fail with an UnsupportedOperationException if the
+   * Iterator's remove method does) until there are no more elements to remove.
+   * Many implementations will have a faster way of doing this.
+   *
+   * @exception UnsupportedOperationException if the Iterator returned by
+   *   iterator does not provide an implementation of remove
+   */
+  public void clear() {
+    Iterator i = iterator();
+    while (i.hasNext()) {
+      i.next();
+      i.remove();
+    }
+  }
+
+  /**
+   * Test whether this collection contains a given object. That is, if the
+   * collection has an element e such that (o == null ? e == null :
+   * o.equals(e)). This implementation obtains an iterator over the collection
+   * and iterates over it, testing each element for equality with the given
+   * object. If it is equal, true is returned. Otherwise false is returned when
+   * the end of the collection is reached.
+   *
+   * @param o the object to remove from this collection
+   * @return true if this collection contains an object equal to o
+   */
+  public boolean contains(Object o) {
+    Iterator i = iterator();
+
+    // This looks crazily inefficient, but it takes the test o==null outside
+    // the loop, saving time, and also saves needing to store the result of
+    // i.next() each time.
+    if (o == null) {
+      while (i.hasNext()) {
+        if (i.next() == null) {
+          return true;
+        }
+      }
+    } else {
+      while (i.hasNext()) {
+        if (o.equals(i.next())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Tests whether this collection contains all the elements in a given
+   * collection. This implementation iterates over the given collection,
+   * testing whether each element is contained in this collection. If any one
+   * is not, false is returned. Otherwise true is returned.
+   *
+   * @param c the collection to test against
+   * @return true if this collection contains all the elements in the given
+   *   collection
+   */
+  public boolean containsAll(Collection c) {
+    Iterator i = c.iterator();
+    while (i.hasNext()) {
+      if (!contains(i.next())) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Test whether this collection is empty. This implementation returns
+   * size() == 0.
+   *
+   * @return true if this collection is empty.
+   */
+  public boolean isEmpty() {
+    return size() == 0;
+  }
+
+  /**
+   * Remove a single instance of an object from this collection. That is,
+   * remove one element e such that (o == null ? e == null : o.equals(e)), if
+   * such an element exists. This implementation obtains an iterator over the
+   * collection and iterates over it, testing each element for equality with
+   * the given object. If it is equal, it is removed by the iterator's remove
+   * method (thus this method will fail with an UnsupportedOperationException
+   * if the Iterator's remove method does). After the first element has been
+   * removed, true is returned; if the end of the collection is reached, false
+   * is returned.
+   *
+   * @param o the object to remove from this collection
+   * @return true if the remove operation caused the Collection to change, or
+   *   equivalently if the collection did contain o.
+   * @exception UnsupportedOperationException if this collection's Iterator
+   *   does not support the remove method
+   */
+  public boolean remove(Object o) {
+    Iterator i = iterator();
+
+    // This looks crazily inefficient, but it takes the test o==null outside
+    // the loop, saving time, and also saves needing to store the result of
+    // i.next() each time.
+    if (o == null) {
+      while (i.hasNext()) {
+        if (i.next() == null) {
+          i.remove();
+	  return true;
+        }
+      }
+    } else {
+      while (i.hasNext()) {
+        if (o.equals(i.next())) {
+          i.remove();
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Remove from this collection all its elements that are contained in a given
+   * collection. This implementation iterates over this collection, and for
+   * each element tests if it is contained in the given collection. If so, it
+   * is removed by the Iterator's remove method (thus this method will fail
+   * with an UnsupportedOperationException if the Iterator's remove method
+   * does).
+   *
+   * @param c the collection to remove the elements of
+   * @return true if the remove operation caused the Collection to change
+   * @exception UnsupportedOperationException if this collection's Iterator
+   *   does not support the remove method
+   */
+  public boolean removeAll(Collection c) {
+    Iterator i = iterator();
+    boolean changed = false;
+    while (i.hasNext()) {
+      if (c.contains(i.next())) {
+        i.remove();
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
+  /**
+   * Remove from this collection all its elements that are not contained in a
+   * given collection. This implementation iterates over this collection, and
+   * for each element tests if it is contained in the given collection. If not,
+   * it is removed by the Iterator's remove method (thus this method will fail
+   * with an UnsupportedOperationException if the Iterator's remove method
+   * does).
+   *
+   * @param c the collection to retain the elements of
+   * @return true if the remove operation caused the Collection to change
+   * @exception UnsupportedOperationException if this collection's Iterator
+   *   does not support the remove method
+   */
+  public boolean retainAll(Collection c) {
+    Iterator i = iterator();
+    boolean changed = false;
+    while (i.hasNext()) {
+      if (!c.contains(i.next())) {
+        i.remove();
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
+  /**
+   * Return an array containing the elements of this collection. This
+   * implementation creates an Object array of size size() and then iterates
+   * over the collection, setting each element of the array from the value
+   * returned by the iterator.
+   *
+   * @return an array containing the elements of this collection
+   */
+  public Object[] toArray() {
+    Object[] a = new Object[size()];
+    Iterator i = iterator();
+    for (int pos = 0; pos < a.length; pos++) {
+      a[pos] = i.next();
+    }
+    return a;
+  }
+
+  /**
+   * Copy the collection into a given array if it will fit, or into a
+   * dynamically created array of the same run-time type as the given array if
+   * not. If there is space remaining in the array, the first element after the
+   * end of the collection is set to null (this is only useful if the
+   * collection is known to contain no null elements, however). This
+   * implementation first tests whether the given array is large enough to hold
+   * all the elements of the collection. If not, the reflection API is used to
+   * allocate a new array of the same run-time type. Next an iterator is
+   * obtained over the collection and the elements are placed in the array as
+   * they are returned by the iterator. Finally the first spare element, if
+   * any, of the array is set to null, and the created array is returned.
+   *
+   * @param a the array to copy into, or of the correct run-time type
+   * @return the array that was produced
+   * @exception ClassCastException if the type of the array precludes holding
+   *   one of the elements of the Collection
+   */
+  public Object[] toArray(Object[] a) {
+    final int n = size();
+    if (a.length < n) {
+      a = (Object[])Array.newInstance(a.getClass().getComponentType(), n);
+    }
+    Iterator i = iterator();
+    for (int pos = 0; pos < n; pos++) {
+      a[pos] = i.next();
+    }
+    if (a.length > n) {
+      a[n] = null;
+    }
+    return a;
+  }
+
+  /**
+   * Creates a String representation of the Collection. The string returned is
+   * of the form "[a, b, ...]" where a and b etc are the results of calling
+   * toString on the elements of the collection. This implementation obtains an
+   * Iterator over the Collection and adds each element to a StringBuffer as it
+   * is returned by the iterator.
+   *
+   * @return a String representation of the Collection
+   */
+  public String toString() {
+    StringBuffer s = new StringBuffer();
+    s.append('[');
+    Iterator i = iterator();
+    boolean more = i.hasNext();
+    while(more) {
+      s.append(i.next());
+      if (more = i.hasNext()) {
+        s.append(", ");
+      }
+    }
+    s.append(']');
+    return s.toString();
+  }
+}

libjava/java/util/AbstractList.java

@@ -0,0 +1,558 @@
+/* AbstractList.java -- Abstract implementation of most of List
+   Copyright (C) 1998, 1999, 2000 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. */
+
+
+// TO DO:
+// ~ Doc comments for almost everything.
+// ~ Better general commenting
+
+package java.util;
+
+/**
+ * A basic implementation of most of the methods in the List interface to make
+ * it easier to create a List based on a random-access data structure. To
+ * create an unmodifiable list, it is only necessary to override the size() and
+ * get(int) methods (this contrasts with all other abstract collection classes
+ * which require an iterator to be provided). To make the list modifiable, the
+ * set(int, Object)  method should also be overridden, and to make the list
+ * resizable, the add(int, Object) and remove(int) methods should be overridden
+ * too. Other methods should be overridden if the backing data structure allows
+ * for a more efficient implementation. The precise implementation used by
+ * AbstractList is documented, so that subclasses can tell which methods could
+ * be implemented more efficiently.
+ */
+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).
+   */
+  protected transient int modCount = 0;
+
+  public abstract Object get(int index);
+
+  public void add(int index, Object o) {
+    throw new UnsupportedOperationException();
+  }
+
+  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 void clear() {
+    removeRange(0, size());
+  }
+
+  public boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    } else 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;
+      }
+    }
+  }
+
+  public int hashCode() {
+    int hashCode = 1;
+    Iterator i = iterator();
+    while (i.hasNext()) {
+      Object obj = i.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++;
+      }
+    }
+    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 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;
+        }
+      }
+    }
+    return -1;
+  }
+
+  public ListIterator listIterator() {
+    return listIterator(0);
+  }
+
+  public ListIterator listIterator(final 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;
+      }
+    };
+  }
+
+  public Object remove(int index) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Remove a subsection of the list. This is called by the clear and
+   * removeRange methods of the class which implements subList, which are
+   * difficult for subclasses to override directly. Therefore, this method
+   * should be overridden instead by the more efficient implementation, if one
+   * exists.
+   * <p>
+   * This implementation first checks for illegal or out of range arguments. It
+   * then obtains a ListIterator over the list using listIterator(fromIndex).
+   * It then calls next() and remove() on this iterator repeatedly, toIndex -
+   * fromIndex times.
+   *
+   * @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();
+      }
+    }
+  }
+
+  public Object set(int index, Object o) {
+    throw new UnsupportedOperationException();
+  }
+
+  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 {
+
+    private AbstractList backingList;
+    private int offset;
+    private int size;
+
+    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
+     * has been, and otherwise returns normally.
+     * Note that since this method is private, it will be inlined.
+     *
+     * @exception ConcurrentModificationException if there has been a
+     *   concurrent modification.
+     */
+    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() {
+      this.modCount = backingList.modCount;
+    }
+    
+    /**
+     * This method checks that a value is between 0 and size (inclusive). If
+     * it is not, an exception is thrown.
+     * Note that since this method is private, it will be inlined.
+     *
+     * @exception IndexOutOfBoundsException if the value is out of range.
+     */
+    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.
+     * Note that since this method is private, it will be inlined.
+     *
+     * @exception IndexOutOfBoundsException if the value is out of range.
+     */
+    private void checkBoundsExclusive(int index) {
+      if (index < 0 || index >= size) {
+	throw new IndexOutOfBoundsException();
+      }
+    }
+    
+    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) {
+      checkMod();
+      checkBoundsExclusive(index);
+      o = backingList.set(index + offset, o);
+      upMod();
+      return o;
+    }
+    
+    public Object get(int index) {
+      checkMod();
+      checkBoundsExclusive(index);
+      return backingList.get(index + offset);
+    }
+
+    public void add(int index, Object o) {
+      checkMod();
+      checkBoundsInclusive(index);
+      backingList.add(index + offset, o);
+      upMod();
+      size++;
+    }
+    
+    public Object remove(int index) {
+      checkMod();
+      checkBoundsExclusive(index);
+      Object o = backingList.remove(index + offset);
+      upMod();
+      size--;
+      return o;
+    }
+
+    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) {
+      checkMod();
+      checkBoundsInclusive(index);
+      int s = backingList.size();
+      boolean result = backingList.addAll(offset + index, c);
+      upMod();
+      size += backingList.size() - s;
+      return result;
+    }
+  }
+}