/*

 * 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;

/**

 * interface to minimize the effort required to implement this interface

 * backed by a "sequential access" data store (such as a linked list).  For

 * in preference to this class.<p>

 *

 * the other way around.<p>

 *

 * To implement a list the programmer needs only to extend this class and

 * methods.  For an unmodifiable list, the programmer need only implement the

 *

 * For a modifiable list the programmer should additionally implement the list

 *

 * The programmer should generally provide a void (no argument) and collection

 * 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

     *

     * @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

     *

     * <p>Note that this implementation will throw an

     *

     * @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

     *

     * <p>Note that this implementation will throw an

     *

     * @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

     *

     * <p>Note that this implementation will throw an

     *

     * @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

     * collection, inserting the elements obtained from the iterator into this

     *

     * <p>Note that this implementation will throw an

     * 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);

            for (E e : c) {

                e1.add(e);

                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

     * @return a list iterator over the elements in this list (in proper

     *         sequence)

     * @throws IndexOutOfBoundsException {@inheritDoc}

     */

    public abstract ListIterator<E> listIterator(int index);

}