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

## Class MultiList<E>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - java.util.AbstractList<E>
    - - org.eclipse.core.databinding.observable.list.AbstractObservableList<E>
      - - org.eclipse.core.databinding.observable.list.MultiList<E>

Type Parameters:
  `E` - the type of the elements in the list

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

    public class MultiList<E>
    extends AbstractObservableList<E>

An observable list backed by an array of observable lists. This class supports all removal methods (including `clear()`), as well as the `set(int, Object)` method. All other mutator methods (addition methods and `move(int, int)`) throw an `UnsupportedOperationException`.

Since:
  1.2

### Field Summary

### Fields inherited from class java.util.AbstractList

`modCount`

### Constructor Summary

Constructors
`MultiList​(List<IObservableList<E>> lists)` Constructs a MultiList in the default realm, and backed by the given observable lists.
`MultiList​(List<IObservableList<E>> lists, Object elementType)` Constructs a MultiList in the default realm backed by the given observable lists.
`MultiList​(IObservableList<E>[] lists)` Deprecated. use `MultiList(List)` instead
`MultiList​(IObservableList<E>[] lists, Object elementType)` Deprecated. use `MultiList(List, Object)` instead
`MultiList​(Realm realm, List<IObservableList<E>> lists, Object elementType)` Constructs a MultiList belonging to the given realm, and backed by the given observable lists.
`MultiList​(Realm realm, IObservableList<E>[] lists)` Constructs a MultiList belonging to the given realm, and backed by the given observable lists.
`MultiList​(Realm realm, IObservableList<E>[] lists, Object elementType)` Deprecated. use `MultiList(Realm, List, Object)` instead

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `add​(int index, Object o)`
`boolean` `add​(Object o)`
`boolean` `addAll​(int index, Collection<? extends E> c)`
`boolean` `addAll​(Collection<? extends E> c)`
`void` `clear()`
`boolean` `contains​(Object o)`
`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 int` `doGetSize()`
`boolean` `equals​(Object o)`
`protected void` `firstListenerAdded()`
`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()`
`boolean` `isStale()` Returns whether the state of this observable is stale and is expected to change soon.
`Iterator<E>` `iterator()`
`int` `lastIndexOf​(Object o)`
`protected void` `lastListenerRemoved()`
`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)`
`boolean` `retainAll​(Collection<?> c)`
`E` `set​(int index, E o)`
`Object[]` `toArray()`
`<T> T[]` `toArray​(T[] a)`

### Methods inherited from class org.eclipse.core.databinding.observable.list.AbstractObservableList

`addChangeListener, addDisposeListener, addListChangeListener, addStaleListener, checkRealm, containsAll, fireChange, fireListChange, fireStale, getRealm, hasListeners, isDisposed, removeChangeListener, removeDisposeListener, removeListChangeListener, removeStaleListener, size`

### Methods inherited from class java.util.AbstractList

`listIterator, removeRange, subList`

### Methods inherited from class java.util.AbstractCollection

`toString`

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

`clone, 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.list.IObservableList

`listIterator, subList`

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

`forEach`

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

`replaceAll, sort, spliterator`

### Constructor Detail

#### MultiList

    @Deprecated
    public MultiList​(IObservableList<E>[] lists)

Deprecated.
use `MultiList(List)` instead
Constructs a MultiList in the default realm, and backed by the given observable lists.

Parameters:
  `lists` - the array of observable lists backing this MultiList.

#### MultiList

    public MultiList​(List<IObservableList<E>> lists)

Constructs a MultiList in the default realm, and backed by the given observable lists.

Parameters:
  `lists` - the array of observable lists backing this MultiList.
Since:
  1.6

#### MultiList

    @Deprecated
    public MultiList​(IObservableList<E>[] lists,
                     Object elementType)

Deprecated.
use `MultiList(List, Object)` instead
Constructs a MultiList in the default realm backed by the given observable lists.

Parameters:
  `lists` - the array of observable lists backing this MultiList.
  `elementType` - element type of the constructed list.

#### MultiList

    public MultiList​(List<IObservableList<E>> lists,
                     Object elementType)

Constructs a MultiList in the default realm backed by the given observable lists.

Parameters:
  `lists` - the array of observable lists backing this MultiList.
  `elementType` - element type of the constructed list.
Since:
  1.6

#### MultiList

    public MultiList​(Realm realm,
                     IObservableList<E>[] lists)

Constructs a MultiList belonging to the given realm, and backed by the given observable lists.

Parameters:
  `realm` - the observable's realm
  `lists` - the array of observable lists backing this MultiList

#### MultiList

    @Deprecated
    public MultiList​(Realm realm,
                     IObservableList<E>[] lists,
                     Object elementType)

Deprecated.
use `MultiList(Realm, List, Object)` instead
Constructs a MultiList belonging to the given realm, and backed by the given observable lists.

Parameters:
  `realm` - the observable's realm
  `lists` - the array of observable lists backing this MultiList
  `elementType` - element type of the constructed list.

#### MultiList

    public MultiList​(Realm realm,
                     List<IObservableList<E>> lists,
                     Object elementType)

Constructs a MultiList belonging to the given realm, and backed by the given observable lists.

Parameters:
  `realm` - the observable's realm
  `lists` - the array of observable lists backing this MultiList
  `elementType` - element type of the constructed list.
Since:
  1.6

### Method Detail

#### firstListenerAdded

    protected void firstListenerAdded()

Overrides:
  `firstListenerAdded` in class `AbstractObservableList<E>`

#### lastListenerRemoved

    protected void lastListenerRemoved()

Overrides:
  `lastListenerRemoved` in class `AbstractObservableList<E>`

#### doGetSize

    protected int doGetSize()

Specified by:
  `doGetSize` in class `AbstractObservableList<E>`
Returns:
  the size

#### getElementType

    public Object getElementType()

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

Returns:
  the type of the elements or `null` if untyped

#### add

    public boolean add​(Object o)

Specified by:
  `add` in interface `Collection<E>`
Specified by:
  `add` in interface `IObservableList<E>`
Specified by:
  `add` in interface `List<E>`
Overrides:
  `add` in class `AbstractObservableList<E>`

#### add

    public void add​(int index,
                    Object o)

Specified by:
  `add` in interface `List<E>`
Overrides:
  `add` in class `AbstractList<E>`

#### addAll

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

Specified by:
  `addAll` in interface `Collection<E>`
Specified by:
  `addAll` in interface `IObservableList<E>`
Specified by:
  `addAll` in interface `List<E>`
Overrides:
  `addAll` in class `AbstractObservableList<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>`
Overrides:
  `addAll` in class `AbstractObservableList<E>`

#### clear

    public void clear()

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

#### get

    public E get​(int index)

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

#### contains

    public boolean contains​(Object o)

Specified by:
  `contains` in interface `Collection<E>`
Specified by:
  `contains` in interface `IObservableList<E>`
Specified by:
  `contains` in interface `List<E>`
Overrides:
  `contains` in class `AbstractObservableList<E>`

#### equals

    public boolean equals​(Object o)

Specified by:
  `equals` in interface `Collection<E>`
Specified by:
  `equals` in interface `IObservableList<E>`
Specified by:
  `equals` in interface `List<E>`
Overrides:
  `equals` in class `AbstractObservableList<E>`

#### hashCode

    public int hashCode()

Specified by:
  `hashCode` in interface `Collection<E>`
Specified by:
  `hashCode` in interface `IObservableList<E>`
Specified by:
  `hashCode` in interface `List<E>`
Overrides:
  `hashCode` in class `AbstractObservableList<E>`

#### indexOf

    public int indexOf​(Object o)

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

#### isEmpty

    public boolean isEmpty()

Specified by:
  `isEmpty` in interface `Collection<E>`
Specified by:
  `isEmpty` in interface `IObservableList<E>`
Specified by:
  `isEmpty` in interface `List<E>`
Overrides:
  `isEmpty` in class `AbstractObservableList<E>`

#### iterator

    public Iterator<E> iterator()

Specified by:
  `iterator` in interface `Collection<E>`
Specified by:
  `iterator` in interface `IObservableList<E>`
Specified by:
  `iterator` in interface `Iterable<E>`
Specified by:
  `iterator` in interface `List<E>`
Overrides:
  `iterator` in class `AbstractObservableList<E>`

#### lastIndexOf

    public int lastIndexOf​(Object o)

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

#### listIterator

    public ListIterator<E> listIterator​(int index)

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

#### move

    public E move​(int oldIndex,
                  int newIndex)

Description copied from class: `AbstractObservableList`
Moves the element located at `oldIndex` to `newIndex`. This method is equivalent to calling `add(newIndex, remove(oldIndex))`.

Subclasses should override this method to 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>`
Overrides:
  `move` in class `AbstractObservableList<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 boolean remove​(Object o)

Specified by:
  `remove` in interface `Collection<E>`
Specified by:
  `remove` in interface `IObservableList<E>`
Specified by:
  `remove` in interface `List<E>`
Overrides:
  `remove` in class `AbstractObservableList<E>`

#### remove

    public E remove​(int index)

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

#### removeAll

    public boolean removeAll​(Collection<?> c)

Specified by:
  `removeAll` in interface `Collection<E>`
Specified by:
  `removeAll` in interface `IObservableList<E>`
Specified by:
  `removeAll` in interface `List<E>`
Overrides:
  `removeAll` in class `AbstractObservableList<E>`

#### retainAll

    public boolean retainAll​(Collection<?> c)

Specified by:
  `retainAll` in interface `Collection<E>`
Specified by:
  `retainAll` in interface `IObservableList<E>`
Specified by:
  `retainAll` in interface `List<E>`
Overrides:
  `retainAll` in class `AbstractObservableList<E>`

#### set

    public E set​(int index,
                 E o)

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

#### toArray

    public Object[] toArray()

Specified by:
  `toArray` in interface `Collection<E>`
Specified by:
  `toArray` in interface `IObservableList<E>`
Specified by:
  `toArray` in interface `List<E>`
Overrides:
  `toArray` in class `AbstractObservableList<E>`

#### toArray

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

Specified by:
  `toArray` in interface `Collection<E>`
Specified by:
  `toArray` in interface `IObservableList<E>`
Specified by:
  `toArray` in interface `List<E>`
Overrides:
  `toArray` in class `AbstractObservableList<E>`

#### isStale

    public boolean isStale()

Description copied from interface: `IObservable`
Returns whether the state of this observable is stale and is expected to change soon. A non-stale observable that becomes stale will notify its stale listeners. A stale object that becomes non-stale does so by changing its state and notifying its change listeners, it does not notify its stale listeners about becoming non-stale. Clients that do not expect asynchronous changes may ignore staleness of observable objects.

Specified by:
  `isStale` in interface `IObservable`
Overrides:
  `isStale` in class `AbstractObservableList<E>`
Returns:
  true if this observable's state is stale and will change soon.

#### 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 `AbstractObservableList<E>`