org.libj.util

Class ObservableList<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

org.libj.util.DelegateList<E>

org.libj.util.ObservableList<E>

Type Parameters:

E - The type of elements in this list.

All Implemented Interfaces:

Iterable<E>, Collection<E>, List<E>

Direct Known Subclasses:

CompositeList, CompositeList.ComponentList, MirrorList, ObservableList.ObservableSubList, SortedList

public abstract class ObservableList<E>
extends DelegateList<E>

A DelegateList that provides callback methods to observe the retrieval, addition, and removal of elements, either due to direct method invocation on the list instance itself, or via iterator(), listIterator(), subList(int,int), and any other entrypoint that facilitates access to the elements in this list, either for modification or retrieval.

See Also:

beforeGet(int,ListIterator), afterGet(int,Object,ListIterator,RuntimeException), beforeAdd(int,Object), afterAdd(int,Object,RuntimeException), beforeRemove(int), afterRemove(Object,RuntimeException), beforeSet(int,Object), afterSet(int,Object,RuntimeException)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	ObservableList.ObservableListIterator A CursorListIterator that delegates callback methods to the defining ObservableList instance for the retrieval, addition, and removal of elements.
protected class	ObservableList.ObservableSubList An ObservableList that delegates callback methods to the parent ObservableList instance for the retrieval, addition, and removal of elements.

Field Summary

Fields inherited from class org.libj.util.DelegateList

target

Fields inherited from class java.util.AbstractList

modCount

Constructor Summary

Constructors

Modifier	Constructor and Description
	ObservableList(List<E> list) Creates a new ObservableList with the specified target List.
protected	ObservableList(List<E> list, int fromIndex, int toIndex) Creates a new ObservableList with the specified target list, and from and to indexes to limit the scope of the target list.

Method Summary

Modifier and Type	Method and Description
boolean	add(E e)
void	add(int index, E element)
boolean	addAll(Collection<? extends E> c)
boolean	addAll(int index, Collection<? extends E> c)
protected void	addFast(int index, E element)
protected void	afterAdd(int index, E element, RuntimeException e) Callback method that is invoked immediately after an element is added to the enclosed List.
protected void	afterGet(int index, E element, ListIterator<? super E> iterator, RuntimeException e) Callback method that is invoked immediately after an element is retrieved from the enclosed List.
protected void	afterRemove(Object element, RuntimeException e) Callback method that is invoked immediately after an element is removed from the enclosed List.
protected void	afterSet(int index, E oldElement, RuntimeException e) Callback method that is invoked immediately after an element is set at an index to the enclosed List.
protected boolean	beforeAdd(int index, E element) Callback method that is invoked immediately before an element is added to the enclosed List.
protected void	beforeGet(int index, ListIterator<E> iterator) Callback method that is invoked immediately before an element is retrieved from the enclosed List.
protected boolean	beforeRemove(int index) Callback method that is invoked immediately before an element is removed from the enclosed List.
protected boolean	beforeSet(int index, E newElement) Callback method that is invoked immediately before an element is set at an index in the enclosed List.
void	clear()
boolean	contains(Object o)
boolean	containsAll(Collection<?> c)
boolean	equals(Object obj)
void	forEach(Consumer<? super E> action)
E	get(int index)
protected E	getFast(int index)
int	hashCode()
int	indexOf(Object o)
Iterator<E>	iterator()
int	lastIndexOf(Object o)
ListIterator<E>	listIterator()
ListIterator<E>	listIterator(int index)
protected ObservableList.ObservableListIterator	newListIterator(ListIterator<? extends E> iterator) Factory method that returns a new instance of an ObservableList.ObservableListIterator for the specified ListIterator<E>.
protected ObservableList.ObservableSubList	newSubList(int fromIndex, int toIndex) Factory method that returns a new instance of an ObservableList.ObservableSubList for the specified fromIndex and toIndex.
Stream<E>	parallelStream()
E	remove(int index)
boolean	remove(Object o)
boolean	removeAll(Collection<?> c)
protected E	removeFast(int index)
boolean	removeIf(Predicate<? super E> filter)
void	replaceAll(UnaryOperator<E> operator)
boolean	retainAll(Collection<?> c)
E	set(int index, E element)
int	size()
void	sort(Comparator<? super E> c)
Spliterator<E>	spliterator()
Stream<E>	stream()
ObservableList<E>	subList(int fromIndex, int toIndex)
Object[]	toArray()
<T> T[]	toArray(T[] a)
String	toString()

Methods inherited from class org.libj.util.DelegateList

isEmpty, superForEach, superParallelStream, superRemoveIf, superReplaceAll, superSort, superSpliterator, superStream

Methods inherited from class java.util.AbstractList

removeRange

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ObservableList

public ObservableList(List<E> list)

Creates a new ObservableList with the specified target List.

Parameters:

list - The target List.

Throws:

NullPointerException - If list is null.

ObservableList

protected ObservableList(List<E> list,
                         int fromIndex,
                         int toIndex)

Creates a new ObservableList with the specified target list, and from and to indexes to limit the scope of the target list.

Parameters:

list - The target List object.

fromIndex - The starting index as the lower limit of the elements in the target list, inclusive.

toIndex - The starting index as the upper limit of the elements in the target list, exclusive.

Throws:

NullPointerException - If list is null.

Method Detail

beforeGet

protected void beforeGet(int index,
                         ListIterator<E> iterator)

Callback method that is invoked immediately before an element is retrieved from the enclosed List.

Parameters:

index - The index of the element to be retrieved from the enclosed List.

iterator - The ListIterator instance if the get is a result of an iterator reference, otherwise null.

afterGet

protected void afterGet(int index,
                        E element,
                        ListIterator<? super E> iterator,
                        RuntimeException e)

Callback method that is invoked immediately after an element is retrieved from the enclosed List.

Parameters:

index - The index of the element retrieved from the enclosed List.

element - The element retrieved from the enclosed List.

iterator - The Iterator instance if the get is a result of an iterator reference, otherwise null.

e - A RuntimeException that occurred during the get operation, or null if no exception occurred.

beforeAdd

protected boolean beforeAdd(int index,
                            E element)

Callback method that is invoked immediately before an element is added to the enclosed List.

Note: It is possible for index to be -1, in case the add operation is executed from an Iterator when a prior Iterator.remove() or ListIterator.add(Object) or ListIterator.set(Object) has already been called.

Parameters:

index - The index for the element to be added to the enclosed List.

element - The element to be added to the enclosed List.

Returns:

If this method returns true, the subsequent add operation will be performed; if this method returns false, the subsequent add operation will not be performed.

afterAdd

protected void afterAdd(int index,
                        E element,
                        RuntimeException e)

Callback method that is invoked immediately after an element is added to the enclosed List.

Parameters:

index - The index of the element added to the enclosed List.

element - The element to be added to the enclosed List.

e - A RuntimeException that occurred during the add operation, or null if no exception occurred.

beforeRemove

protected boolean beforeRemove(int index)

Callback method that is invoked immediately before an element is removed from the enclosed List.

Note: It is possible for index to be -1, in case the remove operation is executed from an Iterator when a prior Iterator.remove() or ListIterator.add(Object) or ListIterator.set(Object) has already been called.

Parameters:

index - The index of the element to be removed from the enclosed List.

Returns:

If this method returns true, the subsequent remove operation will be performed; if this method returns false, the subsequent remove operation will not be performed.

afterRemove

protected void afterRemove(Object element,
                           RuntimeException e)

Callback method that is invoked immediately after an element is removed from the enclosed List.

Parameters:

element - The element removed from the enclosed List, or attempted to be removed from the List in case of a RuntimeException.

e - A RuntimeException that occurred during the remove operation, or null if no exception occurred.

beforeSet

protected boolean beforeSet(int index,
                            E newElement)

Callback method that is invoked immediately before an element is set at an index in the enclosed List.

Note: It is possible for index to be -1, in case the set operation is executed from an Iterator when a prior Iterator.remove() or ListIterator.add(Object) or ListIterator.set(Object) has already been called.

Parameters:

index - The index for the element to be set in the enclosed List.

newElement - The element to be set in the enclosed List.

Returns:

If this method returns true, the subsequent set operation will be performed; if this method returns false, the subsequent set operation will not be performed.

afterSet

protected void afterSet(int index,
                        E oldElement,
                        RuntimeException e)

Callback method that is invoked immediately after an element is set at an index to the enclosed List.

Parameters:

index - The index of the element set in the enclosed List.

oldElement - The old element at the index of the enclosed List.

e - A RuntimeException that occurred during the set operation, or null if no exception occurred.

addFast

protected void addFast(int index,
                       E element)

add

public boolean add(E e)

The callback methods beforeAdd(int,Object) and afterAdd(int,Object,RuntimeException) are called immediately before and after the enclosed List is modified for the addition of the element. If beforeAdd(int,Object) returns false, the element will not be added.

Specified by:

add in interface Collection<E>

Specified by:

add in interface List<E>

Overrides:

add in class DelegateList<E>

add

public void add(int index,
                E element)

The callback methods beforeAdd(int,Object) and afterAdd(int,Object,RuntimeException) are called immediately before and after the enclosed List is modified for the addition of the element. If beforeAdd(int,Object) returns false, the element will not be added.

Specified by:

add in interface List<E>

Overrides:

add in class DelegateList<E>

addAll

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

The callback methods beforeAdd(int,Object) and afterAdd(int,Object,RuntimeException) are called immediately before and after the enclosed List is modified for the addition of each element in the specified Collection. All elements for which beforeAdd(int,Object) returns false will not be added to this List.

Specified by:

addAll in interface Collection<E>

Specified by:

addAll in interface List<E>

Overrides:

addAll in class DelegateList<E>

addAll

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

The callback methods beforeAdd(int,Object) and afterAdd(int,Object,RuntimeException) are called immediately before and after the enclosed List is modified for the addition of each element in the specified Collection. All elements for which beforeAdd(int,Object) returns false will not be added to this List.

Specified by:

addAll in interface List<E>

Overrides:

addAll in class DelegateList<E>

clear

public void clear()

The callback methods beforeRemove(int) and afterRemove(Object,RuntimeException) are called immediately before and after the enclosed List is modified for the removal of each element. All elements for which beforeRemove(int) returns false will not be removed from this List.

Specified by:

clear in interface Collection<E>

Specified by:

clear in interface List<E>

Overrides:

clear in class DelegateList<E>

contains

public boolean contains(Object o)

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

contains in interface Collection<E>

Specified by:

contains in interface List<E>

Overrides:

contains in class DelegateList<E>

containsAll

public boolean containsAll(Collection<?> c)

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

containsAll in interface Collection<E>

Specified by:

containsAll in interface List<E>

Overrides:

containsAll in class DelegateList<E>

getFast

protected E getFast(int index)

get

public E get(int index)

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after the get operation on the enclosed List.

Specified by:

get in interface List<E>

Overrides:

get in class DelegateList<E>

indexOf

public int indexOf(Object o)

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

indexOf in interface List<E>

Overrides:

indexOf in class DelegateList<E>

lastIndexOf

public int lastIndexOf(Object o)

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

lastIndexOf in interface List<E>

Overrides:

lastIndexOf in class DelegateList<E>

iterator

public Iterator<E> iterator()

Calling Iterator.remove() will delegate a callback to beforeRemove(int) and afterRemove(Object,RuntimeException) on this instance. All elements for which beforeRemove(int) returns false will not be removed from this List.

Specified by:

iterator in interface Iterable<E>

Specified by:

iterator in interface Collection<E>

Specified by:

iterator in interface List<E>

Overrides:

iterator in class DelegateList<E>

listIterator

public ListIterator<E> listIterator()

Calling ListIterator.remove() will delegate a callback to beforeRemove(int) and afterRemove(Object,RuntimeException) on this instance. All elements for which beforeRemove(int) returns false will not be removed from this List. Calling ListIterator.set(Object) will delegate a callback to beforeSet(int,Object) and afterSet(int,Object,RuntimeException) on this instance. All elements for which beforeSet(int,Object) returns false will not be set in this List. Calling ListIterator.add(Object) will delegate a callback to beforeAdd(int,Object) and afterAdd(int,Object,RuntimeException) on this instance. All elements for which beforeAdd(int,Object) returns false will not be added to this List.

Specified by:

listIterator in interface List<E>

Overrides:

listIterator in class DelegateList<E>

newListIterator

protected ObservableList.ObservableListIterator newListIterator(ListIterator<? extends E> iterator)

Factory method that returns a new instance of an ObservableList.ObservableListIterator for the specified ListIterator<E>. This method is intended to be overridden by subclasses in order to provide instances of the subclass.

Parameters:

iterator - The target ListIterator<E>.

Returns:

A new instance of an ObservableList.ObservableListIterator.

listIterator

public ListIterator<E> listIterator(int index)

Calling ListIterator.remove() will delegate a callback to beforeRemove(int) and afterRemove(Object,RuntimeException) on this instance. All elements for which beforeRemove(int) returns false will not be removed from this List. Calling ListIterator.set(Object) will delegate a callback to beforeSet(int,Object) and afterSet(int,Object,RuntimeException) on this instance. All elements for which beforeSet(int,Object) returns false will not be set in this List. Calling ListIterator.add(Object) will delegate a callback to beforeAdd(int,Object) and afterAdd(int,Object,RuntimeException) on this instance. All elements for which beforeAdd(int,Object) returns false will not be added to this List.

Specified by:

listIterator in interface List<E>

Overrides:

listIterator in class DelegateList<E>

removeFast

protected E removeFast(int index)

remove

public E remove(int index)

The callback methods beforeRemove(int) and afterRemove(Object,RuntimeException) are called immediately before and after the enclosed List is modified for the removal of the element. If beforeRemove(int) returns false, the element will not be removed, and this method will return null.

Specified by:

remove in interface List<E>

Overrides:

remove in class DelegateList<E>

remove

public boolean remove(Object o)

The callback methods beforeRemove(int) and afterRemove(Object,RuntimeException) are called immediately before and after the enclosed List is modified. If beforeRemove(int) returns false, the element will not be removed.

Specified by:

remove in interface Collection<E>

Specified by:

remove in interface List<E>

Overrides:

remove in class DelegateList<E>

set

public E set(int index,
             E element)

The callback methods beforeSet(int,Object) and afterSet(int,Object,RuntimeException) are called immediately before and after the enclosed List is modified. If beforeSet(int,Object) returns false, the element will not be set, and this method will return null.

Specified by:

set in interface List<E>

Overrides:

set in class DelegateList<E>

removeAll

public boolean removeAll(Collection<?> c)

The callback methods beforeRemove(int) and afterRemove(Object,RuntimeException) are called immediately before and after the enclosed List is modified for the removal of each element in the specified Collection. All elements for which beforeRemove(int) returns false will not be removed from this List.

Specified by:

removeAll in interface Collection<E>

Specified by:

removeAll in interface List<E>

Overrides:

removeAll in class DelegateList<E>

See Also:

Collection.removeAll(Collection)

removeIf

public boolean removeIf(Predicate<? super E> filter)

The callback methods beforeRemove(int) and afterRemove(Object,RuntimeException) are called immediately before and after the enclosed List is modified for the removal of each element. All elements for which beforeRemove(int) returns false will not be removed from this List.

Specified by:

removeIf in interface Collection<E>

Overrides:

removeIf in class DelegateList<E>

retainAll

public boolean retainAll(Collection<?> c)

The callback methods beforeRemove(int) and afterRemove(Object,RuntimeException) are called immediately before and after the enclosed List is modified for the removal of each element not in the specified Collection. All elements for which beforeRemove(int) returns false will not be removed from this List.

Specified by:

retainAll in interface Collection<E>

Specified by:

retainAll in interface List<E>

Overrides:

retainAll in class DelegateList<E>

replaceAll

public void replaceAll(UnaryOperator<E> operator)

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

The callback methods beforeSet(int,Object) and afterSet(int,Object,RuntimeException) are called immediately before and after the enclosed List is modified. If beforeSet(int,Object) returns false, the element will not be set.

Specified by:

replaceAll in interface List<E>

Overrides:

replaceAll in class DelegateList<E>

size

public int size()

Specified by:

size in interface Collection<E>

Specified by:

size in interface List<E>

Overrides:

size in class DelegateList<E>

newSubList

protected ObservableList.ObservableSubList newSubList(int fromIndex,
                                                      int toIndex)

Factory method that returns a new instance of an ObservableList.ObservableSubList for the specified fromIndex and toIndex. This method is intended to be overridden by subclasses in order to provide instances of the subclass.

Parameters:

fromIndex - The starting index as the lower limit of the elements in the target list, inclusive.

toIndex - The starting index as the upper limit of the elements in the target list, exclusive.

Returns:

A new instance of an ObservableList.ObservableSubList.

subList

public ObservableList<E> subList(int fromIndex,
                                 int toIndex)

Description copied from class: DelegateList

The class DelegateList does not itself implement #subList(int,int), so calling this method on an instance of a subclass of DelegateList that does not override this method will result in a UnsupportedOperationException.

Specified by:

subList in interface List<E>

Overrides:

subList in class DelegateList<E>

sort

public void sort(Comparator<? super E> c)

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

sort in interface List<E>

Overrides:

sort in class DelegateList<E>

toArray

public Object[] toArray()

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

toArray in interface Collection<E>

Specified by:

toArray in interface List<E>

Overrides:

toArray in class DelegateList<E>

toArray

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

The callback methods beforeGet(int,ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each member of the enclosed list is referenced.

Specified by:

toArray in interface Collection<E>

Specified by:

toArray in interface List<E>

Overrides:

toArray in class DelegateList<E>

forEach

public void forEach(Consumer<? super E> action)

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Specified by:

forEach in interface Iterable<E>

Overrides:

forEach in class DelegateList<E>

spliterator

public Spliterator<E> spliterator()

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Specified by:

spliterator in interface Iterable<E>

Specified by:

spliterator in interface Collection<E>

Specified by:

spliterator in interface List<E>

Overrides:

spliterator in class DelegateList<E>

stream

public Stream<E> stream()

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Specified by:

stream in interface Collection<E>

Overrides:

stream in class DelegateList<E>

parallelStream

public Stream<E> parallelStream()

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Specified by:

parallelStream in interface Collection<E>

Overrides:

parallelStream in class DelegateList<E>

equals

public boolean equals(Object obj)

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Specified by:

equals in interface Collection<E>

Specified by:

equals in interface List<E>

Overrides:

equals in class DelegateList<E>

hashCode

public int hashCode()

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Specified by:

hashCode in interface Collection<E>

Specified by:

hashCode in interface List<E>

Overrides:

hashCode in class DelegateList<E>

toString

public String toString()

The callback methods beforeGet(int, ListIterator) and afterGet(int,Object,ListIterator,RuntimeException) are called immediately before and after each element of the enclosed list is retrieved.

Overrides:

toString in class DelegateList<E>