## org.eclipse.emf.common.util
Class BasicEList<E>

    java.lang.Object
      java.util.AbstractCollection<E>
          java.util.AbstractList<E>
              org.eclipse.emf.common.util.AbstractEList<E>
                  org.eclipse.emf.common.util.BasicEList<E>

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<E>, java.util.Collection<E>, java.util.List<E>, java.util.RandomAccess, EList<E>

Direct Known Subclasses:
  AbstractTreeIterator, BasicEList.FastCompare, BasicEList.UnmodifiableEList, BasicInternalEList, BasicNotifierImpl.EAdapterList, ExtensibleURIConverterImpl.ContentHandlerList, ExtensibleURIConverterImpl.URIHandlerList, NotificationChainImpl, NotifyingListImpl, StringSegment, UniqueEList, XMLHandler.MyStack

    public class BasicEList<E>

extends AbstractEList<E>
implements java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable

A highly extensible list implementation.

See Also:
  Serialized Form

Nested Class Summary
`protected static class` `BasicEList.BasicIndexOutOfBoundsException` An IndexOutOfBoundsException that constructs a message from the argument data.
`protected class` `BasicEList.EIterator<E1>` Deprecated.
`protected class` `BasicEList.EListIterator<E1>` Deprecated.
`static class` `BasicEList.FastCompare<E>` A `BasicEList` that `uses` `==` instead of `equals` to compare members.
`protected class` `BasicEList.NonResolvingEIterator<E1>` Deprecated.
`protected class` `BasicEList.NonResolvingEListIterator<E1>` Deprecated.
`static class` `BasicEList.UnmodifiableEList<E>` An unmodifiable version of `BasicEList`.

Field Summary
`protected java.lang.Object[]` `data` The underlying data storage of the list.
`protected int` `size` The size of the list.

Fields inherited from class java.util.AbstractList
`modCount`

Constructor Summary
`` `BasicEList()` Creates an empty instance with no initial capacity.
`` `BasicEList(java.util.Collection<? extends E> collection)` Creates an instance that is a copy of the collection.
`` `BasicEList(int initialCapacity)` Creates an empty instance with the given capacity.
`protected` `BasicEList(int size, java.lang.Object[] data)` Creates an initialized instance that directly uses the given arguments.

Method Summary
`boolean` `addAllUnique(java.util.Collection<? extends E> collection)` Adds each object of the collection to the end of the list; it does no uniqueness checking.
`boolean` `addAllUnique(int index, java.util.Collection<? extends E> collection)` Adds each object of the collection at each successive index in the list and returns whether any objects were added; it does no ranging checking or uniqueness checking.
`boolean` `addAllUnique(int index, java.lang.Object[] objects, int start, int end)` Adds each object from start to end of the array at each successive index in the list and returns whether any objects were added; it does no ranging checking or uniqueness checking.
`boolean` `addAllUnique(java.lang.Object[] objects, int start, int end)` Adds each object from start to end of the array at the index of list and returns whether any objects were added; it does no ranging checking or uniqueness checking.
`void` `addUnique(E object)` Adds the object at the end of the list; it does no uniqueness checking.
`void` `addUnique(int index, E object)` Adds the object at the given index in the list; it does no ranging checking or uniqueness checking.
`protected E` `assign(int index, E object)` Assigns the object into the data storage at the given index and returns the object that's been stored.
`E` `basicGet(int index)` Returns the object at the index without `resolving` it.
`protected java.util.List<E>` `basicList()` Returns an unsafe list that provides a `non-resolving` view of the underlying data storage.
`void` `clear()` Clears the list of all objects.
`java.lang.Object` `clone()` Returns a shallow copy of this list.
`boolean` `contains(java.lang.Object object)` Returns whether the list contains the object.
`java.lang.Object[]` `data()` Returns direct unsafe access to the underlying data storage.
`E` `get(int index)` Returns the object at the index.
`void` `grow(int minimumCapacity)` Grows the capacity of the list to ensure that no additional growth is needed until the size exceeds the specified minimum capacity.
`int` `indexOf(java.lang.Object object)` Returns the position of the first occurrence of the object in the list.
`boolean` `isEmpty()` Returns whether the list has zero size.
`int` `lastIndexOf(java.lang.Object object)` Returns the position of the last occurrence of the object in the list.
`E` `move(int targetIndex, int sourceIndex)` Moves the object at the source index of the list to the target index of the list and returns the moved object.
`protected java.lang.Object[]` `newData(int capacity)` Returns new allocated data storage.
`protected E` `primitiveGet(int index)` Returns the object at the index without `resolving` it and without range checking the index.
`E` `remove(int index)` Removes the object at the index from the list and returns it.
`void` `setData(int size, java.lang.Object[] data)` Updates directly and unsafely the underlying data storage.
`E` `setUnique(int index, E object)` Sets the object at the index and returns the old object at the index; it does no ranging checking or uniqueness checking.
`void` `shrink()` Shrinks the capacity of the list to the minimal requirements.
`int` `size()` Returns the number of objects in the list.
`java.lang.Object[]` `toArray()` Returns an array containing all the objects in sequence.

`

`<T> T[]`

`

`toArray(T[] array)`
Returns an array containing all the objects in sequence.

Methods inherited from class org.eclipse.emf.common.util.AbstractEList
`add, add, addAll, addAll, basicIterator, basicListIterator, basicListIterator, canContainNull, didAdd, didChange, didClear, didMove, didRemove, didSet, equalObjects, equals, getDuplicates, getNonDuplicates, hashCode, isUnique, iterator, listIterator, listIterator, move, remove, removeAll, resolve, retainAll, set, toString, useEquals, validate`

Methods inherited from class java.util.AbstractList
`removeRange, subList`

Methods inherited from class java.util.AbstractCollection
`containsAll`

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface java.util.List
`containsAll, subList`

Field Detail

### size

    protected int size

  The size of the list.

### data

    protected transient java.lang.Object[] data

  The underlying data storage of the list.

Constructor Detail

### BasicEList

    public BasicEList()

  Creates an empty instance with no initial capacity. The data storage will be null.

### BasicEList

    public BasicEList(int initialCapacity)

  Creates an empty instance with the given capacity.

  Parameters:
    `initialCapacity` - the initial capacity of the list before it must grow.
  Throws:
    `java.lang.IllegalArgumentException` - if the `initialCapacity` is negative.

### BasicEList

    public BasicEList(java.util.Collection<? extends E> collection)

  Creates an instance that is a copy of the collection.

  Parameters:
    `collection` - the initial contents of the list.

### BasicEList

    protected BasicEList(int size,
                         java.lang.Object[] data)

  Creates an initialized instance that directly uses the given arguments.

  Parameters:
    `size` - the size of the list.
    `data` - the underlying storage of the list.

Method Detail

### newData

    protected java.lang.Object[] newData(int capacity)

  Returns new allocated data storage. Clients may override this to create typed storage. The cost of type checking via a typed array is negligible.

  Returns:
    new data storage.

### assign

    protected E assign(int index,
                       E object)

  Assigns the object into the data storage at the given index and returns the object that's been stored. Clients can monitor access to the storage via this method.

  Parameters:
    `index` - the position of the new content.
    `object` - the new content.
  Returns:
    the object that's been stored.

### size

    public int size()

  Returns the number of objects in the list.

  Specified by:
    `size` in interface `java.util.Collection<E>`
  Specified by:
    `size` in interface `java.util.List<E>`
  Specified by:
    `size` in class `java.util.AbstractCollection<E>`
  Returns:
    the number of objects in the list.

### isEmpty

    public boolean isEmpty()

  Returns whether the list has zero size.

  Specified by:
    `isEmpty` in interface `java.util.Collection<E>`
  Specified by:
    `isEmpty` in interface `java.util.List<E>`
  Overrides:
    `isEmpty` in class `java.util.AbstractCollection<E>`
  Returns:
    whether the list has zero size.

### contains

    public boolean contains(java.lang.Object object)

  Returns whether the list contains the object. This implementation uses either `equals` or `"=="` depending on `useEquals`.

  Specified by:
    `contains` in interface `java.util.Collection<E>`
  Specified by:
    `contains` in interface `java.util.List<E>`
  Overrides:
    `contains` in class `java.util.AbstractCollection<E>`
  Parameters:
    `object` - the object in question.
  Returns:
    whether the list contains the object.
  See Also:
    `AbstractEList.useEquals()`

### indexOf

    public int indexOf(java.lang.Object object)

  Returns the position of the first occurrence of the object in the list. This implementation uses either `equals` or `"=="` depending on `useEquals`.

  Specified by:
    `indexOf` in interface `java.util.List<E>`
  Overrides:
    `indexOf` in class `java.util.AbstractList<E>`
  Parameters:
    `object` - the object in question.
  Returns:
    the position of the first occurrence of the object in the list.

### lastIndexOf

    public int lastIndexOf(java.lang.Object object)

  Returns the position of the last occurrence of the object in the list. This implementation uses either `equals` or `"=="` depending on `useEquals`.

  Specified by:
    `lastIndexOf` in interface `java.util.List<E>`
  Overrides:
    `lastIndexOf` in class `java.util.AbstractList<E>`
  Parameters:
    `object` - the object in question.
  Returns:
    the position of the last occurrence of the object in the list.

### toArray

    public java.lang.Object[] toArray()

  Returns an array containing all the objects in sequence. Clients may override `newData` to create typed storage in this case.

  Specified by:
    `toArray` in interface `java.util.Collection<E>`
  Specified by:
    `toArray` in interface `java.util.List<E>`
  Overrides:
    `toArray` in class `java.util.AbstractCollection<E>`
  Returns:
    an array containing all the objects in sequence.
  See Also:
    `newData(int)`

### toArray

    public <T> T[] toArray(T[] array)

  Returns an array containing all the objects in sequence.

  Specified by:
    `toArray` in interface `java.util.Collection<E>`
  Specified by:
    `toArray` in interface `java.util.List<E>`
  Overrides:
    `toArray` in class `java.util.AbstractCollection<E>`
  Parameters:
    `array` - the array that will be filled and returned, if it's big enough; otherwise, a suitably large array of the same type will be allocated and used instead.
  Returns:
    an array containing all the objects in sequence.
  See Also:
    `newData(int)`

### data

    public java.lang.Object[] data()

  Returns direct unsafe access to the underlying data storage. Clients may not modify this and may not assume that the array remains valid as the list is modified.

  Returns:
    direct unsafe access to the underlying data storage.

### setData

    public void setData(int size,
                        java.lang.Object[] data)

  Updates directly and unsafely the underlying data storage. Clients must be aware that this subverts all callbacks and hence possibly the integrity of the list.

### get

    public E get(int index)

  Returns the object at the index. This implementation delegates to `resolve` so that clients may transform the fetched object.

  Specified by:
    `get` in interface `java.util.List<E>`
  Specified by:
    `get` in class `java.util.AbstractList<E>`
  Parameters:
    `index` - the position in question.
  Returns:
    the object at the index.
  Throws:
    `BasicEList.BasicIndexOutOfBoundsException` - if the index isn't within the size range.
  See Also:
    `AbstractEList.resolve(int, E)`, `basicGet(int)`

### basicGet

    public E basicGet(int index)

  Returns the object at the index without `resolving` it.

  Overrides:
    `basicGet` in class `AbstractEList<E>`
  Parameters:
    `index` - the position in question.
  Returns:
    the object at the index.
  Throws:
    `BasicEList.BasicIndexOutOfBoundsException` - if the index isn't within the size range.
  See Also:
    `AbstractEList.resolve(int, E)`, `get(int)`

### primitiveGet

    protected E primitiveGet(int index)

  Returns the object at the index without `resolving` it and without range checking the index.

  Specified by:
    `primitiveGet` in class `AbstractEList<E>`
  Parameters:
    `index` - the position in question.
  Returns:
    the object at the index.
  See Also:
    `AbstractEList.resolve(int, E)`, `get(int)`, `basicGet(int)`

### setUnique

    public E setUnique(int index,
                       E object)

  Sets the object at the index and returns the old object at the index; it does no ranging checking or uniqueness checking. This implementation delegates to `assign`, `didSet`, and `didChange`.

  Specified by:
    `setUnique` in class `AbstractEList<E>`
  Parameters:
    `index` - the position in question.
    `object` - the object to set.
  Returns:
    the old object at the index.
  See Also:
    `AbstractEList.set(int, E)`

### addUnique

    public void addUnique(E object)

  Adds the object at the end of the list; it does no uniqueness checking. This implementation delegates to `assign`, `didAdd`, and `didChange`. after uniqueness checking.

  Specified by:
    `addUnique` in class `AbstractEList<E>`
  Parameters:
    `object` - the object to be added.
  See Also:
    `AbstractEList.add(Object)`

### addUnique

    public void addUnique(int index,
                          E object)

  Adds the object at the given index in the list; it does no ranging checking or uniqueness checking. This implementation delegates to `assign`, `didAdd`, and `didChange`.

  Specified by:
    `addUnique` in class `AbstractEList<E>`
  Parameters:
    `object` - the object to be added.
  See Also:
    `AbstractEList.add(int, Object)`

### addAllUnique

    public boolean addAllUnique(java.util.Collection<? extends E> collection)

  Adds each object of the collection to the end of the list; it does no uniqueness checking. This implementation delegates to `assign`, `didAdd`, and `didChange`.

  Specified by:
    `addAllUnique` in class `AbstractEList<E>`
  Parameters:
    `collection` - the collection of objects to be added.
  See Also:
    `AbstractEList.addAll(Collection)`

### addAllUnique

    public boolean addAllUnique(int index,
                                java.util.Collection<? extends E> collection)

  Adds each object of the collection at each successive index in the list and returns whether any objects were added; it does no ranging checking or uniqueness checking. This implementation delegates to `assign`, `didAdd`, and `didChange`.

  Specified by:
    `addAllUnique` in class `AbstractEList<E>`
  Parameters:
    `index` - the index at which to add.
    `collection` - the collection of objects to be added.
  Returns:
    whether any objects were added.
  See Also:
    `AbstractEList.addAll(int, Collection)`

### addAllUnique

    public boolean addAllUnique(java.lang.Object[] objects,
                                int start,
                                int end)

  Adds each object from start to end of the array at the index of list and returns whether any objects were added; it does no ranging checking or uniqueness checking. This implementation delegates to `assign`, `didAdd`, and `didChange`.

  Specified by:
    `addAllUnique` in class `AbstractEList<E>`
  Parameters:
    `objects` - the objects to be added.
    `start` - the index of first object to be added.
    `end` - the index past the last object to be added.
  Returns:
    whether any objects were added.
  See Also:
    `addAllUnique(Object[], int, int)`

### addAllUnique

    public boolean addAllUnique(int index,
                                java.lang.Object[] objects,
                                int start,
                                int end)

  Adds each object from start to end of the array at each successive index in the list and returns whether any objects were added; it does no ranging checking or uniqueness checking. This implementation delegates to `assign`, `didAdd`, and `didChange`.

  Specified by:
    `addAllUnique` in class `AbstractEList<E>`
  Parameters:
    `index` - the index at which to add.
    `objects` - the objects to be added.
    `start` - the index of first object to be added.
    `end` - the index past the last object to be added.
  Returns:
    whether any objects were added.
  See Also:
    `addAllUnique(Object[], int, int)`

### remove

    public E remove(int index)

  Removes the object at the index from the list and returns it. This implementation delegates to `didRemove` and `didChange`.

  Specified by:
    `remove` in interface `java.util.List<E>`
  Specified by:
    `remove` in class `AbstractEList<E>`
  Parameters:
    `index` - the position of the object to remove.
  Returns:
    the removed object.
  Throws:
    `BasicEList.BasicIndexOutOfBoundsException` - if the index isn't within the size range.

### clear

    public void clear()

  Clears the list of all objects. This implementation discards the data storage without modifying it and delegates to `didClear` and `didChange`.

  Specified by:
    `clear` in interface `java.util.Collection<E>`
  Specified by:
    `clear` in interface `java.util.List<E>`
  Overrides:
    `clear` in class `java.util.AbstractList<E>`

### move

    public E move(int targetIndex,
                  int sourceIndex)

  Moves the object at the source index of the list to the target index of the list and returns the moved object. This implementation delegates to `assign`, `didMove`, and `didChange`.

  Specified by:
    `move` in interface `EList<E>`
  Specified by:
    `move` in class `AbstractEList<E>`
  Parameters:
    `targetIndex` - the new position for the object in the list.
    `sourceIndex` - the old position of the object in the list.
  Returns:
    the moved object.
  Throws:
    `BasicEList.BasicIndexOutOfBoundsException` - if either index isn't within the size range.

### shrink

    public void shrink()

  Shrinks the capacity of the list to the minimal requirements.

  See Also:
    `grow(int)`

### grow

    public void grow(int minimumCapacity)

  Grows the capacity of the list to ensure that no additional growth is needed until the size exceeds the specified minimum capacity.

  See Also:
    `shrink()`

### clone

    public java.lang.Object clone()

  Returns a shallow copy of this list.

  Overrides:
    `clone` in class `java.lang.Object`
  Returns:
    a shallow copy of this list.

### basicList

    protected java.util.List<E> basicList()

  Returns an unsafe list that provides a `non-resolving` view of the underlying data storage.

  Specified by:
    `basicList` in class `AbstractEList<E>`
  Returns:
    an unsafe list that provides a non-resolving view of the underlying data storage.

Copyright 2001-2006 IBM Corporation and others. All Rights Reserved.