diff -r ee8a922f4268 -r d382dacfd73f rt/emul/compact/src/main/java/java/util/AbstractSequentialList.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rt/emul/compact/src/main/java/java/util/AbstractSequentialList.java Tue Feb 26 16:54:16 2013 +0100 @@ -0,0 +1,253 @@ +/* + * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.util; + +/** + * This class provides a skeletal implementation of the List + * interface to minimize the effort required to implement this interface + * backed by a "sequential access" data store (such as a linked list). For + * random access data (such as an array), AbstractList should be used + * in preference to this class.

+ * + * This class is the opposite of the AbstractList class in the sense + * that it implements the "random access" methods (get(int index), + * set(int index, E element), add(int index, E element) and + * remove(int index)) on top of the list's list iterator, instead of + * the other way around.

+ * + * To implement a list the programmer needs only to extend this class and + * provide implementations for the listIterator and size + * methods. For an unmodifiable list, the programmer need only implement the + * list iterator's hasNext, next, hasPrevious, + * previous and index methods.

+ * + * For a modifiable list the programmer should additionally implement the list + * iterator's set method. For a variable-size list the programmer + * should additionally implement the list iterator's remove and + * add methods.

+ * + * The programmer should generally provide a void (no argument) and collection + * constructor, as per the recommendation in the Collection interface + * specification.

+ * + * This class is a member of the + * + * Java Collections Framework. + * + * @author Josh Bloch + * @author Neal Gafter + * @see Collection + * @see List + * @see AbstractList + * @see AbstractCollection + * @since 1.2 + */ + +public abstract class AbstractSequentialList extends AbstractList { + /** + * Sole constructor. (For invocation by subclass constructors, typically + * implicit.) + */ + protected AbstractSequentialList() { + } + + /** + * Returns the element at the specified position in this list. + * + *

This implementation first gets a list iterator pointing to the + * indexed element (with listIterator(index)). Then, it gets + * the element using ListIterator.next and returns it. + * + * @throws IndexOutOfBoundsException {@inheritDoc} + */ + public E get(int index) { + try { + return listIterator(index).next(); + } catch (NoSuchElementException exc) { + throw new IndexOutOfBoundsException("Index: "+index); + } + } + + /** + * Replaces the element at the specified position in this list with the + * specified element (optional operation). + * + *

This implementation first gets a list iterator pointing to the + * indexed element (with listIterator(index)). Then, it gets + * the current element using ListIterator.next and replaces it + * with ListIterator.set. + * + *

Note that this implementation will throw an + * UnsupportedOperationException if the list iterator does not + * implement the set operation. + * + * @throws UnsupportedOperationException {@inheritDoc} + * @throws ClassCastException {@inheritDoc} + * @throws NullPointerException {@inheritDoc} + * @throws IllegalArgumentException {@inheritDoc} + * @throws IndexOutOfBoundsException {@inheritDoc} + */ + public E set(int index, E element) { + try { + ListIterator e = listIterator(index); + E oldVal = e.next(); + e.set(element); + return oldVal; + } catch (NoSuchElementException exc) { + throw new IndexOutOfBoundsException("Index: "+index); + } + } + + /** + * Inserts the specified element at the specified position in this list + * (optional operation). Shifts the element currently at that position + * (if any) and any subsequent elements to the right (adds one to their + * indices). + * + *

This implementation first gets a list iterator pointing to the + * indexed element (with listIterator(index)). Then, it + * inserts the specified element with ListIterator.add. + * + *

Note that this implementation will throw an + * UnsupportedOperationException if the list iterator does not + * implement the add operation. + * + * @throws UnsupportedOperationException {@inheritDoc} + * @throws ClassCastException {@inheritDoc} + * @throws NullPointerException {@inheritDoc} + * @throws IllegalArgumentException {@inheritDoc} + * @throws IndexOutOfBoundsException {@inheritDoc} + */ + public void add(int index, E element) { + try { + listIterator(index).add(element); + } catch (NoSuchElementException exc) { + throw new IndexOutOfBoundsException("Index: "+index); + } + } + + /** + * Removes the element at the specified position in this list (optional + * operation). Shifts any subsequent elements to the left (subtracts one + * from their indices). Returns the element that was removed from the + * list. + * + *

This implementation first gets a list iterator pointing to the + * indexed element (with listIterator(index)). Then, it removes + * the element with ListIterator.remove. + * + *

Note that this implementation will throw an + * UnsupportedOperationException if the list iterator does not + * implement the remove operation. + * + * @throws UnsupportedOperationException {@inheritDoc} + * @throws IndexOutOfBoundsException {@inheritDoc} + */ + public E remove(int index) { + try { + ListIterator e = listIterator(index); + E outCast = e.next(); + e.remove(); + return outCast; + } catch (NoSuchElementException exc) { + throw new IndexOutOfBoundsException("Index: "+index); + } + } + + + // Bulk Operations + + /** + * Inserts all of the elements in the specified collection into this + * list at the specified position (optional operation). Shifts the + * element currently at that position (if any) and any subsequent + * elements to the right (increases their indices). The new elements + * will appear in this list in the order that they are returned by the + * specified collection's iterator. The behavior of this operation is + * undefined if the specified collection is modified while the + * operation is in progress. (Note that this will occur if the specified + * collection is this list, and it's nonempty.) + * + *

This implementation gets an iterator over the specified collection and + * a list iterator over this list pointing to the indexed element (with + * listIterator(index)). Then, it iterates over the specified + * collection, inserting the elements obtained from the iterator into this + * list, one at a time, using ListIterator.add followed by + * ListIterator.next (to skip over the added element). + * + *

Note that this implementation will throw an + * UnsupportedOperationException if the list iterator returned by + * the listIterator method does not implement the add + * operation. + * + * @throws UnsupportedOperationException {@inheritDoc} + * @throws ClassCastException {@inheritDoc} + * @throws NullPointerException {@inheritDoc} + * @throws IllegalArgumentException {@inheritDoc} + * @throws IndexOutOfBoundsException {@inheritDoc} + */ + public boolean addAll(int index, Collection c) { + try { + boolean modified = false; + ListIterator e1 = listIterator(index); + Iterator e2 = c.iterator(); + while (e2.hasNext()) { + e1.add(e2.next()); + modified = true; + } + return modified; + } catch (NoSuchElementException exc) { + throw new IndexOutOfBoundsException("Index: "+index); + } + } + + + // Iterators + + /** + * Returns an iterator over the elements in this list (in proper + * sequence).

+ * + * This implementation merely returns a list iterator over the list. + * + * @return an iterator over the elements in this list (in proper sequence) + */ + public Iterator iterator() { + return listIterator(); + } + + /** + * Returns a list iterator over the elements in this list (in proper + * sequence). + * + * @param index index of first element to be returned from the list + * iterator (by a call to the next method) + * @return a list iterator over the elements in this list (in proper + * sequence) + * @throws IndexOutOfBoundsException {@inheritDoc} + */ + public abstract ListIterator listIterator(int index); +}