Thread: [Jnode-svn-commits] SF.net SVN: jnode: [2897] trunk/core/src/classpath/java/java/util

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 2897
          http://jnode.svn.sourceforge.net/jnode/?rev=2897&view=rev
Author:   lsantha
Date:     2006-12-12 13:12:29 -0800 (Tue, 12 Dec 2006)

Log Message:
-----------
Migrating to Java 5 level classpath.

Added Paths:
-----------
    trunk/core/src/classpath/java/java/util/AbstractCollection.java
    trunk/core/src/classpath/java/java/util/AbstractList.java
    trunk/core/src/classpath/java/java/util/AbstractMap.java
    trunk/core/src/classpath/java/java/util/AbstractQueue.java
    trunk/core/src/classpath/java/java/util/AbstractSequentialList.java
    trunk/core/src/classpath/java/java/util/AbstractSet.java
    trunk/core/src/classpath/java/java/util/ArrayList.java
    trunk/core/src/classpath/java/java/util/Arrays.java
    trunk/core/src/classpath/java/java/util/BitSet.java
    trunk/core/src/classpath/java/java/util/Collection.java
    trunk/core/src/classpath/java/java/util/Collections.java
    trunk/core/src/classpath/java/java/util/Comparator.java
    trunk/core/src/classpath/java/java/util/Dictionary.java
    trunk/core/src/classpath/java/java/util/DuplicateFormatFlagsException.java
    trunk/core/src/classpath/java/java/util/EnumMap.java
    trunk/core/src/classpath/java/java/util/EnumSet.java
    trunk/core/src/classpath/java/java/util/Enumeration.java
    trunk/core/src/classpath/java/java/util/FormatFlagsConversionMismatchException.java
    trunk/core/src/classpath/java/java/util/Formattable.java
    trunk/core/src/classpath/java/java/util/FormattableFlags.java
    trunk/core/src/classpath/java/java/util/Formatter.java
    trunk/core/src/classpath/java/java/util/FormatterClosedException.java
    trunk/core/src/classpath/java/java/util/HashMap.java
    trunk/core/src/classpath/java/java/util/HashSet.java
    trunk/core/src/classpath/java/java/util/Hashtable.java
    trunk/core/src/classpath/java/java/util/IdentityHashMap.java
    trunk/core/src/classpath/java/java/util/IllegalFormatCodePointException.java
    trunk/core/src/classpath/java/java/util/IllegalFormatConversionException.java
    trunk/core/src/classpath/java/java/util/IllegalFormatException.java
    trunk/core/src/classpath/java/java/util/IllegalFormatFlagsException.java
    trunk/core/src/classpath/java/java/util/IllegalFormatPrecisionException.java
    trunk/core/src/classpath/java/java/util/IllegalFormatWidthException.java
    trunk/core/src/classpath/java/java/util/Iterator.java
    trunk/core/src/classpath/java/java/util/LinkedHashMap.java
    trunk/core/src/classpath/java/java/util/LinkedHashSet.java
    trunk/core/src/classpath/java/java/util/LinkedList.java
    trunk/core/src/classpath/java/java/util/List.java
    trunk/core/src/classpath/java/java/util/ListIterator.java
    trunk/core/src/classpath/java/java/util/Map.java
    trunk/core/src/classpath/java/java/util/MissingFormatArgumentException.java
    trunk/core/src/classpath/java/java/util/MissingFormatWidthException.java
    trunk/core/src/classpath/java/java/util/PriorityQueue.java
    trunk/core/src/classpath/java/java/util/Properties.java
    trunk/core/src/classpath/java/java/util/Queue.java
    trunk/core/src/classpath/java/java/util/Set.java
    trunk/core/src/classpath/java/java/util/SortedMap.java
    trunk/core/src/classpath/java/java/util/SortedSet.java
    trunk/core/src/classpath/java/java/util/Stack.java
    trunk/core/src/classpath/java/java/util/TreeMap.java
    trunk/core/src/classpath/java/java/util/TreeSet.java
    trunk/core/src/classpath/java/java/util/UnknownFormatConversionException.java
    trunk/core/src/classpath/java/java/util/UnknownFormatFlagsException.java
    trunk/core/src/classpath/java/java/util/Vector.java
    trunk/core/src/classpath/java/java/util/WeakHashMap.java

Added: trunk/core/src/classpath/java/java/util/AbstractCollection.java
===================================================================

--- trunk/core/src/classpath/java/java/util/AbstractCollection.java	                        (rev 0)
+++ trunk/core/src/classpath/java/java/util/AbstractCollection.java	2006-12-12 21:12:29 UTC (rev 2897)
@@ -0,0 +1,490 @@
+/* AbstractCollection.java -- Abstract implementation of most of Collection
+   Copyright (C) 1998, 2000, 2001, 2004, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+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.
+ * <p>
+ *
+ * The programmer should provide a no-argument constructor, and one that
+ * accepts another Collection, as recommended by the Collection interface.
+ * Unfortunately, there is no way to enforce this in Java.
+ *
+ * @author Original author unknown
+ * @author Bryce McKinlay
+ * @author Eric Blake (eb...@em...)
+ * @author Tom Tromey (tr...@re...)
+ * @author Andrew John Hughes (gnu...@me...)
+ * @see Collection
+ * @see AbstractSet
+ * @see AbstractList
+ * @since 1.2
+ * @status updated to 1.4
+ */
+public abstract class AbstractCollection<E>
+  implements Collection<E>, Iterable<E>
+{
+  /**
+   * The main constructor, for use by subclasses.
+   */
+  protected AbstractCollection()
+  {
+  }
+
+  /**
+   * 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.
+   *
+   * @return an iterator
+   */
+  public abstract Iterator<E> iterator();
+
+  /**
+   * Return the number of elements in this collection. If there are more than
+   * Integer.MAX_VALUE elements, return Integer.MAX_VALUE.
+   *
+   * @return the size
+   */
+  public abstract int size();
+
+  /**
+   * Add an object to the collection (optional operation). This implementation
+   * always throws an UnsupportedOperationException - it should be
+   * overridden if the collection is to be modifiable. If the collection
+   * does not accept duplicates, simply return false. Collections may specify
+   * limitations on what may be added.
+   *
+   * @param o the object to add
+   * @return true if the add operation caused the Collection to change
+   * @throws UnsupportedOperationException if the add operation is not
+   *         supported on this collection
+   * @throws NullPointerException if the collection does not support null
+   * @throws ClassCastException if the object is of the wrong type
+   * @throws IllegalArgumentException if some aspect of the object prevents
+   *         it from being added
+   */
+  public boolean add(E o)
+  {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Add all the elements of a given collection to this collection (optional
+   * operation). 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). The behavior is
+   * unspecified if the specified collection is modified during the iteration,
+   * including the special case of trying addAll(this) on a non-empty
+   * collection.
+   *
+   * @param c the collection to add the elements of to this collection
+   * @return true if the add operation caused the Collection to change
+   * @throws UnsupportedOperationException if the add operation is not
+   *         supported on this collection
+   * @throws NullPointerException if the specified collection is null
+   * @throws ClassCastException if the type of any element in c is
+   *         not a valid type for addition.
+   * @throws IllegalArgumentException if some aspect of any element
+   *         in c prevents it being added.
+   * @throws NullPointerException if any element in c is null and this
+   *         collection doesn't allow null values.
+   * @see #add(Object)
+   */
+  public boolean addAll(Collection<? extends E> c)
+  {
+    Iterator<? extends E> itr = c.iterator();
+    boolean modified = false;
+    int pos = c.size();
+    while (--pos >= 0)
+      modified |= add(itr.next());
+    return modified;
+  }
+
+  /**
+   * Remove all elements from the collection (optional operation). 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.
+   *
+   * @throws UnsupportedOperationException if the Iterator returned by
+   *         iterator does not provide an implementation of remove
+   * @see Iterator#remove()
+   */
+  public void clear()
+  {
+    Iterator<E> itr = iterator();
+    int pos = size();
+    while (--pos >= 0)
+      {
+        itr.next();
+        itr.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<E> itr = iterator();
+    int pos = size();
+    while (--pos >= 0)
+      if (equals(o, itr.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
+   * @throws NullPointerException if the given collection is null
+   * @see #contains(Object)
+   */
+  public boolean containsAll(Collection<?> c)
+  {
+    Iterator<?> itr = c.iterator();
+    int pos = c.size();
+    while (--pos >= 0)
+      if (!contains(itr.next()))
+        return false;
+    return true;
+  }
+
+  /**
+   * Test whether this collection is empty. This implementation returns
+   * size() == 0.
+   *
+   * @return true if this collection is empty.
+   * @see #size()
+   */
+  public boolean isEmpty()
+  {
+    return size() == 0;
+  }
+
+  /**
+   * Remove a single instance of an object from this collection (optional
+   * operation). That is, remove one element e such that
+   * <code>(o == null ? e == null : o.equals(e))</code>, 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.
+   * @throws UnsupportedOperationException if this collection's Iterator
+   *         does not support the remove method
+   * @see Iterator#remove()
+   */
+  public boolean remove(Object o)
+  {
+    Iterator<E> itr = iterator();
+    int pos = size();
+    while (--pos >= 0)
+      if (equals(o, itr.next()))
+        {
+          itr.remove();
+          return true;
+        }
+    return false;
+  }
+
+  /**
+   * Remove from this collection all its elements that are contained in a given
+   * collection (optional operation). 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
+   * @throws UnsupportedOperationException if this collection's Iterator
+   *         does not support the remove method
+   * @throws NullPointerException if the collection, c, is null.
+   * @see Iterator#remove()
+   */
+  public boolean removeAll(Collection<?> c)
+  {
+    return removeAllInternal(c);
+  }
+
+  /**
+   * Remove from this collection all its elements that are contained in a given
+   * collection (optional operation). 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). This method is necessary for ArrayList,
+   * which cannot publicly override removeAll but can optimize this call.
+   *
+   * @param c the collection to remove the elements of
+   * @return true if the remove operation caused the Collection to change
+   * @throws UnsupportedOperationException if this collection's Iterator
+   *         does not support the remove method
+   * @throws NullPointerException if the collection, c, is null.
+   * @see Iterator#remove()
+   */
+  // Package visible for use throughout java.util.
+  boolean removeAllInternal(Collection<?> c)
+  {
+    Iterator<E> itr = iterator();
+    boolean modified = false;
+    int pos = size();
+    while (--pos >= 0)
+      if (c.contains(itr.next()))
+        {
+          itr.remove();
+          modified = true;
+        }
+    return modified;
+  }
+
+  /**
+   * Remove from this collection all its elements that are not contained in a
+   * given collection (optional operation). 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
+   * @throws UnsupportedOperationException if this collection's Iterator
+   *         does not support the remove method
+   * @throws NullPointerException if the collection, c, is null.
+   * @see Iterator#remove()
+   */
+  public boolean retainAll(Collection<?> c)
+  {
+    return retainAllInternal(c);
+  }
+
+  /**
+   * Remove from this collection all its elements that are not contained in a
+   * given collection (optional operation). 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). This method is necessary for
+   * ArrayList, which cannot publicly override retainAll but can optimize
+   * this call.
+   *
+   * @param c the collection to retain the elements of
+   * @return true if the remove operation caused the Collection to change
+   * @throws UnsupportedOperationException if this collection's Iterator
+   *         does not support the remove method
+   * @throws NullPointerException if the collection, c, is null.
+   * @see Iterator#remove()
+   */
+  // Package visible for use throughout java.util.
+  boolean retainAllInternal(Collection<?> c)
+  {
+    Iterator<E> itr = iterator();
+    boolean modified = false;
+    int pos = size();
+    while (--pos >= 0)
+      if (!c.contains(itr.next()))
+        {
+          itr.remove();
+          modified = true;
+        }
+    return modified;
+  }
+
+  /**
+   * 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. The returned array is safe, and is not backed
+   * by the collection.
+   *
+   * @return an array containing the elements of this collection
+   */
+  public Object[] toArray()
+  {
+    Iterator<E> itr = iterator();
+    int size = size();
+    Object[] a = new Object[size];
+    for (int pos = 0; pos < size; pos++)
+      a[pos] = itr.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.
+   * The returned array is safe; it is not backed by the collection. Note that
+   * null may not mark the last element, if the collection allows null
+   * elements.
+   *
+   * @param a the array to copy into, or of the correct run-time type
+   * @return the array that was produced
+   * @throws NullPointerException if the given array is null
+   * @throws ArrayStoreException if the type of the array precludes holding
+   *         one of the elements of the Collection
+   */
+  public <T> T[] toArray(T[] a)
+  {
+    int size = size();
+    if (a.length < size)
+      a = (T[]) Array.newInstance(a.getClass().getComponentType(),
+                                       size);
+    else if (a.length > size)
+      a[size] = null;
+
+    Iterator<E> itr = iterator();
+    for (int pos = 0; pos < size; pos++)
+      {
+	try
+	  {
+	    a[pos] = (T) (itr.next());
+	  }
+	catch (ClassCastException exception)
+	  {
+	    throw new ArrayStoreException("The element is of the wrong type "+
+					  "for storing in this array.");
+	  }
+      }
+    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. "<this>" is inserted when the collection
+   * contains itself (only works for direct containment, not for collections
+   * inside collections).
+   *
+   * @return a String representation of the Collection
+   */
+  public String toString()
+  {
+    Iterator itr = iterator();
+    StringBuffer r = new StringBuffer("[");
+    boolean hasNext = itr.hasNext();
+    while (hasNext)
+      {
+        Object o = itr.next();
+	if (o == this)
+	  r.append("<this>");
+	else
+	  r.append(o);
+	hasNext = itr.hasNext();
+        if (hasNext)
+          r.append(", ");
+      }
+    r.append("]");
+    return r.toString();
+  }
+
+  /**
+   * Compare two objects according to Collection semantics.
+   *
+   * @param o1 the first object
+   * @param o2 the second object
+   * @return o1 == null ? o2 == null : o1.equals(o2)
+   */
+  // Package visible for use throughout java.util.
+  // It may be inlined since it is final.
+  static final boolean equals(Object o1, Object o2)
+  {
+    return o1 == null ? o2 == null : o1.equals(o2);
+  }
+
+  /**
+   * Hash an object according to Collection semantics.
+   *
+   * @param o the object to hash
+   * @return o1 == null ? 0 : o1.hashCode()
+   */
+  // Package visible for use throughout java.util.
+  // It may be inlined since it is final.
+  static final int hashCode(Object o)
+  {
+    return o == null ? 0 : o.hashCode();
+  }
+}

Added: trunk/core/src/classpath/java/java/util/AbstractList.java
===================================================================
--- trunk/core/src/classpath/java/java/util/AbstractList.java	                        (rev 0)
+++ trunk/core/src/classpath/java/java/util/AbstractList.java	2006-12-12 21:12:29 UTC (rev 2897)
@@ -0,0 +1,1204 @@
+/* AbstractList.java -- Abstract implementation of most of List
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005
+   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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+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. If
+ * the list is sequential (such as a linked list), use AbstractSequentialList.
+ * 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.
+ * <p>
+ *
+ * As recommended by Collection and List, the subclass should provide at
+ * least a no-argument and a Collection constructor. This class is not
+ * synchronized.
+ *
+ * @author Original author unknown
+ * @author Bryce McKinlay
+ * @author Eric Blake (eb...@em...)
+ * @see Collection
+ * @see List
+ * @see AbstractSequentialList
+ * @see AbstractCollection
+ * @see ListIterator
+ * @since 1.2
+ * @status updated to 1.4
+ */
+public abstract class AbstractList<E>
+  extends AbstractCollection<E>
+  implements List<E>
+{
+  /**
+   * A count of the number of structural modifications that have been made to
+   * the list (that is, insertions and removals). Structural modifications
+   * are ones which change the list size or affect how iterations would
+   * behave. This field is available for use by Iterator and ListIterator,
+   * in order to throw a {@link ConcurrentModificationException} in response
+   * to the next operation on the iterator. This <i>fail-fast</i> behavior
+   * saves the user from many subtle bugs otherwise possible from concurrent
+   * modification during iteration.
+   * <p>
+   *
+   * To make lists fail-fast, increment this field by just 1 in the
+   * <code>add(int, Object)</code> and <code>remove(int)</code> methods.
+   * Otherwise, this field may be ignored.
+   */
+  protected transient int modCount;
+
+  /**
+   * The main constructor, for use by subclasses.
+   */
+  protected AbstractList()
+  {
+  }
+
+  /**
+   * Returns the elements at the specified position in the list.
+   *
+   * @param index the element to return
+   * @return the element at that position
+   * @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
+   */
+  public abstract E get(int index);
+
+  /**
+   * Insert an element into the list at a given position (optional operation).
+   * This shifts all existing elements from that position to the end one
+   * index to the right.  This version of add has no return, since it is
+   * assumed to always succeed if there is no exception. This implementation
+   * always throws UnsupportedOperationException, and must be overridden to
+   * make a modifiable List.  If you want fail-fast iterators, be sure to
+   * increment modCount when overriding this.
+   *
+   * @param index the location to insert the item
+   * @param o the object to insert
+   * @throws UnsupportedOperationException if this list does not support the
+   *         add operation
+   * @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
+   * @throws ClassCastException if o cannot be added to this list due to its
+   *         type
+   * @throws IllegalArgumentException if o cannot be added to this list for
+   *         some other reason
+   * @see #modCount
+   */
+  public void add(int index, E o)
+  {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Add an element to the end of the list (optional operation). If the list
+   * imposes restraints on what can be inserted, such as no null elements,
+   * this should be documented. This implementation calls
+   * <code>add(size(), o);</code>, and will fail if that version does.
+   *
+   * @param o the object to add
+   * @return true, as defined by Collection for a modified list
+   * @throws UnsupportedOperationException if this list does not support the
+   *         add operation
+   * @throws ClassCastException if o cannot be added to this list due to its
+   *         type
+   * @throws IllegalArgumentException if o cannot be added to this list for
+   *         some other reason
+   * @see #add(int, Object)
+   */
+  public boolean add(E o)
+  {
+    add(size(), o);
+    return true;
+  }
+
+  /**
+   * Insert the contents of a collection into the list at a given position
+   * (optional operation). Shift all elements at that position to the right
+   * by the number of elements inserted. This operation is undefined if
+   * this list is modified during the operation (for example, if you try
+   * to insert a list into itself). This implementation uses the iterator of
+   * the collection, repeatedly calling add(int, Object); this will f...
 
[truncated message content]

Thread: [Jnode-svn-commits] SF.net SVN: jnode: [2897] trunk/core/src/classpath/java/java/util

jnode-svn-commits