gcc/libjava/java/util/ArrayList.java

/* ArrayList.java -- JDK1.2's answer to Vector; this is an array-backed
   implementation of the List interface
   Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */


package java.util;

import java.lang.reflect.Array;
import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;

/**
 * An array-backed implementation of the List interface.  ArrayList
 * performs well on simple tasks:  random access into a list, appending
 * to or removing from the end of a list, checking the size, &c.
 *
 * @author        Jon A. Zeppieri
 * @version       $Id: ArrayList.java,v 1.4 2000/03/15 21:59:06 rao Exp $
 * @see           java.util.AbstractList
 * @see           java.util.List
 */
public class ArrayList extends AbstractList 
  implements List, Cloneable, Serializable
{
  /** the default capacity for new ArrayLists */
  private static final int DEFAULT_CAPACITY = 16;

  /** the number of elements in this list */
  int _iSize;

  /** where the data is stored */
  Object[] _arData;

  /** used for serialization -- denotes which fields are serialized */
  private static final ObjectStreamField[] serialPersistentFields =
  {new ObjectStreamField("size", int.class)};

  /** 
   * Construct a new ArrayList with the supplied initial capacity. 
   *
   * @param     iCapacity
   */
  public ArrayList(int iCapacity)
  {
    _arData = new Object[iCapacity];
  }


  /**
   * Construct a new ArrayList with the default capcity 
   */
  public ArrayList()
  {
    this(DEFAULT_CAPACITY);
  }

  /** 
   * Construct a new ArrayList, and initialize it with the elements
   * in the supplied Collection; Sun specs say that the initial 
   * capacity is 110% of the Collection's size.
   *
   * @param        oCollection     the collection whose elements will
   *                               initialize this list
   */
  public ArrayList(Collection oCollection)
  {
    this((int) (oCollection.size() * 1.1));
    addAll(oCollection);
  }

  /**
   * Guarantees that this list will have at least enough capacity to
   * hold iMinCapacity elements.
   *
   * @param      iMinCapacity     the minimum guaranteed capacity
   */
  public void ensureCapacity(int iMinCapacity)
  {
    Object[] arNewData;
    int iCapacity = _arData.length;

    if (iMinCapacity > iCapacity)
    {
      arNewData = new Object[Math.max((iCapacity * 2), iMinCapacity)];
      System.arraycopy(_arData, 0, arNewData, 0, iCapacity);
      _arData = arNewData;
    }
  }

  /**
   * Appends the supplied element to the end of this list.
   *
   * @param       oElement      the element to be appended to this list
   */
  public boolean add(Object oElement)
  {
    ensureCapacity(_iSize + 1);
    _arData[_iSize++] = oElement;
    modCount++;
    return true;
  }

  /**
   * Retrieves the element at the user-supplied index.
   *
   * @param    iIndex        the index of the element we are fetching
   * @throws   IndexOutOfBoundsException  (iIndex < 0) || (iIndex >= size())
   */
  public Object get(int iIndex)
  {
    if (iIndex >= _iSize)
      throw new IndexOutOfBoundsException("ArrayList size=" +
                                          String.valueOf(_iSize) + "; " +
                                          "index=" + String.valueOf(iIndex));
    return _arData[iIndex];
  }

  /**
   * Returns the number of elements in this list 
   */
  public int size()
  {
    return _iSize;
  }

  /**
   * Removes the element at the user-supplied index
   *
   * @param     iIndex      the index of the element to be removed
   * @return    the removed Object
   * @throws    IndexOutOfBoundsException  (iIndex < 0) || (iIndex >= size())
   */
  public Object remove(int iIndex)
  {
    Object oResult;

    if (iIndex >= _iSize)
      throw new IndexOutOfBoundsException("ArrayList size=" +
                                          String.valueOf(_iSize) + "; " +
                                          "index=" + String.valueOf(iIndex));

    oResult = _arData[iIndex];

    if (iIndex != --_iSize)
      System.arraycopy(_arData, (iIndex + 1), _arData, iIndex, 
                       (_iSize - iIndex));
  
    modCount++;
    _arData[_iSize] = null;

    return oResult;
  }

  /**
   * Removes all elements in the half-open interval [iFromIndex, iToIndex).
   *
   * @param     iFromIndex   the first index which will be removed
   * @param     iToIndex     one greater than the last index which will be 
   *                         removed
   */
  public void removeRange(int iFromIndex, int iToIndex)
  {
    int iReduction;
    int i;

    if ((iFromIndex >= _iSize) || (iToIndex >= _iSize))
    {
      throw new IndexOutOfBoundsException("ArrayList size=" +
                                          String.valueOf(_iSize) + "; " +
                                          "indices=" + 
                                          String.valueOf(iFromIndex) + "," +
                                          String.valueOf(iToIndex));
    }
    else if (iFromIndex > iToIndex)
    {
      throw new IllegalArgumentException("fromIndex(" + 
                                         String.valueOf(iFromIndex) + 
                                         ") > toIndex(" +
                                         String.valueOf(iToIndex) + ")");
    }
    else if (iFromIndex != iToIndex)
    {
      iReduction = iToIndex - iFromIndex;
      System.arraycopy(_arData, (iFromIndex + iReduction), _arData,
                       iFromIndex, (_iSize - iFromIndex - iReduction));
      modCount++;

      for (i = (iFromIndex + iReduction); i < _iSize; i++)
        _arData[i] = null;

      _iSize -= iReduction;
    }
  }

  /**
   * Adds the supplied element at the specified index, shifting all
   * elements currently at that index or higher one to the right.
   *
   * @param     iIndex      the index at which the element is being added
   * @param     oElement    the element being added
   */
  public void add(int iIndex, Object oElement)
  {
    if (iIndex > _iSize)
      throw new IndexOutOfBoundsException("ArrayList size=" +
                                          String.valueOf(_iSize) + "; " +
                                          "index=" + String.valueOf(iIndex));

    ensureCapacity(_iSize + 1);
    System.arraycopy(_arData, iIndex, _arData, 
                      (iIndex + 1), (_iSize - iIndex));
    _arData[iIndex] = oElement;
    _iSize++;
    modCount++;
  }

  /** 
   * Add each element in the supplied Collection to this List.
   *
   * @param        oCollection     a Collection containing elements to be 
   *                               added to this List
   */
  public boolean addAll(Collection oCollection)
  {
    Iterator itElements;
    int iLen = oCollection.size();

    if (iLen > 0)
    {
      ensureCapacity(_iSize + iLen);
      modCount++;

      itElements = oCollection.iterator();

      while (itElements.hasNext())
        _arData[_iSize++] = itElements.next();

      return true;
    }
    return false;
  }

  /** 
   * Add all elements in the supplied collection, inserting them beginning
   * at the specified index.
   *
   * @param     iIndex       the index at which the elements will be inserted
   * @param     oCollection  the Collection containing the elements to be
   *                         inserted
   */
  public boolean addAll(int iIndex, Collection oCollection)
  {
    Iterator itElements;
    int iLen;

    if (iIndex > _iSize)
      throw new IndexOutOfBoundsException("ArrayList size=" +
                                          String.valueOf(_iSize) + "; " +
                                          "index=" + String.valueOf(iIndex));

    iLen = oCollection.size();

    if (iLen > 0)
    {
      ensureCapacity(_iSize + iLen);

      System.arraycopy(_arData, iIndex, _arData, 
                       (iIndex + iLen), (_iSize - iIndex));
      modCount++;
      _iSize += iLen;

      itElements = oCollection.iterator();
      while (itElements.hasNext())
        _arData[iIndex++] = itElements.next();

      return true;
   }
    return false;
  }

  /**
   * Creates a shallow copy of this ArrayList
   */
  public Object clone()
  {
    ArrayList oClone;

    try
    {
      oClone = (ArrayList) super.clone();
      oClone._arData = _arData;
      oClone._iSize = _iSize;
    }
    catch(CloneNotSupportedException e)
    {
      oClone = null;
    }
    return oClone;
  }

  /** 
   * Returns true iff oElement is in this ArrayList.
   *
   * @param     oElement     the element whose inclusion in the List is being
   *                         tested
   */
  public boolean contains(Object oElement)
  {
    return (indexOf(oElement) != -1);
  }

  /**
   * Returns the lowest index at which oElement appears in this List, or 
   * -1 if it does not appear.
   *
   * @param    oElement       the element whose inclusion in the List is being
   *                          tested
   */
  public int indexOf(Object oElement)
  {
    int i;

    for (i = 0; i < _iSize; i++)
    {
      if (doesEqual(oElement, _arData[i]))
        return i;
    }
    return -1;
  }

  /**
   * Returns the highest index at which oElement appears in this List, or 
   * -1 if it does not appear.
   *
   * @param    oElement       the element whose inclusion in the List is being
   *                          tested
   */
  public int lastIndexOf(Object oElement)
  {
    int i;

    for (i = _iSize - 1; i >= 0; i--)
    {
      if (doesEqual(oElement, _arData[i]))
        return i;
    }
    return -1;
  }

  /**
   * Removes all elements from this List
   */
  public void clear()
  {
    int i;

    if (_iSize > 0)
    {
      modCount++;
      _iSize = 0;

      for (i = 0; i < _iSize; i++)
        _arData[i] = null;
    }      
  }

  /**
   * Sets the element at the specified index.
   *
   * @param     iIndex     the index at which the element is being set
   * @param     oElement   the element to be set
   * @return    the element previously at the specified index, or null if
   *            none was there
   */
  public Object set(int iIndex, Object oElement)
  {
    Object oResult;

    if (iIndex >= _iSize)
      throw new IndexOutOfBoundsException("ArrayList size=" +
                                          String.valueOf(_iSize) + "; " +
                                          "index=" + String.valueOf(iIndex));
    oResult = _arData[iIndex];
    // SEH: no structural change, so don't update modCount
    _arData[iIndex] = oElement;

    return oResult;
  }

  /**
   * Returns an Object Array containing all of the elements in this ArrayList
   */
  public Object[] toArray()
  {
    Object[] arObjects = new Object[_iSize];
    System.arraycopy(_arData, 0, arObjects, 0, _iSize);
    return arObjects;
  }

  /**
   * Returns an Array whse component type is the runtime component type of
   * the passes-in Array.  The returned Array is populated with all of the
   * elements in this ArrayList.  If the passed-in Array is not large enough
   * to store all of the elements in this List, a new Array will be created 
   * and returned; if the passed-in Array is <i>larger</i> than the size
   * of this List, then size() + 1 index will be set to null.
   *
   * @param      arObjects      the passed-in Array
   */
  public Object[] toArray(Object[] arObjects)
  {
    Object[] arReturn = (arObjects.length >= _iSize)
      ? arObjects 
      : (Object[])
      Array.newInstance(arObjects.getClass().getComponentType(), _iSize);

    System.arraycopy(_arData, 0, arReturn, 0, _iSize);

    if (arReturn.length > _iSize)
      arReturn[_iSize] = null;

    return arReturn;
  }

  /**
   * Trims the capacity of tjis List to be equal to its size; 
   * a memory saver. 
   */
  public void trimToSize()
  {
    Object[] arNewData = new Object[_iSize];
    System.arraycopy(_arData, 0, arNewData, 0, _iSize);
    modCount++;
    _arData = arNewData;
  }

  private void writeObject(ObjectOutputStream oOut)
    throws IOException
  {
    int i;

    ObjectOutputStream.PutField oFields = oOut.putFields();
    oFields.put("size", _iSize);
    oOut.writeFields();

    oOut.writeInt(_arData.length);
    for (i = 0; i < _arData.length; i++)
      oOut.writeObject(_arData[i]);
  }

  private void readObject(ObjectInputStream oIn)
    throws IOException, ClassNotFoundException
  {
    int i;
    int iCapacity;

    ObjectInputStream.GetField oFields = oIn.readFields();
    _iSize = oFields.get("size", 0);

    iCapacity = oIn.readInt();
    _arData = new Object[iCapacity];

    for (i = 0; i < iCapacity; i++)
      _arData[i] = oIn.readObject();
  }

  private static final boolean doesEqual(Object oOne, Object oTwo)
  {
    return ((oOne == null) ? (oTwo == null) : oOne.equals(oTwo));
  }
}