util/concurrent/CopyOnWriteArrayList.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group.  Adapted and released under explicit permission 
 * from JDK1.2 ArrayList.java which carries the following copyright:
 *
 * Copyright 1997 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */

package java.util.concurrent;
import java.util.*;

/**
 * CopyOnWriteArrayList is a variant of java.util.ArrayList in which all
 * mutative operations (add, set, and so on) are implemented by making
 * a fresh copy of the underlying array.  <p>
 *
 * This is ordinarily too costly, but it becomes attractive when
 * traversal operations vastly overwhelm mutations, and, especially,
 * when you cannot or don't want to synchronize traversals, yet need
 * to preclude interference among concurrent threads.  The iterator
 * method uses a reference to the state of the array at the point that
 * the iterator was created. This array never changes during the
 * lifetime of the iterator, so interference is impossible.  (The
 * iterator will not traverse elements added or changed since the
 * iterator was created, but usually this is a desirable feature.)
 * <p>
 *
 * Because of the copy-on-write policy, some one-by-one mutative
 * operations in the java.util.Arrays and java.util.Collections
 * classes are so time/space intensive as to never be worth calling.
 * <p>
 *
 * Due to their strict read-only nature, element-changing operations
 * on iterators (remove, set, and add) are not supported. These are
 * the only methods throwing UnsupportedOperationException.  <p>
 **/
public class CopyOnWriteArrayList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    /**
     * The held array. Directly access only within synchronized
     *  methods
     */
    private volatile transient E[] array_;

    /**
     * Accessor to the array intended to be called from
     * within unsynchronized read-only methods
     **/
    private E[] array() { return array_; }

    /**
     * Constructs an empty list
     *
     */
    public CopyOnWriteArrayList() {
        array_ = new E[0];
    }

    /**
     * Constructs an list containing the elements of the specified
     * Collection, in the order they are returned by the Collection's
     * iterator.
     */
    public CopyOnWriteArrayList(Collection<E> c) {
        array_ = new E[c.size()];
        Iterator<E> i = c.iterator();
        int size = 0;
        while (i.hasNext())
            array_[size++] = i.next();
    }

    /**
     * Create a new CopyOnWriteArrayList holding a copy of given array
     * @param toCopyIn the array. A copy of this array is used as the
     * internal array.
     **/
    public CopyOnWriteArrayList(E[] toCopyIn) {
        copyIn(toCopyIn, 0, toCopyIn.length);
    }

    /**
     * Replace the held array with a copy of the <code>n</code>
     * elements of the provided array, starting at position <code>first</code>.
     * To copy an entire array, call with arguments (array, 0, array.length).
     * @param toCopyIn the array. A copy of the indicated elements of
     * this  array is used as the
     * internal array.
     * @param first The index of first position of the array to
     * start copying from.
     * @param n the number of elements to copy. This will be the new size of
     * the list.
     **/
    private synchronized void copyIn(E[] toCopyIn, int first, int n) {
        array_  = new E[n];
        System.arraycopy(toCopyIn, first, array_, 0, n);
    }

    /**
     * Returns the number of components in this list.
     *
     * @return  the number of components in this list.
     */
    public int size() {
        return array().length;
    }

    /**
     * Tests if this list has no components.
     *
     * @return  <code>true</code> if this list has no components;
     *          <code>false</code> otherwise.
     */
    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * Returns true if this list contains the specified element.
     *
     * @param o element whose presence in this List is to be tested.
     */
    public boolean contains(Object elem) {
        E[] elementData = array();
        int len = elementData.length;
        return indexOf(elem, elementData, len) >= 0;
    }

    /**
     * Searches for the first occurence of the given argument, testing
     * for equality using the <code>equals</code> method.
     *
     * @param   elem   an object.
     * @return  the index of the first occurrence of the argument in this
     *          list; returns <code>-1</code> if the object is not found.
     * @see     Object#equals(Object)
     */
    public int indexOf(Object elem) {
        E[] elementData = array();
        int len = elementData.length;
        return indexOf(elem, elementData, len);
    }


    /**
     * static version allows repeated call without needed
     * to grab lock for array each time
     **/
    private static int indexOf(Object elem, Object[] elementData, int len) {
        if (elem == null) {
            for (int i = 0; i < len; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < len; i++)
                if (elem.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * Searches for the first occurence of the given argument, beginning
     * the search at <code>index</code>, and testing for equality using
     * the <code>equals</code> method.
     *
     * @param   elem    an object.
     * @param   index   the index to start searching from.
     * @return  the index of the first occurrence of the object argument in
     *          this List at position <code>index</code> or later in the
     *          List; returns <code>-1</code> if the object is not found.
     * @see     Object#equals(Object)
     */
    public int indexOf(E elem, int index) {
        E[] elementData = array();
        int elementCount = elementData.length;

        if (elem == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (elem.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * Returns the index of the last occurrence of the specified object in
     * this list.
     *
     * @param   elem   the desired component.
     * @return  the index of the last occurrence of the specified object in
     *          this list; returns -1 if the object is not found.
     */
    public int lastIndexOf(Object elem) {
        E[] elementData = array();
        int len = elementData.length;
        return lastIndexOf(elem, elementData, len);
    }

    private static int lastIndexOf(Object elem, Object[] elementData, int len) {
        if (elem == null) {
            for (int i = len-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = len-1; i >= 0; i--)
                if (elem.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * Searches backwards for the specified object, starting from the
     * specified index, and returns an index to it.
     *
     * @param  elem    the desired component.
     * @param  index   the index to start searching from.
     * @return the index of the last occurrence of the specified object in this
     *          List at position less than index in the List;
     *          -1 if the object is not found.
     */
    public int lastIndexOf(E elem, int index) {
        // needed in order to compile on 1.2b3
        E[] elementData = array();
        if (elem == null) {
            for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index; i >= 0; i--)
                if (elem.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * Returns a shallow copy of this list.  (The elements themselves
     * are not copied.)
     *
     * @return  a clone of this list.
     */
    public Object clone() {
        try {
            E[] elementData = array();
            CopyOnWriteArrayList<E> v = (CopyOnWriteArrayList)super.clone();
            v.array_ = new E[elementData.length];
            System.arraycopy(elementData, 0, v.array_, 0, elementData.length);
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

    /**
     * Returns an array containing all of the elements in this list
     * in the correct order.
     */
    public Object[] toArray() {
        Object[] elementData = array();
        Object[] result = new Object[elementData.length];
        System.arraycopy(elementData, 0, result, 0, elementData.length);
        return result;
    }

    /**
     * Returns an array containing all of the elements in this list in the
     * correct order.  The runtime type of the returned array is that of the
     * specified array.  If the list fits in the specified array, it is
     * returned therein.  Otherwise, a new array is allocated with the runtime
     * type of the specified array and the size of this list.
     * <p>
     * If the list fits in the specified array with room to spare
     * (i.e., the array has more elements than the list),
     * the element in the array immediately following the end of the
     * collection is set to null.  This is useful in determining the length
     * of the list <em>only</em> if the caller knows that the list
     * does not contain any null elements.
     *
     * @param a the array into which the elements of the list are to
     *            be stored, if it is big enough; otherwise, a new array of the
     *            same runtime type is allocated for this purpose.
     * @return an array containing the elements of the list.
     * @exception ArrayStoreException the runtime type of a is not a supertype
     * of the runtime type of every element in this list.
     */
    public <T> T[] toArray(T a[]) {
        E[] elementData = array();

        if (a.length < elementData.length)
            a = (T[])
            java.lang.reflect.Array.newInstance(a.getClass().getComponentType(),
            elementData.length);

        System.arraycopy(elementData, 0, a, 0, elementData.length);

        if (a.length > elementData.length)
            a[elementData.length] = null;

        return a;
    }

    // Positional Access Operations

    /**
     * Returns the element at the specified position in this list.
     *
     * @param index index of element to return.
     * @exception IndexOutOfBoundsException index is out of range (index
     *              &lt; 0 || index &gt;= size()).
     */
    public E get(int index) {
        E[] elementData = array();
        rangeCheck(index, elementData.length);
        return elementData[index];
    }

    /**
     * Replaces the element at the specified position in this list with
     * the specified element.
     *
     * @param index index of element to replace.
     * @param element element to be stored at the specified position.
     * @return the element previously at the specified position.
     * @exception IndexOutOfBoundsException index out of range
     *              (index &lt; 0 || index &gt;= size()).
     */
    public synchronized E set(int index, E element) {
        int len = array_.length;
        rangeCheck(index, len);
        E oldValue = array_[index];

        boolean same = (oldValue == element ||
        (element != null && element.equals(oldValue)));
        if (!same) {
            E[] newArray = new E[len];
            System.arraycopy(array_, 0, newArray, 0, len);
            newArray[index] = element;
            array_ = newArray;
        }
        return oldValue;
    }

    /**
     * Appends the specified element to the end of this list.
     *
     * @param element element to be appended to this list.
     * @return true (as per the general contract of Collection.add).
     */
    public synchronized boolean add(E element) {
        int len = array_.length;
        E[] newArray = new E[len+1];
        System.arraycopy(array_, 0, newArray, 0, len);
        newArray[len] = element;
        array_ = newArray;
        return true;
    }

    /**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted.
     * @param element element to be inserted.
     * @exception IndexOutOfBoundsException index is out of range
     *              (index &lt; 0 || index &gt; size()).
     */
    public synchronized void add(int index, E element) {
        int len = array_.length;
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+len);

        E[] newArray = new E[len+1];
        System.arraycopy(array_, 0, newArray, 0, index);
        newArray[index] = element;
        System.arraycopy(array_, index, newArray, index+1, len - index);
        array_ = newArray;
    }

    /**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the list.
     *
     * @exception IndexOutOfBoundsException index out of range (index
     *              &lt; 0 || index &gt;= size()).
     * @param index the index of the element to removed.
     */
    public synchronized E remove(int index) {
        int len = array_.length;
        rangeCheck(index, len);
        E oldValue = array_[index];
        E[] newArray = new E[len-1];
        System.arraycopy(array_, 0, newArray, 0, index);
        int numMoved = len - index - 1;
        if (numMoved > 0)
            System.arraycopy(array_, index+1, newArray, index, numMoved);
        array_ = newArray;
        return oldValue;
    }

    /**
     * Removes a single instance of the specified element from this Collection,
     * if it is present (optional operation).  More formally, removes an
     * element <code>e</code> such that <code>(o==null ? e==null :
     * o.equals(e))</code>, if the Collection contains one or more such
     * elements.  Returns true if the Collection contained the specified
     * element (or equivalently, if the Collection changed as a result of the
     * call).
     *
     * @param element element to be removed from this Collection, if present.
     * @return true if the Collection changed as a result of the call.
     */
    public synchronized boolean remove(Object element) {
        int len = array_.length;
        if (len == 0) return false;

        // Copy while searching for element to remove
        // This wins in the normal case of element being present

        int newlen = len-1;
        E[] newArray = new E[newlen];

        for (int i = 0; i < newlen; ++i) {
            if (element == array_[i] ||
            (element != null && element.equals(array_[i]))) {
                // found one;  copy remaining and exit
                for (int k = i + 1; k < len; ++k) newArray[k-1] = array_[k];
                array_ = newArray;
                return true;
            }
            else
                newArray[i] = array_[i];
        }
        // special handling for last cell

        if (element == array_[newlen] ||
        (element != null && element.equals(array_[newlen]))) {
            array_ = newArray;
            return true;
        }
        else
            return false; // throw away copy

    }


    /**
     * Removes from this List all of the elements whose index is between
     * fromIndex, inclusive and toIndex, exclusive.  Shifts any succeeding
     * elements to the left (reduces their index).
     * This call shortens the List by (toIndex - fromIndex) elements.  (If
     * toIndex==fromIndex, this operation has no effect.)
     *
     * @param fromIndex index of first element to be removed.
     * @param fromIndex index after last element to be removed.
     * @exception IndexOutOfBoundsException fromIndex or toIndex out of
     *              range (fromIndex &lt; 0 || fromIndex &gt;= size() || toIndex
     *              &gt; size() || toIndex &lt; fromIndex).
     */
    private synchronized void removeRange(int fromIndex, int toIndex) {
        int len = array_.length;

        if (fromIndex < 0 || fromIndex >= len ||
        toIndex > len || toIndex < fromIndex)
            throw new IndexOutOfBoundsException();

        int numMoved = len - toIndex;
        int newlen = len - (toIndex-fromIndex);
        E[] newArray = new E[newlen];
        System.arraycopy(array_, 0, newArray, 0, fromIndex);
        System.arraycopy(array_, toIndex, newArray, fromIndex, numMoved);
        array_ = newArray;
    }


    /**
     * Append the element if not present.
     * This operation can be used to obtain Set semantics
     * for lists.
     * @param element element to be added to this Collection, if absent.
     * @return true if added
     **/
    public synchronized boolean addIfAbsent(E element) {
        // Copy while checking if already present.
        // This wins in the most common case where it is not present
        int len = array_.length;
        E[] newArray = new E[len + 1];
        for (int i = 0; i < len; ++i) {
            if (element == array_[i] ||
            (element != null && element.equals(array_[i])))
                return false; // exit, throwing away copy
            else
                newArray[i] = array_[i];
        }
        newArray[len] = element;
        array_ = newArray;
        return true;
    }

    /**
     * Returns true if this Collection contains all of the elements in the
     * specified Collection.
     * <p>
     * This implementation iterates over the specified Collection, checking
     * each element returned by the Iterator in turn to see if it's
     * contained in this Collection.  If all elements are so contained
     * true is returned, otherwise false.
     *
     */
    public <T> boolean containsAll(Collection<T> c) {
        E[] elementData = array();
        int len = elementData.length;
        Iterator<T> e = c.iterator();
        while (e.hasNext())
            if(indexOf(e.next(), elementData, len) < 0)
                return false;

        return true;
    }


    /**
     * Removes from this Collection all of its elements that are contained in
     * the specified Collection. This is a particularly expensive operation
     * in this class because of the need for an internal temporary array.
     * <p>
     *
     * @return true if this Collection changed as a result of the call.
     */
    public synchronized <T> boolean removeAll(Collection<T> c) {
        E[] elementData = array_;
        int len = elementData.length;
        if (len == 0) return false;

        // temp array holds those elements we know we want to keep
        E[] temp = new E[len];
        int newlen = 0;
        for (int i = 0; i < len; ++i) {
            E element = elementData[i];
            if (!c.contains(element)) {
                temp[newlen++] = element;
            }
        }

        if (newlen == len) return false;

        //  copy temp as new array
        E[] newArray = new E[newlen];
        System.arraycopy(temp, 0, newArray, 0, newlen);
        array_ = newArray;
        return true;
    }

    /**
     * Retains only the elements in this Collection that are contained in the
     * specified Collection (optional operation).  In other words, removes from
     * this Collection all of its elements that are not contained in the
     * specified Collection.
     * @return true if this Collection changed as a result of the call.
     */
    public synchronized <T> boolean retainAll(Collection<T> c) {
        E[] elementData = array_;
        int len = elementData.length;
        if (len == 0) return false;

        E[] temp = new E[len];
        int newlen = 0;
        for (int i = 0; i < len; ++i) {
            E element = elementData[i];
            if (c.contains(element)) {
                temp[newlen++] = element;
            }
        }

        if (newlen == len) return false;

        E[] newArray = new E[newlen];
        System.arraycopy(temp, 0, newArray, 0, newlen);
        array_ = newArray;
        return true;
    }

    /**
     * Appends all of the elements in the specified Collection that
     * are not already contained in this list, to the end of
     * this list, in the order that they are returned by the
     * specified Collection's Iterator.
     *
     * @param c elements to be added into this list.
     * @return the number of elements added
     */
    public synchronized <T extends E> int addAllAbsent(Collection<T> c) {
        int numNew = c.size();
        if (numNew == 0) return 0;

        E[] elementData = array_;
        int len = elementData.length;

        E[] temp = new E[numNew];
        int added = 0;
        Iterator<T> e = c.iterator();
        while (e.hasNext()) {
            E element = e.next();
            if (indexOf(element, elementData, len) < 0) {
                if (indexOf(element, temp, added) < 0) {
                    temp[added++] = element;
                }
            }
        }

        if (added == 0) return 0;

        E[] newArray = new E[len+added];
        System.arraycopy(elementData, 0, newArray, 0, len);
        System.arraycopy(temp, 0, newArray, len, added);
        array_ = newArray;
        return added;
    }

    /**
     * Removes all of the elements from this list.
     *
     */
    public synchronized void clear() {
        array_ = new E[0];
    }

    /**
     * Appends all of the elements in the specified Collection to the end of
     * this list, in the order that they are returned by the
     * specified Collection's Iterator.
     *
     * @param c elements to be inserted into this list.
     */
    public synchronized <T extends E> boolean addAll(Collection<T> c) {
        int numNew = c.size();
        if (numNew == 0) return false;

        int len = array_.length;
        E[] newArray = new E[len+numNew];
        System.arraycopy(array_, 0, newArray, 0, len);
        Iterator<T> e = c.iterator();
        for (int i=0; i<numNew; i++)
            newArray[len++] = e.next();
        array_ = newArray;

        return true;
    }

    /**
     * Inserts all of the elements in the specified Collection into this
     * list, starting at the specified position.  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 the list in the order that they are returned by the
     * specified Collection's iterator.
     *
     * @param index index at which to insert first element
     *                from the specified collection.
     * @param c elements to be inserted into this list.
     * @exception IndexOutOfBoundsException index out of range (index
     *              &lt; 0 || index &gt; size()).
     */
    public synchronized <T extends E> boolean addAll(int index, Collection<T> c) {
        int len = array_.length;
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+len);

        int numNew = c.size();
        if (numNew == 0) return false;

        E[] newArray = new E[len+numNew];
        System.arraycopy(array_, 0, newArray, 0, len);
        int numMoved = len - index;
        if (numMoved > 0)
            System.arraycopy(array_, index, newArray, index + numNew, numMoved);
        Iterator<T> e = c.iterator();
        for (int i=0; i<numNew; i++)
            newArray[index++] = e.next();
        array_ = newArray;

        return true;
    }

    /**
     * Check if the given index is in range.  If not, throw an appropriate
     * runtime exception.
     */
    private void rangeCheck(int index, int length) {
        if (index >= length || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+ length);
    }

    /**
     * Save the state of the list to a stream (i.e., serialize it).
     *
     * @serialData The length of the array backing the list is emitted
     *               (int), followed by all of its elements (each an Object)
     *               in the proper order.
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{

        // Write out element count, and any hidden stuff
        s.defaultWriteObject();

        E[] elementData = array();
        // Write out array length
        s.writeInt(elementData.length);

        // Write out all elements in the proper order.
        for (int i=0; i<elementData.length; i++)
            s.writeObject(elementData[i]);
    }

    /**
     * Reconstitute the list from a stream (i.e., deserialize it).
     */
    private synchronized void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in array length and allocate array
        int arrayLength = s.readInt();
        E[] elementData = new E[arrayLength];

        // Read in all elements in the proper order.
        for (int i=0; i<elementData.length; i++)
            elementData[i] = (E) s.readObject();
        array_ = elementData;
    }

    /**
     * Returns a string representation of this Collection, containing
     * the String representation of each element.
     */
    public String toString() {
        StringBuffer buf = new StringBuffer();
        Iterator e = iterator();
        buf.append("[");
        int maxIndex = size() - 1;
        for (int i = 0; i <= maxIndex; i++) {
            buf.append(String.valueOf(e.next()));
            if (i < maxIndex)
                buf.append(", ");
        }
        buf.append("]");
        return buf.toString();
    }


    /**
     * Compares the specified Object with this List for equality.  Returns true
     * if and only if the specified Object is also a List, both Lists have the
     * same size, and all corresponding pairs of elements in the two Lists are
     * <em>equal</em>.  (Two elements <code>e1</code> and <code>e2</code> are
     * <em>equal</em> if <code>(e1==null ? e2==null : e1.equals(e2))</code>.)
     * In other words, two Lists are defined to be equal if they contain the
     * same elements in the same order.
     * <p>
     * This implementation first checks if the specified object is this
     * List. If so, it returns true; if not, it checks if the specified
     * object is a List. If not, it returns false; if so, it iterates over
     * both lists, comparing corresponding pairs of elements.  If any
     * comparison returns false, this method returns false.  If either
     * Iterator runs out of elements before before the other it returns false
     * (as the Lists are of unequal length); otherwise it returns true when
     * the iterations complete.
     *
     * @param o the Object to be compared for equality with this List.
     * @return true if the specified Object is equal to this List.
     */
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;

        List<E> l2 = (List)(o);
        if (size() != l2.size())
            return false;

        ListIterator<E> e1 = listIterator();
        ListIterator<E> e2 = l2.listIterator();
        while(e1.hasNext()) {
            E o1 = e1.next();
            E o2 = e2.next();
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return true;
    }

    /**
     * Returns the hash code value for this List.
     * <p>
     * This implementation uses exactly the code that is used to define
     * the List hash function in the documentation for List.hashCode.
     */
    public int hashCode() {
        int hashCode = 1;
        Iterator<E> i = iterator();
        while (i.hasNext()) {
            E obj = i.next();
            hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
        }
        return hashCode;
    }

    /**
     * Returns an Iterator over the elements contained in this collection.
     * The iterator provides a snapshot of the state of the list
     * when the iterator was constructed. No synchronization is
     * needed while traversing the iterator. The iterator does
     * <em>NOT</em> support the <code>remove</code> method.
     */
    public Iterator<E> iterator() {
        return new COWIterator<E>(array(), 0);
    }

    /**
     * Returns an Iterator of the elements in this List (in proper sequence).
     * The iterator provides a snapshot of the state of the list
     * when the iterator was constructed. No synchronization is
     * needed while traversing the iterator. The iterator does
     * <em>NOT</em> support the <code>remove</code>, <code>set</code>,
     * or <code>add</code> methods.
     *
     */
    public ListIterator<E> listIterator() {
        return new COWIterator<E>(array(), 0);
    }

    /**
     * Returns a ListIterator of the elements in this List (in proper
     * sequence), starting at the specified position in the List.  The
     * specified index indicates the first element that would be returned by
     * an initial call to nextElement.  An initial call to previousElement
     * would return the element with the specified index minus one.
     * The ListIterator returned by this implementation will throw
     * an UnsupportedOperationException in its remove, set and
     * add methods.
     *
     * @param index index of first element to be returned from the
     *                ListIterator (by a call to getNext).
     * @exception IndexOutOfBoundsException index is out of range
     *              (index &lt; 0 || index &gt; size()).
     */
    public ListIterator<E> listIterator(final int index) {
        E[] elementData = array();
        int len = elementData.length;
        if (index<0 || index>len)
            throw new IndexOutOfBoundsException("Index: "+index);

        return new COWIterator<E>(array(), index);
    }

    private static class COWIterator<E> implements ListIterator<E> {

        /** Snapshot of the array **/
        private final E[] array;

        /**
         * Index of element to be returned by subsequent call to next.
         */
        private int cursor;

        private COWIterator(E[] elementArray, int initialCursor) {
            array = elementArray;
            cursor = initialCursor;
        }

        public boolean hasNext() {
            return cursor < array.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        public E next() {
            try {
                return array[cursor++];
            }
            catch (IndexOutOfBoundsException ex) {
                throw new NoSuchElementException();
            }
        }

        public E previous() {
            try {
                return array[--cursor];
            } catch(IndexOutOfBoundsException e) {
                throw new NoSuchElementException();
            }
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor-1;
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @exception UnsupportedOperationException remove is not supported
         *            by this Iterator.
         */

        public void remove() {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @exception UnsupportedOperationException set is not supported
         *            by this Iterator.
         */
        public void set(E o) {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @exception UnsupportedOperationException add is not supported
         *            by this Iterator.
         */
        public void add(E o) {
            throw new UnsupportedOperationException();
        }
    }


    /**
     * Returns a view of the portion of this List between fromIndex,
     * inclusive, and toIndex, exclusive.  The returned List is backed by this
     * List, so changes in the returned List are reflected in this List, and
     * vice-versa.  While mutative operations are supported, they are
     * probably not very useful for CopyOnWriteArrays.
     * </p>
     * The semantics of the List returned by this method become undefined if
     * the backing list (i.e., this List) is <i>structurally modified</i> in
     * any way other than via the returned List.  (Structural modifications are
     * those that change the size of the List, or otherwise perturb it in such
     * a fashion that iterations in progress may yield incorrect results.)
     *
     * @param fromIndex low endpoint (inclusive) of the subList.
     * @param toKey high endpoint (exclusive) of the subList.
     * @return a view of the specified range within this List.
     * @exception IndexOutOfBoundsException Illegal endpoint index value
     *     (fromIndex &lt; 0 || toIndex &gt; size || fromIndex &gt; toIndex).
     */
    public synchronized List<E> subList(int fromIndex, int toIndex) {
        // synchronized since sublist ctor depends on it.
        int len = array_.length;
        if (fromIndex<0 || toIndex>len  || fromIndex>toIndex)
            throw new IndexOutOfBoundsException();
        return new COWSubList<E>(this, fromIndex, toIndex);
    }

    private static class COWSubList<E> extends AbstractList<E> {

        /*
          This class extends AbstractList merely for convenience, to
          avoid having to define addAll, etc. This doesn't hurt, but
          is wasteful.  This class does not need or use modCount
          mechanics in AbstractList, but does need to check for
          concurrent modification using similar mechanics.  On each
          operation, the array that we expect the backing list to use
          is checked and updated.  Since we do this for all of the
          base operations invoked by those defined in AbstractList,
          all is well.  While inefficient, this is not worth
          improving.  The kinds of list operations inherited from
          AbstractList are are already so slow on COW sublists that
          adding a bit more space/time doesn't seem even noticeable.
         */

        private final CopyOnWriteArrayList<E> l;
        private final int offset;
        private int size;
        private E[] expectedArray;

        private COWSubList(CopyOnWriteArrayList<E> list,
        int fromIndex, int toIndex) {
            l = list;
            expectedArray = l.array();
            offset = fromIndex;
            size = toIndex - fromIndex;
        }

        // only call this holding l's lock
        private void checkForComodification() {
            if (l.array_ != expectedArray)
                throw new ConcurrentModificationException();
        }

        // only call this holding l's lock
        private void rangeCheck(int index) {
            if (index<0 || index>=size)
                throw new IndexOutOfBoundsException("Index: "+index+ ",Size: "+size);
        }


        public E set(int index, E element) {
            synchronized(l) {
                rangeCheck(index);
                checkForComodification();
                E x = l.set(index+offset, element);
                expectedArray = l.array_;
                return x;
            }
        }

        public E get(int index) {
            synchronized(l) {
                rangeCheck(index);
                checkForComodification();
                return l.get(index+offset);
            }
        }

        public int size() {
            synchronized(l) {
                checkForComodification();
                return size;
            }
        }

        public void add(int index, E element) {
            synchronized(l) {
                checkForComodification();
                if (index<0 || index>size)
                    throw new IndexOutOfBoundsException();
                l.add(index+offset, element);
                expectedArray = l.array_;
                size++;
            }
        }

        public E remove(int index) {
            synchronized(l) {
                rangeCheck(index);
                checkForComodification();
                E result = l.remove(index+offset);
                expectedArray = l.array_;
                size--;
                return result;
            }
        }

        public Iterator<E> iterator() {
            synchronized(l) {
                checkForComodification();
                return new COWSubListIterator(0);
            }
        }

        public ListIterator<E> listIterator(final int index) {
            synchronized(l) {
                checkForComodification();
                if (index<0 || index>size)
                    throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
                return new COWSubListIterator(index);
            }
        }

        private class COWSubListIterator implements ListIterator<E> {
            private final ListIterator<E> i;
            private final int index;
            private COWSubListIterator(int index) {
                this.index = index;
                i = l.listIterator(index+offset);
            }

            public boolean hasNext() {
                return nextIndex() < size;
            }

            public E next() {
                if (hasNext())
                    return i.next();
                else
                    throw new NoSuchElementException();
            }

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

            public E previous() {
                if (hasPrevious())
                    return i.previous();
                else
                    throw new NoSuchElementException();
            }

            public int nextIndex() {
                return i.nextIndex() - offset;
            }

            public int previousIndex() {
                return i.previousIndex() - offset;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }

            public void set(E o) {
                throw new UnsupportedOperationException();
            }

            public void add(E o) {
                throw new UnsupportedOperationException();
            }
        }


        public List<E> subList(int fromIndex, int toIndex) {
            synchronized(l) {
                checkForComodification();
                if (fromIndex<0 || toIndex>size)
                    throw new IndexOutOfBoundsException();
                return new COWSubList<E>(l, fromIndex+offset, toIndex+offset);
            }
        }

    }

}
Revision:	1.3
Committed:	Fri Jun 6 16:53:04 2003 UTC (21 years ago) by dl
Branch:	MAIN
Changes since 1.2:	+12 -2 lines
Log Message:	Minor doc updates; FairReentrantLock serialize now