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

## Class DecoratingObservableList<E>

- java.lang.Object
- - org.eclipse.core.databinding.observable.AbstractObservable
  - - org.eclipse.core.databinding.observable.DecoratingObservable
    - - org.eclipse.core.databinding.observable.DecoratingObservableCollection<E>
      - - org.eclipse.core.databinding.observable.list.DecoratingObservableList<E>

Type Parameters:
  `E` - the list element type

All Implemented Interfaces:
  `Iterable<E>`, `Collection<E>`, `List<E>`, `IDecoratingObservable`, `IObservable`, `IObservableCollection<E>`, `IObservableList<E>`

    public class DecoratingObservableList<E>
    extends DecoratingObservableCollection<E>
    implements IObservableList<E>

An observable list which decorates another observable list.

Since:
  1.2

### Constructor Summary

Constructors
`DecoratingObservableList​(IObservableList<E> decorated, boolean disposeDecoratedOnDispose)` Constructs a DecoratingObservableList which decorates the given observable.

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `add​(int index, E o)`
`boolean` `addAll​(int index, Collection<? extends E> c)`
`void` `addListChangeListener​(IListChangeListener<? super E> listener)` Adds the given list change listener to the list of list change listeners.
`protected void` `addListener​(Object listenerType, IObservablesListener listener)`
`protected Object` `clone()`
`void` `dispose()` Disposes of this observable object, removing all listeners registered with this object, and all listeners this object might have registered on other objects.
`protected void` `fireChange()`
`protected void` `fireEvent​(ObservableEvent event)`
`protected void` `fireListChange​(ListDiff<E> diff)`
`protected void` `firstListenerAdded()`
`E` `get​(int index)`
`Realm` `getRealm()`
`protected void` `handleListChange​(ListChangeEvent<? extends E> event)` Called whenever a ListChangeEvent is received from the decorated observable.
`protected boolean` `hasListeners()`
`int` `indexOf​(Object o)`
`int` `lastIndexOf​(Object o)`
`protected void` `lastListenerRemoved()`
`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)`
`void` `removeListChangeListener​(IListChangeListener<? super E> listener)` Removes the given list change listener from the list of list change listeners.
`protected void` `removeListener​(Object listenerType, IObservablesListener listener)`
`E` `set​(int index, E element)`
`List<E>` `subList​(int fromIndex, int toIndex)`

### Methods inherited from class org.eclipse.core.databinding.observable.DecoratingObservableCollection

`add, addAll, clear, contains, containsAll, equals, getElementType, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray, toString`

### Methods inherited from class org.eclipse.core.databinding.observable.DecoratingObservable

`getDecorated, getterCalled, handleStaleEvent, isStale`

### Methods inherited from class org.eclipse.core.databinding.observable.AbstractObservable

`addChangeListener, addDisposeListener, addStaleListener, checkRealm, fireStale, isDisposed, removeChangeListener, removeDisposeListener, removeStaleListener`

### Methods inherited from class java.lang.Object

`finalize, getClass, notify, notifyAll, wait, wait, wait`

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

`parallelStream, removeIf, stream, toArray`

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

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

### Methods inherited from interface org.eclipse.core.databinding.observable.list.IObservableList

`add, addAll, contains, containsAll, equals, getElementType, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray`

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

`forEach`

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

`clear, replaceAll, sort, spliterator`

### Constructor Detail

#### DecoratingObservableList

    public DecoratingObservableList​(IObservableList<E> decorated,
                                    boolean disposeDecoratedOnDispose)

Constructs a DecoratingObservableList which decorates the given observable.

Parameters:
  `decorated` - the observable list being decorated
  `disposeDecoratedOnDispose` -

### Method Detail

#### addListChangeListener

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

Description copied from interface: `IObservableList`
Adds the given list change listener to the list of list change listeners.

Specified by:
  `addListChangeListener` in interface `IObservableList<E>`

#### removeListChangeListener

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

Description copied from interface: `IObservableList`
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.

Specified by:
  `removeListChangeListener` in interface `IObservableList<E>`

#### fireListChange

    protected void fireListChange​(ListDiff<E> diff)

#### fireChange

    protected void fireChange()

Overrides:
  `fireChange` in class `AbstractObservable`

#### firstListenerAdded

    protected void firstListenerAdded()

Overrides:
  `firstListenerAdded` in class `DecoratingObservable`

#### lastListenerRemoved

    protected void lastListenerRemoved()

Overrides:
  `lastListenerRemoved` in class `DecoratingObservable`

#### handleListChange

    protected void handleListChange​(ListChangeEvent<? extends E> event)

Called whenever a ListChangeEvent is received from the decorated observable. By default, this method fires the list change event again, with the decorating observable as the event source. Subclasses may override to provide different behavior.

Parameters:
  `event` - the change event received from the decorated observable

#### add

    public void add​(int index,
                    E o)

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

#### addAll

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

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

#### get

    public E get​(int index)

Specified by:
  `get` in interface `IObservableList<E>`
Specified by:
  `get` in interface `List<E>`

#### indexOf

    public int indexOf​(Object o)

Specified by:
  `indexOf` in interface `IObservableList<E>`
Specified by:
  `indexOf` in interface `List<E>`

#### lastIndexOf

    public int lastIndexOf​(Object o)

Specified by:
  `lastIndexOf` in interface `IObservableList<E>`
Specified by:
  `lastIndexOf` in interface `List<E>`

#### listIterator

    public ListIterator<E> listIterator()

Specified by:
  `listIterator` in interface `IObservableList<E>`
Specified by:
  `listIterator` in interface `List<E>`

#### listIterator

    public ListIterator<E> listIterator​(int index)

Specified by:
  `listIterator` in interface `IObservableList<E>`
Specified by:
  `listIterator` in interface `List<E>`

#### move

    public E move​(int oldIndex,
                  int newIndex)

Description copied from interface: `IObservableList`
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.

Specified by:
  `move` in interface `IObservableList<E>`
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.
See Also:
  `ListDiffVisitor.handleMove(int, int, Object)`, `ListDiff.accept(ListDiffVisitor)`

#### remove

    public E remove​(int index)

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

#### set

    public E set​(int index,
                 E element)

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

#### subList

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

Specified by:
  `subList` in interface `IObservableList<E>`
Specified by:
  `subList` in interface `List<E>`

#### dispose

    public void dispose()

Description copied from interface: `IObservable`
Disposes of this observable object, removing all listeners registered with this object, and all listeners this object might have registered on other objects.

Specified by:
  `dispose` in interface `IObservable`
Overrides:
  `dispose` in class `DecoratingObservableCollection<E>`

#### addListener

    protected void addListener​(Object listenerType,
                               IObservablesListener listener)

Parameters:
  `listenerType` -
  `listener` -

#### removeListener

    protected void removeListener​(Object listenerType,
                                  IObservablesListener listener)

Parameters:
  `listenerType` -
  `listener` -

#### hasListeners

    protected boolean hasListeners()

#### fireEvent

    protected void fireEvent​(ObservableEvent event)

#### getRealm

    public Realm getRealm()

Returns:
  Returns the realm.

#### clone

    protected Object clone()
                    throws CloneNotSupportedException

Overrides:
  `clone` in class `Object`
Throws:
  `CloneNotSupportedException`