Module javafx.base
Package javafx.collections

# Class ModifiableObservableListBase<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
javafx.collections.ObservableListBase<E>
javafx.collections.ModifiableObservableListBase<E>

Type Parameters:
  `E` - the type of the elements contained in the List

All Implemented Interfaces:
  `Iterable<E>`, `Collection<E>`, `List<E>`, `Observable`, `ObservableList<E>`

    public abstract class ModifiableObservableListBase<E>
    extends ObservableListBase<E>

Abstract class that serves as a base class for `ObservableList` implementations that are modifiable. To implement a modifiable `ObservableList` class, you just need to implement the following set of methods:

- `get(int)`
- `size()`
- `doAdd(int, Object)`
- `doRemove(int)`
- `doSet(int, Object)`

and the notifications and built and fired automatically for you.

Example of a simple `ObservableList` delegating to another `List` would look like this:

       public class ArrayObservableList<E> extends ModifiableObservableList<E> {

       private final List<E> delegate = new ArrayList<>();

       public E get(int index) {
           return delegate.get(index);
       }

       public int size() {
           return delegate.size();
       }

       protected void doAdd(int index, E element) {
           delegate.add(index, element);
       }

       protected E doSet(int index, E element) {
           return delegate.set(index, element);
       }

       protected E doRemove(int index) {
           return delegate.remove(index);
       }

Since:
  JavaFX 8.0
See Also:
  `ObservableListBase`

- ## Field Summary

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

  `modCount`

- ## Constructor Summary

  Constructors
  Constructor | Description
  --- | ---
  `ModifiableObservableListBase()` |

- ## Method Summary

  Modifier and Type | Method | Description
  --- | --- | ---
  `void` | `add​(int index, E element)` |
  `boolean` | `addAll​(int index, Collection<? extends E> c)` |
  `boolean` | `addAll​(Collection<? extends E> c)` |
  `protected abstract void` | `doAdd​(int index, E element)` | Adds the `element` to the List at the position of `index`.
  `protected abstract E` | `doRemove​(int index)` | Removes the element at position of `index`.
  `protected abstract E` | `doSet​(int index, E element)` | Sets the `element` in the List at the position of `index`.
  `abstract E` | `get​(int index)` |
  `E` | `remove​(int index)` |
  `boolean` | `remove​(Object o)` |
  `boolean` | `removeAll​(Collection<?> c)` |
  `protected void` | `removeRange​(int fromIndex, int toIndex)` |
  `boolean` | `retainAll​(Collection<?> c)` |
  `E` | `set​(int index, E element)` |
  `boolean` | `setAll​(Collection<? extends E> col)` | Clears the ObservableList and adds all elements from the collection.
  `abstract int` | `size()` |
  `List<E>` | `subList​(int fromIndex, int toIndex)` |

  ### Methods inherited from class javafx.collections.ObservableListBase

  `addAll, addListener, addListener, beginChange, endChange, fireChange, hasListeners, nextAdd, nextPermutation, nextRemove, nextRemove, nextReplace, nextSet, nextUpdate, remove, removeAll, removeListener, removeListener, retainAll, setAll`

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

  `add, clear, equals, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator`

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

  `contains, containsAll, isEmpty, toArray, toArray, 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 java.lang.Iterable

  `forEach`

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

  `add, clear, contains, containsAll, equals, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, replaceAll, sort, spliterator, toArray, toArray`

  ### Methods inherited from interface javafx.collections.ObservableList

  `filtered, sorted, sorted`

- ## Constructor Details

  - ### ModifiableObservableListBase

    public ModifiableObservableListBase()

- ## Method Details

  - ### setAll

    public boolean setAll​(Collection<? extends E> col)
    Description copied from interface: `ObservableList`
    Clears the ObservableList and adds all elements from the collection.
    Specified by:
      `setAll` in interface `ObservableList<E>`
    Overrides:
      `setAll` in class `ObservableListBase<E>`
    Parameters:
      `col` - the collection with elements that will be added to this observableArrayList
    Returns:
      true (as specified by Collection.add(E))

  - ### addAll

    public boolean addAll​(Collection<? extends E> c)
    Specified by:
      `addAll` in interface `Collection<E>`
    Specified by:
      `addAll` in interface `List<E>`
    Overrides:
      `addAll` in class `AbstractCollection<E>`

  - ### addAll

    public boolean addAll​(int index, Collection<? extends E> c)
    Specified by:
      `addAll` in interface `List<E>`
    Overrides:
      `addAll` in class `AbstractList<E>`

  - ### removeRange

    protected void removeRange​(int fromIndex, int toIndex)
    Overrides:
      `removeRange` in class `AbstractList<E>`

  - ### removeAll

    public boolean removeAll​(Collection<?> c)
    Specified by:
      `removeAll` in interface `Collection<E>`
    Specified by:
      `removeAll` in interface `List<E>`
    Overrides:
      `removeAll` in class `AbstractCollection<E>`

  - ### retainAll

    public boolean retainAll​(Collection<?> c)
    Specified by:
      `retainAll` in interface `Collection<E>`
    Specified by:
      `retainAll` in interface `List<E>`
    Overrides:
      `retainAll` in class `AbstractCollection<E>`

  - ### add

    public void add​(int index, E element)
    Specified by:
      `add` in interface `List<E>`
    Overrides:
      `add` in class `AbstractList<E>`

  - ### set

    public E set​(int index, E element)
    Specified by:
      `set` in interface `List<E>`
    Overrides:
      `set` in class `AbstractList<E>`

  - ### remove

    public boolean remove​(Object o)
    Specified by:
      `remove` in interface `Collection<E>`
    Specified by:
      `remove` in interface `List<E>`
    Overrides:
      `remove` in class `AbstractCollection<E>`

  - ### remove

    public E remove​(int index)
    Specified by:
      `remove` in interface `List<E>`
    Overrides:
      `remove` in class `AbstractList<E>`

  - ### subList

    public List<E> subList​(int fromIndex, int toIndex)
    Specified by:
      `subList` in interface `List<E>`
    Overrides:
      `subList` in class `AbstractList<E>`

  - ### get

    public abstract E get​(int index)
    Specified by:
      `get` in interface `List<E>`
    Specified by:
      `get` in class `AbstractList<E>`

  - ### size

    public abstract int size()
    Specified by:
      `size` in interface `Collection<E>`
    Specified by:
      `size` in interface `List<E>`
    Specified by:
      `size` in class `AbstractCollection<E>`

  - ### doAdd

    protected abstract void doAdd​(int index, E element)
    Adds the `element` to the List at the position of `index`.

    For the description of possible exceptions, please refer to the documentation of `AbstractList.add(java.lang.Object)` method.

    Parameters:
      `index` - the position where to add the element
      `element` - the element that will be added
    Throws:
      `ClassCastException` - if the type of the specified element is incompatible with this list
      `NullPointerException` - if the specified arguments contain one or more null elements
      `IllegalArgumentException` - if some property of this element prevents it from being added to this list
      `IndexOutOfBoundsException` - if the index is out of range `(index < 0 || index > size())`

  - ### doSet

    protected abstract E doSet​(int index, E element)
    Sets the `element` in the List at the position of `index`.

    For the description of possible exceptions, please refer to the documentation of `set(int, java.lang.Object)` method.

    Parameters:
      `index` - the position where to set the element
      `element` - the element that will be set at the specified position
    Returns:
      the old element at the specified position
    Throws:
      `ClassCastException` - if the type of the specified element is incompatible with this list
      `NullPointerException` - if the specified arguments contain one or more null elements
      `IllegalArgumentException` - if some property of this element prevents it from being added to this list
      `IndexOutOfBoundsException` - if the index is out of range `(index < 0 || index >= size())`

  - ### doRemove

    protected abstract E doRemove​(int index)
    Removes the element at position of `index`.
    Parameters:
      `index` - the index of the removed element
    Returns:
      the removed element
    Throws:
      `IndexOutOfBoundsException` - if the index is out of range `(index < 0 || index >= size())`