Package org.eclipse.core.databinding.observable.list

## Interface IObservableList<E>

Type Parameters:
  `E` - the type of elements in this collection

All Superinterfaces:
  `Collection<E>`, `IObservable`, `IObservableCollection<E>`, `Iterable<E>`, `List<E>`

All Known Subinterfaces:
  `ISWTObservableList<E>`, `IViewerObservableList<E>`

All Known Implementing Classes:
  `AbstractObservableList`, `ComputedList`, `DecoratingObservableList`, `MultiList`, `ObservableList`, `WritableList`

    public interface IObservableList<E>
    extends List<E>, IObservableCollection<E>

A list whose changes can be tracked by list change listeners.

Since:
  1.0
See Also:
  `AbstractObservableList`, `ObservableList`
Restriction:
  This interface is not intended to be implemented by clients. Clients should instead subclass one of the classes that implement this interface.

  Authors of extensions to the databinding framework may extend this interface and indirectly implement it, but if doing so must also extend one of the framework classes. (Use an API problem filter to suppress the resulting warning.)

  Direct implementers of this interface outside of the framework will be broken in future releases when methods are added to this interface.

### Method Summary

All Methods Instance Methods Abstract Methods
`boolean` `add​(E o)`
`boolean` `addAll​(int index, Collection<? extends E> c)`
`boolean` `addAll​(Collection<? extends E> c)`
`void` `addListChangeListener​(IListChangeListener<? super E> listener)` Adds the given list change listener to the list of list change listeners.
`boolean` `contains​(Object o)`
`boolean` `containsAll​(Collection<?> c)`
`boolean` `equals​(Object o)`
`E` `get​(int index)`
`Object` `getElementType()` Returns the element type of this observable collection, or `null` if this observable collection is untyped.
`int` `hashCode()`
`int` `indexOf​(Object o)`
`boolean` `isEmpty()`
`Iterator<E>` `iterator()`
`int` `lastIndexOf​(Object o)`
`ListIterator<E>` `listIterator()`
`ListIterator<E>` `listIterator​(int index)`
`E` `move​(int oldIndex, int newIndex)` Moves the element located at `oldIndex` to `newIndex`.
`E` `remove​(int index)`
`boolean` `remove​(Object o)`
`boolean` `removeAll​(Collection<?> c)`
`void` `removeListChangeListener​(IListChangeListener<? super E> listener)` Removes the given list change listener from the list of list change listeners.
`boolean` `retainAll​(Collection<?> c)`
`E` `set​(int index, E element)`
`int` `size()`
`List<E>` `subList​(int fromIndex, int toIndex)`
`Object[]` `toArray()`
`<T> T[]` `toArray​(T[] a)`

### Methods inherited from interface java.util.Collection

`parallelStream, removeIf, stream, toArray`

### Methods inherited from interface org.eclipse.core.databinding.observable.IObservable

`addChangeListener, addDisposeListener, addStaleListener, dispose, getRealm, isDisposed, isStale, removeChangeListener, removeDisposeListener, removeStaleListener`

### Methods inherited from interface java.lang.Iterable

`forEach`

### Methods inherited from interface java.util.List

`add, clear, replaceAll, sort, spliterator`

### Method Detail

#### addListChangeListener

    void addListChangeListener​(IListChangeListener<? super E> listener)

Adds the given list change listener to the list of list change listeners.

Parameters:
  `listener` - the change listener to add; not `null`

#### removeListChangeListener

    void removeListChangeListener​(IListChangeListener<? super E> listener)

Removes the given list change listener from the list of list change listeners. Has no effect if the given listener is not registered as a list change listener.

Parameters:
  `listener` - the change listener to remove; not `null`

#### size

    int size()

Specified by:
  `size` in interface `Collection<E>`
Specified by:
  `size` in interface `List<E>`
"TrackedGetter"

#### isEmpty

    boolean isEmpty()

Specified by:
  `isEmpty` in interface `Collection<E>`
Specified by:
  `isEmpty` in interface `List<E>`
"TrackedGetter"

#### contains

    boolean contains​(Object o)

Specified by:
  `contains` in interface `Collection<E>`
Specified by:
  `contains` in interface `List<E>`
"TrackedGetter"

#### iterator

    Iterator<E> iterator()

Specified by:
  `iterator` in interface `Collection<E>`
Specified by:
  `iterator` in interface `Iterable<E>`
Specified by:
  `iterator` in interface `List<E>`
"TrackedGetter"

#### toArray

    Object[] toArray()

Specified by:
  `toArray` in interface `Collection<E>`
Specified by:
  `toArray` in interface `List<E>`
"TrackedGetter"

#### toArray

    <T> T[] toArray​(T[] a)

Specified by:
  `toArray` in interface `Collection<E>`
Specified by:
  `toArray` in interface `List<E>`
"TrackedGetter"

#### add

    boolean add​(E o)

Specified by:
  `add` in interface `Collection<E>`
Specified by:
  `add` in interface `List<E>`

#### remove

    boolean remove​(Object o)

Specified by:
  `remove` in interface `Collection<E>`
Specified by:
  `remove` in interface `List<E>`

#### containsAll

    boolean containsAll​(Collection<?> c)

Specified by:
  `containsAll` in interface `Collection<E>`
Specified by:
  `containsAll` in interface `List<E>`
"TrackedGetter"

#### addAll

    boolean addAll​(Collection<? extends E> c)

Specified by:
  `addAll` in interface `Collection<E>`
Specified by:
  `addAll` in interface `List<E>`

#### addAll

    boolean addAll​(int index,
                   Collection<? extends E> c)

Specified by:
  `addAll` in interface `List<E>`

#### removeAll

    boolean removeAll​(Collection<?> c)

Specified by:
  `removeAll` in interface `Collection<E>`
Specified by:
  `removeAll` in interface `List<E>`

#### retainAll

    boolean retainAll​(Collection<?> c)

Specified by:
  `retainAll` in interface `Collection<E>`
Specified by:
  `retainAll` in interface `List<E>`

#### equals

    boolean equals​(Object o)

Specified by:
  `equals` in interface `Collection<E>`
Specified by:
  `equals` in interface `List<E>`
Overrides:
  `equals` in class `Object`
"TrackedGetter"

#### hashCode

    int hashCode()

Specified by:
  `hashCode` in interface `Collection<E>`
Specified by:
  `hashCode` in interface `List<E>`
Overrides:
  `hashCode` in class `Object`
"TrackedGetter"

#### get

    E get​(int index)

Specified by:
  `get` in interface `List<E>`
"TrackedGetter"

#### set

    E set​(int index,
          E element)

Specified by:
  `set` in interface `List<E>`

#### move

    E move​(int oldIndex,
           int newIndex)

Moves the element located at `oldIndex` to `newIndex`. This method is equivalent to calling `add(newIndex, remove(oldIndex))`.

Implementors should deliver list change notification for the remove and add operations in the same ListChangeEvent, as this allows `ListDiff.accept(ListDiffVisitor)` to recognize the operation as a move.

Parameters:
  `oldIndex` - the element's position before the move. Must be within the range `0 <= oldIndex < size()`.
  `newIndex` - the element's position after the move. Must be within the range `0 <= newIndex < size()`.
Returns:
  the element that was moved.
Throws:
  `IndexOutOfBoundsException` - if either argument is out of range ( `0 <= index < size()`).
Since:
  1.1
See Also:
  `ListDiffVisitor.handleMove(int, int, Object)`, `ListDiff.accept(ListDiffVisitor)`

#### remove

    E remove​(int index)

Specified by:
  `remove` in interface `List<E>`

#### indexOf

    int indexOf​(Object o)

Specified by:
  `indexOf` in interface `List<E>`
"TrackedGetter"

#### lastIndexOf

    int lastIndexOf​(Object o)

Specified by:
  `lastIndexOf` in interface `List<E>`
"TrackedGetter"

#### listIterator

    ListIterator<E> listIterator()

Specified by:
  `listIterator` in interface `List<E>`
"TrackedGetter"

#### listIterator

    ListIterator<E> listIterator​(int index)

Specified by:
  `listIterator` in interface `List<E>`
"TrackedGetter"

#### subList

    List<E> subList​(int fromIndex,
                    int toIndex)

Specified by:
  `subList` in interface `List<E>`
"TrackedGetter"

#### getElementType

    Object getElementType()

Description copied from interface: `IObservableCollection`
Returns the element type of this observable collection, or `null` if this observable collection is untyped.

Specified by:
  `getElementType` in interface `IObservableCollection<E>`
Returns:
  the type of the elements or `null` if untyped