com.vaadin.flow.data.provider

Interface ListDataView<T,V extends ListDataView<T,?>>

Type Parameters:

T - data type

V - ListDataView type

All Superinterfaces:

DataView<T>, Serializable

All Known Implementing Classes:

AbstractListDataView, CheckboxGroupListDataView, GridListDataView, SelectListDataView

public interface ListDataView<T,V extends ListDataView<T,?>>
extends DataView<T>

DataView for a in-memory list data that provides information on the data and allows operations on it. Mutation operations can be used only if the backing List is mutable.

Since:

Method Summary

Modifier and Type	Method and Description
V	addFilter(SerializablePredicate<T> filter) Adds a filter to be applied to all queries.
V	addItem(T item) Adds an item to the data list if it is not already present.
V	addItemAfter(T item, T after) Adds an item after the given target item.
V	addItemBefore(T item, T before) Adds an item before the given target item.
V	addItems(Collection<T> items) Adds multiple items to the data list.
V	addItemsAfter(Collection<T> items, T after) Adds multiple items after the given target item.
V	addItemsBefore(Collection<T> items, T before) Adds multiple items before the given target item.
V	addSortComparator(SerializableComparator<T> sortComparator) Adds a comparator to the data default sorting.
<V1 extends Comparable<? super V1>> V	addSortOrder(ValueProvider<T,V1> valueProvider, SortDirection sortDirection) Adds a property and direction to the default sorting.
boolean	contains(T item) Check if item is present in the currently filtered data set.
int	getItemCount() Get the full item count with filters if any set.
Optional<T>	getNextItem(T item) Gets the item after given item from the filtered and sorted data.
Optional<T>	getPreviousItem(T item) Gets the item before given item from the filtered and sorted data.
V	removeFilters() Removes all in-memory filters set or added.
V	removeItem(T item) Remove an item from the data list.
V	removeItems(Collection<T> items) Remove multiple items from the data list.
V	removeSorting() Removes any default sorting that has been set or added previously.
V	setFilter(SerializablePredicate<T> filter) Sets a filter to be applied to the data.
V	setSortComparator(SerializableComparator<T> sortComparator) Sets the comparator to use as the default sorting.
<V1 extends Comparable<? super V1>> V	setSortOrder(ValueProvider<T,V1> valueProvider, SortDirection sortDirection) Sets the property and direction to use as the default sorting.

Methods inherited from interface com.vaadin.flow.data.provider.DataView

addItemCountChangeListener, getItem, getItems, refreshItem, setIdentifierProvider

Method Detail

contains

boolean contains(T item)

Check if item is present in the currently filtered data set.

By default, equals method implementation of the item is used for identity check. If a custom data provider is used, then the DataProvider.getId(Object) method is used instead. Item's custom identity can be set up with a DataView.setIdentifierProvider(IdentifierProvider).

Parameters:

item - item to search for

Returns:

true if item is found in filtered data set

See Also:

DataView.setIdentifierProvider(IdentifierProvider)

getItemCount

int getItemCount()

Get the full item count with filters if any set. As the item count might change at any point, it is recommended to add a listener with the DataView.addItemCountChangeListener(ComponentEventListener) method instead to get notified when the item count has changed.

Returns:

filtered item count

See Also:

DataView.addItemCountChangeListener(ComponentEventListener)

getNextItem

Optional<T> getNextItem(T item)

Gets the item after given item from the filtered and sorted data.

Note! Item might be present in the data set, but be filtered out or be the last item so that the next item won't be available.

Parameters:

item - item to get next for

Returns:

next item if available, else empty optional if item doesn't exist or not in current filtered items

See Also:

getPreviousItem(Object)

getPreviousItem

Optional<T> getPreviousItem(T item)

Gets the item before given item from the filtered and sorted data.

Note! Item might be present in the data set, but be filtered out or be the first item so that the previous item won't be available.

Parameters:

item - item to get previous for

Returns:

previous item if available, else empty optional if item doesn't exist or not in current filtered items

See Also:

getNextItem(Object)

addItem

V addItem(T item)

Adds an item to the data list if it is not already present.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

Parameters:

item - item to add

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

See Also:

addItemBefore(Object, Object), addItemAfter(Object, Object), removeItem(Object)

addItemAfter

V addItemAfter(T item,
               T after)

Adds an item after the given target item.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

If the item is already present in the data provider, then it is moved.

Note! Item is added to the unfiltered and unsorted List.

Parameters:

item - item to add

after - item after which to add the item at

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

IllegalArgumentException - if item doesn't exist or collection is not a list

See Also:

addItem(Object), addItemBefore(Object, Object)

addItemBefore

V addItemBefore(T item,
                T before)

Adds an item before the given target item.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

If the item is already present in the data provider, then it is moved.

Note! Item is added to the unfiltered and unsorted List.

Parameters:

item - item to add

before - item before which to add the item at

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

IllegalArgumentException - if item doesn't exist or collection is not a list

See Also:

addItem(Object), addItemAfter(Object, Object)

addItems

V addItems(Collection<T> items)

Adds multiple items to the data list.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

Any items that already present in the data provider are moved to the end.

Parameters:

items - collection of item to add

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

See Also:

removeItems(Collection), addItemsBefore(Collection, Object), addItemsAfter(Collection, Object)

addItemsAfter

V addItemsAfter(Collection<T> items,
                T after)

Adds multiple items after the given target item. The full collection is added in order after the target.

The backing List must be mutable to use this method. Immutable data structure will throw an exception. Any items that already present in the data provider are moved.

Note! Item is added to the unfiltered and unsorted List.

Parameters:

items - collection of items to add

after - item after which to add the item at

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

IllegalArgumentException - if item doesn't exist or collection is not a list

See Also:

addItems(Collection), addItemsBefore(Collection, Object)

addItemsBefore

V addItemsBefore(Collection<T> items,
                 T before)

Adds multiple items before the given target item. The full collection is added in order before the target.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

Any items that already present in the data provider are moved.

Note! Item is added to the unfiltered and unsorted List.

Parameters:

items - collection of items to add

before - item before which to add the item at

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

IllegalArgumentException - if item doesn't exist or collection is not a list

See Also:

addItems(Collection), addItemsAfter(Collection, Object)

removeItem

V removeItem(T item)

Remove an item from the data list.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

Parameters:

item - item to remove

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

See Also:

addItem(Object), removeItems(Collection)

removeItems

V removeItems(Collection<T> items)

Remove multiple items from the data list.

The backing List must be mutable to use this method. Immutable data structure will throw an exception.

Parameters:

items - collection of items to remove

Returns:

this ListDataView instance

Throws:

UnsupportedOperationException - if backing collection doesn't support modification

See Also:

removeItem(Object), removeItems(Collection)

setFilter

V setFilter(SerializablePredicate<T> filter)

Sets a filter to be applied to the data. The filter replaces any filter that has been set or added previously. null will clear all filters.

A filter bound to data set, not to the component. That means this filter won't be retained when a new data or DataProvider is set to the component. Any other component using the same DataProvider object would be affected by setting a filter through data view of another component.

Parameters:

filter - filter to be set, or null to clear any previously set filters

Returns:

ListDataView instance

See Also:

addFilter(SerializablePredicate), removeFilters()

addFilter

V addFilter(SerializablePredicate<T> filter)

Adds a filter to be applied to all queries. The filter will be used in addition to any filter that has been set or added previously.

A filter bound to data set, not to the component. That means this filter and previously added filters won't be retained when a new data or DataProvider is set to the component. Any other component using the same DataProvider object would be affected by adding a filter through data view of another component.

Parameters:

filter - the filter to add, not null

Returns:

ListDataView instance

See Also:

setFilter(SerializablePredicate), removeFilters()

removeFilters

V removeFilters()

Removes all in-memory filters set or added.

Returns:

ListDataView instance

See Also:

addFilter(SerializablePredicate), setFilter(SerializablePredicate)

setSortComparator

V setSortComparator(SerializableComparator<T> sortComparator)

Sets the comparator to use as the default sorting. This overrides the sorting set by any other method that manipulates the default sorting.

A comparator bound to data set, not to the component. That means the default sorting won't be retained when a new data or DataProvider is set to the component. Any other component using the same DataProvider object would be affected by setting a sort comparator through data view of another component.

Parameters:

sortComparator - a comparator to use, or null to clear any previously set sort order

Returns:

ListDataView instance

See Also:

addSortComparator(SerializableComparator)

addSortComparator

V addSortComparator(SerializableComparator<T> sortComparator)

Adds a comparator to the data default sorting. If no default sorting has been defined, then the provided comparator will be used as the default sorting. If a default sorting has been defined, then the provided comparator will be used to determine the ordering of items that are considered equal by the previously defined default sorting.

A comparator added to data set, not to the component. That means the default sorting won't be retained when a new data or DataProvider is set to the component. Any other component using the same DataProvider object would be affected by adding a sort comparator through data view of another component.

Parameters:

sortComparator - a comparator to add, not null

Returns:

ListDataView instance

See Also:

setSortComparator(SerializableComparator)

removeSorting

V removeSorting()

Removes any default sorting that has been set or added previously.

Any other component using the same DataProvider object would be affected by removing default sorting through data view of another component.

Returns:

ListDataView instance

See Also:

setSortComparator(SerializableComparator), addSortComparator(SerializableComparator)

setSortOrder

<V1 extends Comparable<? super V1>> V setSortOrder(ValueProvider<T,V1> valueProvider,
                                                   SortDirection sortDirection)

Sets the property and direction to use as the default sorting. This overrides the sorting set by any other method that manipulates the default sorting of this DataProvider.

A sort order bound to data set, not to the component. That means the default sorting won't be retained when a new data or DataProvider is set to the component. Any other component using the same DataProvider object would be affected by setting a sort order through data view of another component.

Type Parameters:

V1 - the provided value type

Parameters:

valueProvider - the value provider that defines the property do sort by, not null

sortDirection - the sort direction to use, not null

Returns:

ListDataView instance

See Also:

addSortOrder(ValueProvider, SortDirection)

addSortOrder

<V1 extends Comparable<? super V1>> V addSortOrder(ValueProvider<T,V1> valueProvider,
                                                   SortDirection sortDirection)

Adds a property and direction to the default sorting. If no default sorting has been defined, then the provided sort order will be used as the default sorting. If a default sorting has been defined, then the provided sort order will be used to determine the ordering of items that are considered equal by the previously defined default sorting.

A sort order added to data set, not to the component. That means the default sorting won't be retained when a new data or DataProvider is set to the component. Any other component using the same DataProvider object would be affected by adding a sort order through data view of another component.

Type Parameters:

V1 - the provided value type

Parameters:

valueProvider - the value provider that defines the property do sort by, not null

sortDirection - the sort direction to use, not null

Returns:

ListDataView instance

See Also:

setSortOrder(ValueProvider, SortDirection)