luni/src/main/java/java/util/AbstractList.java - platform/libcore2 - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package java.util;

 /**
  * {@code AbstractList} is an abstract implementation of the {@code List} interface, optimized
  * for a backing store which supports random access. This implementation does
  * not support adding or replacing. A subclass must implement the abstract
  * methods {@code get()} and {@code size()}, and to create a
  * modifiable {@code List} it's necessary to override the {@code add()} method that
  * currently throws an {@code UnsupportedOperationException}.
  *
  * @since 1.2
  */
 public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

     /**
      * A counter for changes to the list.
      */
     protected transient int modCount;

     private class SimpleListIterator implements Iterator<E> {
         int pos = -1;

         int expectedModCount;

         int lastPosition = -1;

         SimpleListIterator() {
             expectedModCount = modCount;
         }

         public boolean hasNext() {
             return pos + 1 < size();
         }

         public E next() {
             if (expectedModCount == modCount) {
                 try {
                     E result = get(pos + 1);
                     lastPosition = ++pos;
                     return result;
                 } catch (IndexOutOfBoundsException e) {
                     throw new NoSuchElementException();
                 }
             }
             throw new ConcurrentModificationException();
         }

         public void remove() {
             if (this.lastPosition == -1) {
                 throw new IllegalStateException();
             }

             if (expectedModCount != modCount) {
                 throw new ConcurrentModificationException();
             }

             try {
                 AbstractList.this.remove(lastPosition);
             } catch (IndexOutOfBoundsException e) {
                 throw new ConcurrentModificationException();
             }

             expectedModCount = modCount;
             if (pos == lastPosition) {
                 pos--;
             }
             lastPosition = -1;
         }
     }

     private final class FullListIterator extends SimpleListIterator implements ListIterator<E> {
         FullListIterator(int start) {
             if (start >= 0 && start <= size()) {
                 pos = start - 1;
             } else {
                 throw new IndexOutOfBoundsException();
             }
         }

         public void add(E object) {
             if (expectedModCount == modCount) {
                 try {
                     AbstractList.this.add(pos + 1, object);
                 } catch (IndexOutOfBoundsException e) {
                     throw new NoSuchElementException();
                 }
                 pos++;
                 lastPosition = -1;
                 if (modCount != expectedModCount) {
                     expectedModCount = modCount;
                 }
             } else {
                 throw new ConcurrentModificationException();
             }
         }

         public boolean hasPrevious() {
             return pos >= 0;
         }

         public int nextIndex() {
             return pos + 1;
         }

         public E previous() {
             if (expectedModCount == modCount) {
                 try {
                     E result = get(pos);
                     lastPosition = pos;
                     pos--;
                     return result;
                 } catch (IndexOutOfBoundsException e) {
                     throw new NoSuchElementException();
                 }
             }
             throw new ConcurrentModificationException();
         }

         public int previousIndex() {
             return pos;
         }

         public void set(E object) {
             if (expectedModCount == modCount) {
                 try {
                     AbstractList.this.set(lastPosition, object);
                 } catch (IndexOutOfBoundsException e) {
                     throw new IllegalStateException();
                 }
             } else {
                 throw new ConcurrentModificationException();
             }
         }
     }

     private static final class SubAbstractListRandomAccess<E> extends
             SubAbstractList<E> implements RandomAccess {
         SubAbstractListRandomAccess(AbstractList<E> list, int start, int end) {
             super(list, start, end);
         }
     }

     private static class SubAbstractList<E> extends AbstractList<E> {
         private final AbstractList<E> fullList;

         private int offset;

         private int size;

         private static final class SubAbstractListIterator<E> implements
                 ListIterator<E> {
             private final SubAbstractList<E> subList;

             private final ListIterator<E> iterator;

             private int start;

             private int end;

             SubAbstractListIterator(ListIterator<E> it,
                     SubAbstractList<E> list, int offset, int length) {
                 iterator = it;
                 subList = list;
                 start = offset;
                 end = start + length;
             }

             public void add(E object) {
                 iterator.add(object);
                 subList.sizeChanged(true);
                 end++;
             }

             public boolean hasNext() {
                 return iterator.nextIndex() < end;
             }

             public boolean hasPrevious() {
                 return iterator.previousIndex() >= start;
             }

             public E next() {
                 if (iterator.nextIndex() < end) {
                     return iterator.next();
                 }
                 throw new NoSuchElementException();
             }

             public int nextIndex() {
                 return iterator.nextIndex() - start;
             }

             public E previous() {
                 if (iterator.previousIndex() >= start) {
                     return iterator.previous();
                 }
                 throw new NoSuchElementException();
             }

             public int previousIndex() {
                 int previous = iterator.previousIndex();
                 if (previous >= start) {
                     return previous - start;
                 }
                 return -1;
             }

             public void remove() {
                 iterator.remove();
                 subList.sizeChanged(false);
                 end--;
             }

             public void set(E object) {
                 iterator.set(object);
             }
         }

         SubAbstractList(AbstractList<E> list, int start, int end) {
             fullList = list;
             modCount = fullList.modCount;
             offset = start;
             size = end - start;
         }

         @Override
         public void add(int location, E object) {
             if (modCount == fullList.modCount) {
                 if (location >= 0 && location <= size) {
                     fullList.add(location + offset, object);
                     size++;
                     modCount = fullList.modCount;
                 } else {
                     throw new IndexOutOfBoundsException();
                 }
             } else {
                 throw new ConcurrentModificationException();
             }
         }

         @Override
         public boolean addAll(int location, Collection<? extends E> collection) {
             if (modCount == fullList.modCount) {
                 if (location >= 0 && location <= size) {
                     boolean result = fullList.addAll(location + offset,
                             collection);
                     if (result) {
                         size += collection.size();
                         modCount = fullList.modCount;
                     }
                     return result;
                 }
                 throw new IndexOutOfBoundsException();
             }
             throw new ConcurrentModificationException();
         }

         @Override
         public boolean addAll(Collection<? extends E> collection) {
             if (modCount == fullList.modCount) {
                 boolean result = fullList.addAll(offset + size, collection);
                 if (result) {
                     size += collection.size();
                     modCount = fullList.modCount;
                 }
                 return result;
             }
             throw new ConcurrentModificationException();
         }

         @Override
         public E get(int location) {
             if (modCount == fullList.modCount) {
                 if (location >= 0 && location < size) {
                     return fullList.get(location + offset);
                 }
                 throw new IndexOutOfBoundsException();
             }
             throw new ConcurrentModificationException();
         }

         @Override
         public Iterator<E> iterator() {
             return listIterator(0);
         }

         @Override
         public ListIterator<E> listIterator(int location) {
             if (modCount == fullList.modCount) {
                 if (location >= 0 && location <= size) {
                     return new SubAbstractListIterator<E>(fullList
                             .listIterator(location + offset), this, offset,
                             size);
                 }
                 throw new IndexOutOfBoundsException();
             }
             throw new ConcurrentModificationException();
         }

         @Override
         public E remove(int location) {
             if (modCount == fullList.modCount) {
                 if (location >= 0 && location < size) {
                     E result = fullList.remove(location + offset);
                     size--;
                     modCount = fullList.modCount;
                     return result;
                 }
                 throw new IndexOutOfBoundsException();
             }
             throw new ConcurrentModificationException();
         }

         @Override
         protected void removeRange(int start, int end) {
             if (start != end) {
                 if (modCount == fullList.modCount) {
                     fullList.removeRange(start + offset, end + offset);
                     size -= end - start;
                     modCount = fullList.modCount;
                 } else {
                     throw new ConcurrentModificationException();
                 }
             }
         }

         @Override
         public E set(int location, E object) {
             if (modCount == fullList.modCount) {
                 if (location >= 0 && location < size) {
                     return fullList.set(location + offset, object);
                 }
                 throw new IndexOutOfBoundsException();
             }
             throw new ConcurrentModificationException();
         }

         @Override
         public int size() {
             if (modCount == fullList.modCount) {
                 return size;
             }
             throw new ConcurrentModificationException();
         }

         void sizeChanged(boolean increment) {
             if (increment) {
                 size++;
             } else {
                 size--;
             }
             modCount = fullList.modCount;
         }
     }

     /**
      * Constructs a new instance of this AbstractList.
      */
     protected AbstractList() {
     }

     /**
      * Inserts the specified object into this List at the specified location.
      * The object is inserted before any previous element at the specified
      * location. If the location is equal to the size of this List, the object
      * is added at the end.
      * <p>
      * Concrete implementations that would like to support the add functionality
      * must override this method.
      *
      * @param location
      *            the index at which to insert.
      * @param object
      *            the object to add.
      *
      * @throws UnsupportedOperationException
      *                if adding to this List is not supported.
      * @throws ClassCastException
      *                if the class of the object is inappropriate for this
      *                List
      * @throws IllegalArgumentException
      *                if the object cannot be added to this List
      * @throws IndexOutOfBoundsException
      *                if {@code location < 0 || location > size()}
      */
     public void add(int location, E object) {
         throw new UnsupportedOperationException();
     }

     /**
      * Adds the specified object at the end of this List.
      *
      *
      * @param object
      *            the object to add
      * @return true
      *
      * @throws UnsupportedOperationException
      *                if adding to this List is not supported
      * @throws ClassCastException
      *                if the class of the object is inappropriate for this
      *                List
      * @throws IllegalArgumentException
      *                if the object cannot be added to this List
      */
     @Override
     public boolean add(E object) {
         add(size(), object);
         return true;
     }

     /**
      * Inserts the objects in the specified Collection at the specified location
      * in this List. The objects are added in the order they are returned from
      * the collection's iterator.
      *
      * @param location
      *            the index at which to insert.
      * @param collection
      *            the Collection of objects
      * @return {@code true} if this List is modified, {@code false} otherwise.
      * @throws UnsupportedOperationException
      *             if adding to this list is not supported.
      * @throws ClassCastException
      *             if the class of an object is inappropriate for this list.
      * @throws IllegalArgumentException
      *             if an object cannot be added to this list.
      * @throws IndexOutOfBoundsException
      *             if {@code location < 0 || location > size()}
      */
     public boolean addAll(int location, Collection<? extends E> collection) {
         Iterator<? extends E> it = collection.iterator();
         while (it.hasNext()) {
             add(location++, it.next());
         }
         return !collection.isEmpty();
     }

     /**
      * Removes all elements from this list, leaving it empty.
      *
      * @throws UnsupportedOperationException
      *             if removing from this list is not supported.
      * @see List#isEmpty
      * @see List#size
      */
     @Override
     public void clear() {
         removeRange(0, size());
     }

     /**
      * Compares the specified object to this list and return true if they are
      * equal. Two lists are equal when they both contain the same objects in the
      * same order.
      *
      * @param object
      *            the object to compare to this object.
      * @return {@code true} if the specified object is equal to this list,
      *         {@code false} otherwise.
      * @see #hashCode
      */
     @Override
     public boolean equals(Object object) {
         if (this == object) {
             return true;
         }
         if (object instanceof List) {
             List<?> list = (List<?>) object;
             if (list.size() != size()) {
                 return false;
             }

             Iterator<?> it1 = iterator(), it2 = list.iterator();
             while (it1.hasNext()) {
                 Object e1 = it1.next(), e2 = it2.next();
                 if (!(e1 == null ? e2 == null : e1.equals(e2))) {
                     return false;
                 }
             }
             return true;
         }
         return false;
     }

     /**
      * Returns the element at the specified location in this list.
      *
      * @param location
      *            the index of the element to return.
      * @return the element at the specified index.
      * @throws IndexOutOfBoundsException
      *             if {@code location < 0 || location >= size()}
      */
     public abstract E get(int location);

     /**
      * Returns the hash code of this list. The hash code is calculated by taking
      * each element's hashcode into account.
      *
      * @return the hash code.
      * @see #equals
      * @see List#hashCode()
      */
     @Override
     public int hashCode() {
         int result = 1;
         Iterator<?> it = iterator();
         while (it.hasNext()) {
             Object object = it.next();
             result = (31 * result) + (object == null ? 0 : object.hashCode());
         }
         return result;
     }

     /**
      * Searches this list for the specified object and returns the index of the
      * first occurrence.
      *
      * @param object
      *            the object to search for.
      * @return the index of the first occurrence of the object, or -1 if it was
      *         not found.
      */
     public int indexOf(Object object) {
         ListIterator<?> it = listIterator();
         if (object != null) {
             while (it.hasNext()) {
                 if (object.equals(it.next())) {
                     return it.previousIndex();
                 }
             }
         } else {
             while (it.hasNext()) {
                 if (it.next() == null) {
                     return it.previousIndex();
                 }
             }
         }
         return -1;
     }

     /**
      * Returns an iterator on the elements of this list. The elements are
      * iterated in the same order as they occur in the list.
      *
      * @return an iterator on the elements of this list.
      * @see Iterator
      */
     @Override
     public Iterator<E> iterator() {
         return new SimpleListIterator();
     }

     /**
      * Searches this list for the specified object and returns the index of the
      * last occurrence.
      *
      * @param object
      *            the object to search for.
      * @return the index of the last occurrence of the object, or -1 if the
      *         object was not found.
      */
     public int lastIndexOf(Object object) {
         ListIterator<?> it = listIterator(size());
         if (object != null) {
             while (it.hasPrevious()) {
                 if (object.equals(it.previous())) {
                     return it.nextIndex();
                 }
             }
         } else {
             while (it.hasPrevious()) {
                 if (it.previous() == null) {
                     return it.nextIndex();
                 }
             }
         }
         return -1;
     }

     /**
      * Returns a ListIterator on the elements of this list. The elements are
      * iterated in the same order that they occur in the list.
      *
      * @return a ListIterator on the elements of this list
      * @see ListIterator
      */
     public ListIterator<E> listIterator() {
         return listIterator(0);
     }

     /**
      * Returns a list iterator on the elements of this list. The elements are
      * iterated in the same order as they occur in the list. The iteration
      * starts at the specified location.
      *
      * @param location
      *            the index at which to start the iteration.
      * @return a ListIterator on the elements of this list.
      * @throws IndexOutOfBoundsException
      *             if {@code location < 0 || location > size()}
      * @see ListIterator
      */
     public ListIterator<E> listIterator(int location) {
         return new FullListIterator(location);
     }

     /**
      * Removes the object at the specified location from this list.
      *
      * @param location
      *            the index of the object to remove.
      * @return the removed object.
      * @throws UnsupportedOperationException
      *             if removing from this list is not supported.
      * @throws IndexOutOfBoundsException
      *             if {@code location < 0 || location >= size()}
      */
     public E remove(int location) {
         throw new UnsupportedOperationException();
     }

     /**
      * Removes the objects in the specified range from the start to the end
      * index minus one.
      *
      * @param start
      *            the index at which to start removing.
      * @param end
      *            the index after the last element to remove.
      * @throws UnsupportedOperationException
      *             if removing from this list is not supported.
      * @throws IndexOutOfBoundsException
      *             if {@code start < 0} or {@code start >= size()}.
      */
     protected void removeRange(int start, int end) {
         Iterator<?> it = listIterator(start);
         for (int i = start; i < end; i++) {
             it.next();
             it.remove();
         }
     }

     /**
      * Replaces the element at the specified location in this list with the
      * specified object.
      *
      * @param location
      *            the index at which to put the specified object.
      * @param object
      *            the object to add.
      * @return the previous element at the index.
      * @throws UnsupportedOperationException
      *             if replacing elements in this list is not supported.
      * @throws ClassCastException
      *             if the class of an object is inappropriate for this list.
      * @throws IllegalArgumentException
      *             if an object cannot be added to this list.
      * @throws IndexOutOfBoundsException
      *             if {@code location < 0 || location >= size()}
      */
     public E set(int location, E object) {
         throw new UnsupportedOperationException();
     }

     /**
      * Returns a part of consecutive elements of this list as a view. The
      * returned view will be of zero length if start equals end. Any change that
      * occurs in the returned subList will be reflected to the original list,
      * and vice-versa. All the supported optional operations by the original
      * list will also be supported by this subList.
      * <p>
      * This method can be used as a handy method to do some operations on a sub
      * range of the original list, for example
      * {@code list.subList(from, to).clear();}
      * <p>
      * If the original list is modified in other ways than through the returned
      * subList, the behavior of the returned subList becomes undefined.
      * <p>
      * The returned subList is a subclass of AbstractList. The subclass stores
      * offset, size of itself, and modCount of the original list. If the
      * original list implements RandomAccess interface, the returned subList
      * also implements RandomAccess interface.
      * <p>
      * The subList's set(int, Object), get(int), add(int, Object), remove(int),
      * addAll(int, Collection) and removeRange(int, int) methods first check the
      * bounds, adjust offsets and then call the corresponding methods of the
      * original AbstractList. addAll(Collection c) method of the returned
      * subList calls the original addAll(offset + size, c).
      * <p>
      * The listIterator(int) method of the subList wraps the original list
      * iterator. The iterator() method of the subList invokes the original
      * listIterator() method, and the size() method merely returns the size of
      * the subList.
      * <p>
      * All methods will throw a ConcurrentModificationException if the modCount
      * of the original list is not equal to the expected value.
      *
      * @param start
      *            start index of the subList (inclusive).
      * @param end
      *            end index of the subList, (exclusive).
      * @return a subList view of this list starting from {@code start}
      *         (inclusive), and ending with {@code end} (exclusive)
      * @throws IndexOutOfBoundsException
      *             if (start < 0 || end > size())
      * @throws IllegalArgumentException
      *             if (start > end)
      */
     public List<E> subList(int start, int end) {
         if (start >= 0 && end <= size()) {
             if (start <= end) {
                 if (this instanceof RandomAccess) {
                     return new SubAbstractListRandomAccess<E>(this, start, end);
                 }
                 return new SubAbstractList<E>(this, start, end);
             }
             throw new IllegalArgumentException();
         }
         throw new IndexOutOfBoundsException();
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package java.util;

	/**
	* {@code AbstractList} is an abstract implementation of the {@code List} interface, optimized
	* for a backing store which supports random access. This implementation does
	* not support adding or replacing. A subclass must implement the abstract
	* methods {@code get()} and {@code size()}, and to create a
	* modifiable {@code List} it's necessary to override the {@code add()} method that
	* currently throws an {@code UnsupportedOperationException}.
	*
	* @since 1.2
	*/
	public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

	/**
	* A counter for changes to the list.
	*/
	protected transient int modCount;

	private class SimpleListIterator implements Iterator<E> {
	int pos = -1;

	int expectedModCount;

	int lastPosition = -1;

	SimpleListIterator() {
	expectedModCount = modCount;
	}

	public boolean hasNext() {
	return pos + 1 < size();
	}

	public E next() {
	if (expectedModCount == modCount) {
	try {
	E result = get(pos + 1);
	lastPosition = ++pos;
	return result;
	} catch (IndexOutOfBoundsException e) {
	throw new NoSuchElementException();
	}
	}
	throw new ConcurrentModificationException();
	}

	public void remove() {
	if (this.lastPosition == -1) {
	throw new IllegalStateException();
	}

	if (expectedModCount != modCount) {
	throw new ConcurrentModificationException();
	}

	try {
	AbstractList.this.remove(lastPosition);
	} catch (IndexOutOfBoundsException e) {
	throw new ConcurrentModificationException();
	}

	expectedModCount = modCount;
	if (pos == lastPosition) {
	pos--;
	}
	lastPosition = -1;
	}
	}

	private final class FullListIterator extends SimpleListIterator implements ListIterator<E> {
	FullListIterator(int start) {
	if (start >= 0 && start <= size()) {
	pos = start - 1;
	} else {
	throw new IndexOutOfBoundsException();
	}
	}

	public void add(E object) {
	if (expectedModCount == modCount) {
	try {
	AbstractList.this.add(pos + 1, object);
	} catch (IndexOutOfBoundsException e) {
	throw new NoSuchElementException();
	}
	pos++;
	lastPosition = -1;
	if (modCount != expectedModCount) {
	expectedModCount = modCount;
	}
	} else {
	throw new ConcurrentModificationException();
	}
	}

	public boolean hasPrevious() {
	return pos >= 0;
	}

	public int nextIndex() {
	return pos + 1;
	}

	public E previous() {
	if (expectedModCount == modCount) {
	try {
	E result = get(pos);
	lastPosition = pos;
	pos--;
	return result;
	} catch (IndexOutOfBoundsException e) {
	throw new NoSuchElementException();
	}
	}
	throw new ConcurrentModificationException();
	}

	public int previousIndex() {
	return pos;
	}

	public void set(E object) {
	if (expectedModCount == modCount) {
	try {
	AbstractList.this.set(lastPosition, object);
	} catch (IndexOutOfBoundsException e) {
	throw new IllegalStateException();
	}
	} else {
	throw new ConcurrentModificationException();
	}
	}
	}

	private static final class SubAbstractListRandomAccess<E> extends
	SubAbstractList<E> implements RandomAccess {
	SubAbstractListRandomAccess(AbstractList<E> list, int start, int end) {
	super(list, start, end);
	}
	}

	private static class SubAbstractList<E> extends AbstractList<E> {
	private final AbstractList<E> fullList;

	private int offset;

	private int size;

	private static final class SubAbstractListIterator<E> implements
	ListIterator<E> {
	private final SubAbstractList<E> subList;

	private final ListIterator<E> iterator;

	private int start;

	private int end;

	SubAbstractListIterator(ListIterator<E> it,
	SubAbstractList<E> list, int offset, int length) {
	iterator = it;
	subList = list;
	start = offset;
	end = start + length;
	}

	public void add(E object) {
	iterator.add(object);
	subList.sizeChanged(true);
	end++;
	}

	public boolean hasNext() {
	return iterator.nextIndex() < end;
	}

	public boolean hasPrevious() {
	return iterator.previousIndex() >= start;
	}

	public E next() {
	if (iterator.nextIndex() < end) {
	return iterator.next();
	}
	throw new NoSuchElementException();
	}

	public int nextIndex() {
	return iterator.nextIndex() - start;
	}

	public E previous() {
	if (iterator.previousIndex() >= start) {
	return iterator.previous();
	}
	throw new NoSuchElementException();
	}

	public int previousIndex() {
	int previous = iterator.previousIndex();
	if (previous >= start) {
	return previous - start;
	}
	return -1;
	}

	public void remove() {
	iterator.remove();
	subList.sizeChanged(false);
	end--;
	}

	public void set(E object) {
	iterator.set(object);
	}
	}

	SubAbstractList(AbstractList<E> list, int start, int end) {
	fullList = list;
	modCount = fullList.modCount;
	offset = start;
	size = end - start;
	}

	@Override
	public void add(int location, E object) {
	if (modCount == fullList.modCount) {
	if (location >= 0 && location <= size) {
	fullList.add(location + offset, object);
	size++;
	modCount = fullList.modCount;
	} else {
	throw new IndexOutOfBoundsException();
	}
	} else {
	throw new ConcurrentModificationException();
	}
	}

	@Override
	public boolean addAll(int location, Collection<? extends E> collection) {
	if (modCount == fullList.modCount) {
	if (location >= 0 && location <= size) {
	boolean result = fullList.addAll(location + offset,
	collection);
	if (result) {
	size += collection.size();
	modCount = fullList.modCount;
	}
	return result;
	}
	throw new IndexOutOfBoundsException();
	}
	throw new ConcurrentModificationException();
	}

	@Override
	public boolean addAll(Collection<? extends E> collection) {
	if (modCount == fullList.modCount) {
	boolean result = fullList.addAll(offset + size, collection);
	if (result) {
	size += collection.size();
	modCount = fullList.modCount;
	}
	return result;
	}
	throw new ConcurrentModificationException();
	}

	@Override
	public E get(int location) {
	if (modCount == fullList.modCount) {
	if (location >= 0 && location < size) {
	return fullList.get(location + offset);
	}
	throw new IndexOutOfBoundsException();
	}
	throw new ConcurrentModificationException();
	}

	@Override
	public Iterator<E> iterator() {
	return listIterator(0);
	}

	@Override
	public ListIterator<E> listIterator(int location) {
	if (modCount == fullList.modCount) {
	if (location >= 0 && location <= size) {
	return new SubAbstractListIterator<E>(fullList
	.listIterator(location + offset), this, offset,
	size);
	}
	throw new IndexOutOfBoundsException();
	}
	throw new ConcurrentModificationException();
	}

	@Override
	public E remove(int location) {
	if (modCount == fullList.modCount) {
	if (location >= 0 && location < size) {
	E result = fullList.remove(location + offset);
	size--;
	modCount = fullList.modCount;
	return result;
	}
	throw new IndexOutOfBoundsException();
	}
	throw new ConcurrentModificationException();
	}

	@Override
	protected void removeRange(int start, int end) {
	if (start != end) {
	if (modCount == fullList.modCount) {
	fullList.removeRange(start + offset, end + offset);
	size -= end - start;
	modCount = fullList.modCount;
	} else {
	throw new ConcurrentModificationException();
	}
	}
	}

	@Override
	public E set(int location, E object) {
	if (modCount == fullList.modCount) {
	if (location >= 0 && location < size) {
	return fullList.set(location + offset, object);
	}
	throw new IndexOutOfBoundsException();
	}
	throw new ConcurrentModificationException();
	}

	@Override
	public int size() {
	if (modCount == fullList.modCount) {
	return size;
	}
	throw new ConcurrentModificationException();
	}

	void sizeChanged(boolean increment) {
	if (increment) {
	size++;
	} else {
	size--;
	}
	modCount = fullList.modCount;
	}
	}

	/**
	* Constructs a new instance of this AbstractList.
	*/
	protected AbstractList() {
	}

	/**
	* Inserts the specified object into this List at the specified location.
	* The object is inserted before any previous element at the specified
	* location. If the location is equal to the size of this List, the object
	* is added at the end.
	* <p>
	* Concrete implementations that would like to support the add functionality
	* must override this method.
	*
	* @param location
	* the index at which to insert.
	* @param object
	* the object to add.
	*
	* @throws UnsupportedOperationException
	* if adding to this List is not supported.
	* @throws ClassCastException
	* if the class of the object is inappropriate for this
	* List
	* @throws IllegalArgumentException
	* if the object cannot be added to this List
	* @throws IndexOutOfBoundsException
	* if {@code location < 0 \|\| location > size()}
	*/
	public void add(int location, E object) {
	throw new UnsupportedOperationException();
	}

	/**
	* Adds the specified object at the end of this List.
	*
	*
	* @param object
	* the object to add
	* @return true
	*
	* @throws UnsupportedOperationException
	* if adding to this List is not supported
	* @throws ClassCastException
	* if the class of the object is inappropriate for this
	* List
	* @throws IllegalArgumentException
	* if the object cannot be added to this List
	*/
	@Override
	public boolean add(E object) {
	add(size(), object);
	return true;
	}

	/**
	* Inserts the objects in the specified Collection at the specified location
	* in this List. The objects are added in the order they are returned from
	* the collection's iterator.
	*
	* @param location
	* the index at which to insert.
	* @param collection
	* the Collection of objects
	* @return {@code true} if this List is modified, {@code false} otherwise.
	* @throws UnsupportedOperationException
	* if adding to this list is not supported.
	* @throws ClassCastException
	* if the class of an object is inappropriate for this list.
	* @throws IllegalArgumentException
	* if an object cannot be added to this list.
	* @throws IndexOutOfBoundsException
	* if {@code location < 0 \|\| location > size()}
	*/
	public boolean addAll(int location, Collection<? extends E> collection) {
	Iterator<? extends E> it = collection.iterator();
	while (it.hasNext()) {
	add(location++, it.next());
	}
	return !collection.isEmpty();
	}

	/**
	* Removes all elements from this list, leaving it empty.
	*
	* @throws UnsupportedOperationException
	* if removing from this list is not supported.
	* @see List#isEmpty
	* @see List#size
	*/
	@Override
	public void clear() {
	removeRange(0, size());
	}

	/**
	* Compares the specified object to this list and return true if they are
	* equal. Two lists are equal when they both contain the same objects in the
	* same order.
	*
	* @param object
	* the object to compare to this object.
	* @return {@code true} if the specified object is equal to this list,
	* {@code false} otherwise.
	* @see #hashCode
	*/
	@Override
	public boolean equals(Object object) {
	if (this == object) {
	return true;
	}
	if (object instanceof List) {
	List<?> list = (List<?>) object;
	if (list.size() != size()) {
	return false;
	}

	Iterator<?> it1 = iterator(), it2 = list.iterator();
	while (it1.hasNext()) {
	Object e1 = it1.next(), e2 = it2.next();
	if (!(e1 == null ? e2 == null : e1.equals(e2))) {
	return false;
	}
	}
	return true;
	}
	return false;
	}

	/**
	* Returns the element at the specified location in this list.
	*
	* @param location
	* the index of the element to return.
	* @return the element at the specified index.
	* @throws IndexOutOfBoundsException
	* if {@code location < 0 \|\| location >= size()}
	*/
	public abstract E get(int location);

	/**
	* Returns the hash code of this list. The hash code is calculated by taking
	* each element's hashcode into account.
	*
	* @return the hash code.
	* @see #equals
	* @see List#hashCode()
	*/
	@Override
	public int hashCode() {
	int result = 1;
	Iterator<?> it = iterator();
	while (it.hasNext()) {
	Object object = it.next();
	result = (31 * result) + (object == null ? 0 : object.hashCode());
	}
	return result;
	}

	/**
	* Searches this list for the specified object and returns the index of the
	* first occurrence.
	*
	* @param object
	* the object to search for.
	* @return the index of the first occurrence of the object, or -1 if it was
	* not found.
	*/
	public int indexOf(Object object) {
	ListIterator<?> it = listIterator();
	if (object != null) {
	while (it.hasNext()) {
	if (object.equals(it.next())) {
	return it.previousIndex();
	}
	}
	} else {
	while (it.hasNext()) {
	if (it.next() == null) {
	return it.previousIndex();
	}
	}
	}
	return -1;
	}

	/**
	* Returns an iterator on the elements of this list. The elements are
	* iterated in the same order as they occur in the list.
	*
	* @return an iterator on the elements of this list.
	* @see Iterator
	*/
	@Override
	public Iterator<E> iterator() {
	return new SimpleListIterator();
	}

	/**
	* Searches this list for the specified object and returns the index of the
	* last occurrence.
	*
	* @param object
	* the object to search for.
	* @return the index of the last occurrence of the object, or -1 if the
	* object was not found.
	*/
	public int lastIndexOf(Object object) {
	ListIterator<?> it = listIterator(size());
	if (object != null) {
	while (it.hasPrevious()) {
	if (object.equals(it.previous())) {
	return it.nextIndex();
	}
	}
	} else {
	while (it.hasPrevious()) {
	if (it.previous() == null) {
	return it.nextIndex();
	}
	}
	}
	return -1;
	}

	/**
	* Returns a ListIterator on the elements of this list. The elements are
	* iterated in the same order that they occur in the list.
	*
	* @return a ListIterator on the elements of this list
	* @see ListIterator
	*/
	public ListIterator<E> listIterator() {
	return listIterator(0);
	}

	/**
	* Returns a list iterator on the elements of this list. The elements are
	* iterated in the same order as they occur in the list. The iteration
	* starts at the specified location.
	*
	* @param location
	* the index at which to start the iteration.
	* @return a ListIterator on the elements of this list.
	* @throws IndexOutOfBoundsException
	* if {@code location < 0 \|\| location > size()}
	* @see ListIterator
	*/
	public ListIterator<E> listIterator(int location) {
	return new FullListIterator(location);
	}

	/**
	* Removes the object at the specified location from this list.
	*
	* @param location
	* the index of the object to remove.
	* @return the removed object.
	* @throws UnsupportedOperationException
	* if removing from this list is not supported.
	* @throws IndexOutOfBoundsException
	* if {@code location < 0 \|\| location >= size()}
	*/
	public E remove(int location) {
	throw new UnsupportedOperationException();
	}

	/**
	* Removes the objects in the specified range from the start to the end
	* index minus one.
	*
	* @param start
	* the index at which to start removing.
	* @param end
	* the index after the last element to remove.
	* @throws UnsupportedOperationException
	* if removing from this list is not supported.
	* @throws IndexOutOfBoundsException
	* if {@code start < 0} or {@code start >= size()}.
	*/
	protected void removeRange(int start, int end) {
	Iterator<?> it = listIterator(start);
	for (int i = start; i < end; i++) {
	it.next();
	it.remove();
	}
	}

	/**
	* Replaces the element at the specified location in this list with the
	* specified object.
	*
	* @param location
	* the index at which to put the specified object.
	* @param object
	* the object to add.
	* @return the previous element at the index.
	* @throws UnsupportedOperationException
	* if replacing elements in this list is not supported.
	* @throws ClassCastException
	* if the class of an object is inappropriate for this list.
	* @throws IllegalArgumentException
	* if an object cannot be added to this list.
	* @throws IndexOutOfBoundsException
	* if {@code location < 0 \|\| location >= size()}
	*/
	public E set(int location, E object) {
	throw new UnsupportedOperationException();
	}

	/**
	* Returns a part of consecutive elements of this list as a view. The
	* returned view will be of zero length if start equals end. Any change that
	* occurs in the returned subList will be reflected to the original list,
	* and vice-versa. All the supported optional operations by the original
	* list will also be supported by this subList.
	* <p>
	* This method can be used as a handy method to do some operations on a sub
	* range of the original list, for example
	* {@code list.subList(from, to).clear();}
	* <p>
	* If the original list is modified in other ways than through the returned
	* subList, the behavior of the returned subList becomes undefined.
	* <p>
	* The returned subList is a subclass of AbstractList. The subclass stores
	* offset, size of itself, and modCount of the original list. If the
	* original list implements RandomAccess interface, the returned subList
	* also implements RandomAccess interface.
	* <p>
	* The subList's set(int, Object), get(int), add(int, Object), remove(int),
	* addAll(int, Collection) and removeRange(int, int) methods first check the
	* bounds, adjust offsets and then call the corresponding methods of the
	* original AbstractList. addAll(Collection c) method of the returned
	* subList calls the original addAll(offset + size, c).
	* <p>
	* The listIterator(int) method of the subList wraps the original list
	* iterator. The iterator() method of the subList invokes the original
	* listIterator() method, and the size() method merely returns the size of
	* the subList.
	* <p>
	* All methods will throw a ConcurrentModificationException if the modCount
	* of the original list is not equal to the expected value.
	*
	* @param start
	* start index of the subList (inclusive).
	* @param end
	* end index of the subList, (exclusive).
	* @return a subList view of this list starting from {@code start}
	* (inclusive), and ending with {@code end} (exclusive)
	* @throws IndexOutOfBoundsException
	* if (start < 0 \|\| end > size())
	* @throws IllegalArgumentException
	* if (start > end)
	*/
	public List<E> subList(int start, int end) {
	if (start >= 0 && end <= size()) {
	if (start <= end) {
	if (this instanceof RandomAccess) {
	return new SubAbstractListRandomAccess<E>(this, start, end);
	}
	return new SubAbstractList<E>(this, start, end);
	}
	throw new IllegalArgumentException();
	}
	throw new IndexOutOfBoundsException();
	}
	}