diff -r 3392f250c784 -r ecbd252fd3a7 emul/compact/src/main/java/java/util/AbstractSequentialList.java --- a/emul/compact/src/main/java/java/util/AbstractSequentialList.java Fri Mar 22 16:59:47 2013 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,253 +0,0 @@ -/* - * 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); -}