| /* |
| * 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 <tt>List</tt> |
| * 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), <tt>AbstractList</tt> should be used |
| * in preference to this class.<p> |
| * |
| * This class is the opposite of the <tt>AbstractList</tt> class in the sense |
| * that it implements the "random access" methods (<tt>get(int index)</tt>, |
| * <tt>set(int index, E element)</tt>, <tt>add(int index, E element)</tt> and |
| * <tt>remove(int index)</tt>) on top of the list's list iterator, instead of |
| * the other way around.<p> |
| * |
| * To implement a list the programmer needs only to extend this class and |
| * provide implementations for the <tt>listIterator</tt> and <tt>size</tt> |
| * methods. For an unmodifiable list, the programmer need only implement the |
| * list iterator's <tt>hasNext</tt>, <tt>next</tt>, <tt>hasPrevious</tt>, |
| * <tt>previous</tt> and <tt>index</tt> methods.<p> |
| * |
| * For a modifiable list the programmer should additionally implement the list |
| * iterator's <tt>set</tt> method. For a variable-size list the programmer |
| * should additionally implement the list iterator's <tt>remove</tt> and |
| * <tt>add</tt> methods.<p> |
| * |
| * The programmer should generally provide a void (no argument) and collection |
| * constructor, as per the recommendation in the <tt>Collection</tt> interface |
| * specification.<p> |
| * |
| * This class is a member of the |
| * <a href="{@docRoot}/../technotes/guides/collections/index.html"> |
| * Java Collections Framework</a>. |
| * |
| * @author Josh Bloch |
| * @author Neal Gafter |
| * @see Collection |
| * @see List |
| * @see AbstractList |
| * @see AbstractCollection |
| * @since 1.2 |
| */ |
| |
| public abstract class AbstractSequentialList<E> extends AbstractList<E> { |
| /** |
| * Sole constructor. (For invocation by subclass constructors, typically |
| * implicit.) |
| */ |
| protected AbstractSequentialList() { |
| } |
| |
| /** |
| * Returns the element at the specified position in this list. |
| * |
| * <p>This implementation first gets a list iterator pointing to the |
| * indexed element (with <tt>listIterator(index)</tt>). Then, it gets |
| * the element using <tt>ListIterator.next</tt> 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). |
| * |
| * <p>This implementation first gets a list iterator pointing to the |
| * indexed element (with <tt>listIterator(index)</tt>). Then, it gets |
| * the current element using <tt>ListIterator.next</tt> and replaces it |
| * with <tt>ListIterator.set</tt>. |
| * |
| * <p>Note that this implementation will throw an |
| * <tt>UnsupportedOperationException</tt> if the list iterator does not |
| * implement the <tt>set</tt> 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> 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). |
| * |
| * <p>This implementation first gets a list iterator pointing to the |
| * indexed element (with <tt>listIterator(index)</tt>). Then, it |
| * inserts the specified element with <tt>ListIterator.add</tt>. |
| * |
| * <p>Note that this implementation will throw an |
| * <tt>UnsupportedOperationException</tt> if the list iterator does not |
| * implement the <tt>add</tt> 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. |
| * |
| * <p>This implementation first gets a list iterator pointing to the |
| * indexed element (with <tt>listIterator(index)</tt>). Then, it removes |
| * the element with <tt>ListIterator.remove</tt>. |
| * |
| * <p>Note that this implementation will throw an |
| * <tt>UnsupportedOperationException</tt> if the list iterator does not |
| * implement the <tt>remove</tt> operation. |
| * |
| * @throws UnsupportedOperationException {@inheritDoc} |
| * @throws IndexOutOfBoundsException {@inheritDoc} |
| */ |
| public E remove(int index) { |
| try { |
| ListIterator<E> 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.) |
| * |
| * <p>This implementation gets an iterator over the specified collection and |
| * a list iterator over this list pointing to the indexed element (with |
| * <tt>listIterator(index)</tt>). Then, it iterates over the specified |
| * collection, inserting the elements obtained from the iterator into this |
| * list, one at a time, using <tt>ListIterator.add</tt> followed by |
| * <tt>ListIterator.next</tt> (to skip over the added element). |
| * |
| * <p>Note that this implementation will throw an |
| * <tt>UnsupportedOperationException</tt> if the list iterator returned by |
| * the <tt>listIterator</tt> method does not implement the <tt>add</tt> |
| * operation. |
| * |
| * @throws UnsupportedOperationException {@inheritDoc} |
| * @throws ClassCastException {@inheritDoc} |
| * @throws NullPointerException {@inheritDoc} |
| * @throws IllegalArgumentException {@inheritDoc} |
| * @throws IndexOutOfBoundsException {@inheritDoc} |
| */ |
| public boolean addAll(int index, Collection<? extends E> c) { |
| try { |
| boolean modified = false; |
| ListIterator<E> e1 = listIterator(index); |
| Iterator<? extends E> 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).<p> |
| * |
| * This implementation merely returns a list iterator over the list. |
| * |
| * @return an iterator over the elements in this list (in proper sequence) |
| */ |
| public Iterator<E> 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 <code>next</code> method) |
| * @return a list iterator over the elements in this list (in proper |
| * sequence) |
| * @throws IndexOutOfBoundsException {@inheritDoc} |
| */ |
| public abstract ListIterator<E> listIterator(int index); |
| } |
