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

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

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

Direct Known Subclasses:
  DelegatingEList.UnmodifiableEList, DelegatingNotifyingListImpl

    public abstract class DelegatingEList<E>

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

A highly extensible delegating list implementation.

See Also:
  Serialized Form

Nested Class Summary
`protected class` `DelegatingEList.EIterator<E1>` Deprecated.
`protected class` `DelegatingEList.EListIterator<E1>` Deprecated.
`protected class` `DelegatingEList.NonResolvingEIterator<E1>` Deprecated.
`protected class` `DelegatingEList.NonResolvingEListIterator<E1>` Deprecated.
`static class` `DelegatingEList.UnmodifiableEList<E>` An unmodifiable version of `DelegatingEList`.

Nested classes/interfaces inherited from class org.eclipse.emf.common.util.AbstractEList
`AbstractEList.BasicIndexOutOfBoundsException`

Field Summary

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

Constructor Summary
`DelegatingEList()` Creates an empty instance.
`DelegatingEList(java.util.Collection<? extends E> collection)` Creates an instance that is a copy of the collection.

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` `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 backing store list.
`void` `clear()` Clears the list of all objects.
`boolean` `contains(java.lang.Object object)` Returns whether the list contains the object.
`boolean` `containsAll(java.util.Collection<?> collection)` Returns whether the list contains each object in the collection.
`protected void` `delegateAdd(E object)` Adds the object at the end of the backing store list.
`protected void` `delegateAdd(int index, E object)` Adds the object at the given index in the backing store list.
`protected java.util.List<E>` `delegateBasicList()` Returns an unsafe list that provides a `non-resolving` view of the backing store list.
`protected void` `delegateClear()` Clears the backing store list of all objects.
`protected boolean` `delegateContains(java.lang.Object object)` Returns whether the backing store list contains the object.
`protected boolean` `delegateContainsAll(java.util.Collection<?> collection)` Returns whether the backing store list contains each object in the collection.
`protected boolean` `delegateEquals(java.lang.Object object)` Returns whether the object is a list with corresponding equal objects to those in the backing store list.
`protected E` `delegateGet(int index)` Returns the object at the index in the backing store list.
`protected int` `delegateHashCode()` Returns the hash code of the backing store list.
`protected int` `delegateIndexOf(java.lang.Object object)` Returns the position of the first occurrence of the object in the backing store list.
`protected boolean` `delegateIsEmpty()` Returns whether the backing store list has zero size.
`protected java.util.Iterator<E>` `delegateIterator()` Returns an iterator over the backing store list.
`protected int` `delegateLastIndexOf(java.lang.Object object)` Returns the position of the last occurrence of the object in the backing store list.
`protected abstract java.util.List<E>` `delegateList()` Returns the list that acts as the backing store.
`protected java.util.ListIterator<E>` `delegateListIterator()` Returns a list iterator over the backing store list.
`protected E` `delegateMove(int targetIndex, int sourceIndex)` Moves the object at the source index in the backing store list by removing it and adding it at the new target index.
`protected E` `delegateRemove(int index)` Removes the object at the index from the backing store list and returns it.
`protected E` `delegateSet(int index, E object)` Sets the object at the index in the backing store list and returns the old object at the index.
`protected int` `delegateSize()` Returns the number of objects in the backing store list.
`protected java.lang.Object[]` `delegateToArray()` Returns an array containing all the objects in the backing store list in sequence.

`protected

`<T> T[]`

`

`delegateToArray(T[] array)`
Returns an array containing all the objects in the backing store list in sequence.

`protected java.lang.String` `delegateToString()` Returns a the string form of the backing store list.
`protected void` `doClear(int oldSize, java.lang.Object[] oldData)` Does the actual job of clearing all the objects.
`boolean` `equals(java.lang.Object object)` Returns whether the object is a list with corresponding equal objects.
`E` `get(int index)` Returns the object at the index.
`int` `hashCode()` Returns a hash code computed from each object's hash code.
`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 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.
`boolean` `remove(java.lang.Object object)` Removes the object from the list and returns whether the object was actually contained by the list.
`boolean` `removeAll(java.util.Collection<?> collection)` Removes each object of the collection from the list and returns whether any object was actually contained by the list.
`boolean` `retainAll(java.util.Collection<?> collection)` Removes from the list each object not contained by the collection and returns whether any object was actually removed.
`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.
`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.

`java.lang.String` `toString()` Returns a string of the form `"[object1, object2]"`.

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, getDuplicates, getNonDuplicates, isUnique, iterator, listIterator, listIterator, move, resolve, set, useEquals, validate`

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

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

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

Constructor Detail

### DelegatingEList

    public DelegatingEList()

  Creates an empty instance.

### DelegatingEList

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

  Creates an instance that is a copy of the collection.

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

Method Detail

### delegateList

    protected abstract java.util.List<E> delegateList()

  Returns the list that acts as the backing store.

  Returns:
    the list that acts as the backing store.

### 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.

### delegateSize

    protected int delegateSize()

  Returns the number of objects in the backing store list.

  Returns:
    the number of objects in the backing store 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.

### delegateIsEmpty

    protected boolean delegateIsEmpty()

  Returns whether the backing store list has zero size.

  Returns:
    whether the backing store list has zero size.

### contains

    public boolean contains(java.lang.Object object)

  Returns whether the list contains the object.

  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.

### delegateContains

    protected boolean delegateContains(java.lang.Object object)

  Returns whether the backing store list contains the object.

  Parameters:
    `object` - the object in question.
  Returns:
    whether the backing store list contains the object.

### containsAll

    public boolean containsAll(java.util.Collection<?> collection)

  Returns whether the list contains each object in the collection.

  Specified by:
    `containsAll` in interface `java.util.Collection<E>`
  Specified by:
    `containsAll` in interface `java.util.List<E>`
  Overrides:
    `containsAll` in class `java.util.AbstractCollection<E>`
  Returns:
    whether the list contains each object in the collection.
  See Also:
    `contains(java.lang.Object)`, `AbstractEList.useEquals()`

### delegateContainsAll

    protected boolean delegateContainsAll(java.util.Collection<?> collection)

  Returns whether the backing store list contains each object in the collection.

  Returns:
    whether the backing store list contains each object in the collection.
  See Also:
    `contains(java.lang.Object)`, `AbstractEList.useEquals()`

### indexOf

    public int indexOf(java.lang.Object object)

  Returns the position of the first occurrence of the object in the list.

  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.

### delegateIndexOf

    protected int delegateIndexOf(java.lang.Object object)

  Returns the position of the first occurrence of the object in the backing store list.

  Parameters:
    `object` - the object in question.
  Returns:
    the position of the first occurrence of the object in the backing store list.

### lastIndexOf

    public int lastIndexOf(java.lang.Object object)

  Returns the position of the last occurrence of the object in the list.

  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.

### delegateLastIndexOf

    protected int delegateLastIndexOf(java.lang.Object object)

  Returns the position of the last occurrence of the object in the backing store list.

  Parameters:
    `object` - the object in question.
  Returns:
    the position of the last occurrence of the object in the backing store list.

### toArray

    public java.lang.Object[] toArray()

  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>`
  Returns:
    an array containing all the objects in sequence.

### delegateToArray

    protected java.lang.Object[] delegateToArray()

  Returns an array containing all the objects in the backing store list in sequence.

  Returns:
    an array containing all the objects in the backing store list in sequence.

### 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.

### delegateToArray

    protected <T> T[] delegateToArray(T[] array)

  Returns an array containing all the objects in the backing store list in sequence.

  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.

### 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:
    `java.lang.IndexOutOfBoundsException` - if the index isn't within the size range.
  See Also:
    `AbstractEList.resolve(int, E)`, `basicGet(int)`

### delegateGet

    protected E delegateGet(int index)

  Returns the object at the index in the backing store list.

  Parameters:
    `index` - the position in question.
  Returns:
    the object at the index.
  Throws:
    `java.lang.IndexOutOfBoundsException` - if the index isn't within the size range.

### basicGet

    protected 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:
    `java.lang.IndexOutOfBoundsException` - if the index isn't within the size range.
  See Also:
    `AbstractEList.resolve(int, E)`, `get(int)`

### primitiveGet

    protected E primitiveGet(int index)

  Description copied from class: `AbstractEList`
  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)`, `AbstractList.get(int)`, `AbstractEList.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 `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)`

### delegateSet

    protected E delegateSet(int index,
                            E object)

  Sets the object at the index in the backing store list and returns the old object at the index.

  Parameters:
    `object` - the object to set.
  Returns:
    the old object at the index.

### addUnique

    public void addUnique(E object)

  Adds the object at the end of the list; it does no uniqueness checking. This implementation delegates to `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)`

### delegateAdd

    protected void delegateAdd(E object)

  Adds the object at the end of the backing store list.

  Parameters:
    `object` - the object to be added.

### 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 `didAdd` and `didChange`.

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

### delegateAdd

    protected void delegateAdd(int index,
                               E object)

  Adds the object at the given index in the backing store list.

  Parameters:
    `object` - the object to be added.

### 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 `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 `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 `delegatedAdd`, `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(int, 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 `delegatedAdd`, `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 boolean remove(java.lang.Object object)

  Removes the object from the list and returns whether the object was actually contained by the list. This implementation uses `indexOf` to find the object and delegates to `remove(int)` in the case that it finds the object.

  Specified by:
    `remove` in interface `java.util.Collection<E>`
  Specified by:
    `remove` in interface `java.util.List<E>`
  Overrides:
    `remove` in class `AbstractEList<E>`
  Parameters:
    `object` - the object to be removed.
  Returns:
    whether the object was actually contained by the list.

### removeAll

    public boolean removeAll(java.util.Collection<?> collection)

  Removes each object of the collection from the list and returns whether any object was actually contained by the list.

  Specified by:
    `removeAll` in interface `java.util.Collection<E>`
  Specified by:
    `removeAll` in interface `java.util.List<E>`
  Overrides:
    `removeAll` in class `AbstractEList<E>`
  Parameters:
    `collection` - the collection of objects to be removed.
  Returns:
    whether any object was actually contained by the list.

### 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:
    `java.lang.IndexOutOfBoundsException` - if the index isn't within the size range.

### delegateRemove

    protected E delegateRemove(int index)

  Removes the object at the index from the backing store list and returns it.

  Returns:
    the removed object.
  Throws:
    `java.lang.IndexOutOfBoundsException` - if the index isn't within the size range.

### retainAll

    public boolean retainAll(java.util.Collection<?> collection)

  Removes from the list each object not contained by the collection and returns whether any object was actually removed. This delegates to `remove(int)` in the case that it finds an object that isn't retained.

  Specified by:
    `retainAll` in interface `java.util.Collection<E>`
  Specified by:
    `retainAll` in interface `java.util.List<E>`
  Overrides:
    `retainAll` in class `AbstractEList<E>`
  Parameters:
    `collection` - the collection of objects to be retained.
  Returns:
    whether any object was actually removed.

### clear

    public void clear()

  Clears the list of all objects.

  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>`

### doClear

    protected void doClear(int oldSize,
                           java.lang.Object[] oldData)

  Does the actual job of clearing all the objects.

  Parameters:
    `oldSize` - the size of the list before it is cleared.
    `oldData` - old values of the list before it is cleared.

### delegateClear

    protected void delegateClear()

  Clears the backing store list of all objects.

### 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 `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:
    `java.lang.IndexOutOfBoundsException` - if either index isn't within the size range.

### delegateMove

    protected E delegateMove(int targetIndex,
                             int sourceIndex)

  Moves the object at the source index in the backing store list by removing it and adding it at the new target index.

  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:
    `java.lang.IndexOutOfBoundsException` - if either index isn't within the size range.
  Since:
    2.3

### equals

    public boolean equals(java.lang.Object object)

  Returns whether the object is a list with corresponding equal objects. This implementation uses either `equals` or `"=="` depending on `useEquals`.

  Specified by:
    `equals` in interface `java.util.Collection<E>`
  Specified by:
    `equals` in interface `java.util.List<E>`
  Overrides:
    `equals` in class `AbstractEList<E>`
  Returns:
    whether the object is a list with corresponding equal objects.
  See Also:
    `AbstractEList.useEquals()`

### delegateEquals

    protected boolean delegateEquals(java.lang.Object object)

  Returns whether the object is a list with corresponding equal objects to those in the backing store list.

  Returns:
    whether the object is a list with corresponding equal objects.

### hashCode

    public int hashCode()

  Returns a hash code computed from each object's hash code.

  Specified by:
    `hashCode` in interface `java.util.Collection<E>`
  Specified by:
    `hashCode` in interface `java.util.List<E>`
  Overrides:
    `hashCode` in class `AbstractEList<E>`
  Returns:
    a hash code.

### delegateHashCode

    protected int delegateHashCode()

  Returns the hash code of the backing store list.

  Returns:
    a hash code.

### toString

    public java.lang.String toString()

  Returns a string of the form `"[object1, object2]"`.

  Overrides:
    `toString` in class `AbstractEList<E>`
  Returns:
    a string of the form `"[object1, object2]"`.

### delegateToString

    protected java.lang.String delegateToString()

  Returns a the string form of the backing store list.

  Returns:
    a the string form of the backing store list.

### delegateIterator

    protected java.util.Iterator<E> delegateIterator()

  Returns an iterator over the backing store list.

  Returns:
    an iterator.

### delegateListIterator

    protected java.util.ListIterator<E> delegateListIterator()

  Returns a list iterator over the backing store list.

  Returns:
    a list iterator.

### basicList

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

  Returns an unsafe list that provides a `non-resolving` view of the backing store list.

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

### delegateBasicList

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

  Returns an unsafe list that provides a `non-resolving` view of the backing store list.

  Returns:
    an unsafe list that provides a non-resolving view of the backing store list.

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