DefaultFilteredTableModel (Codion Framework API 0.17.16)

java.lang.Object
- javax.swing.table.AbstractTableModel
- - is.codion.swing.common.model.component.table.DefaultFilteredTableModel<R,C>

Type Parameters:

R - the type representing the rows in this table model

C - the type used to identify columns in this table model, Integer for indexed identification for example

All Implemented Interfaces:

FilteredModel<R>, FilteredTableModel<R,C>, Serializable, TableModel

Direct Known Subclasses:

SwingEntityTableModel
```
public class DefaultFilteredTableModel<R,C>
extends AbstractTableModel
implements FilteredTableModel<R,C>
```
A TableModel implementation that supports filtering, searching and sorting.
```
 DefaultFilteredTableModel tableModel = ...;
 JTable table = new JTable(tableModel, tableModel.columnModel(), tableModel.selectionModel());
 
```
User: Björn Darri
Date: 18.4.2010
Time: 09:48:07
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`DefaultFilteredTableModel.DefaultSummaryValueProvider<T extends Number,C>` A default SummaryValueProvider implementation

Nested classes/interfaces inherited from interface is.codion.swing.common.model.component.table.FilteredTableModel
FilteredTableModel.ColumnValueProvider<R,C>, FilteredTableModel.RowsRemoved

Field Summary
- Fields inherited from class javax.swing.table.AbstractTableModel
  listenerList
- Fields inherited from interface is.codion.common.model.FilteredModel
  ASYNC_REFRESH

Constructor Summary

Constructors
Constructor and Description
`DefaultFilteredTableModel(List<FilteredTableColumn<C>> tableColumns, FilteredTableModel.ColumnValueProvider<R,C> columnValueProvider)` Instantiates a new table model.
`DefaultFilteredTableModel(List<FilteredTableColumn<C>> tableColumns, FilteredTableModel.ColumnValueProvider<R,C> columnValueProvider, Collection<? extends ColumnConditionModel<? extends C,?>> columnFilterModels)` Instantiates a new table model.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addClearListener(EventListener listener)`
`void`	`addDataChangedListener(EventListener listener)`
`void`	`addFilterListener(EventListener listener)`
`protected void`	`addItem(R item)` Adds the given item to the bottom of this table model.
`protected void`	`addItems(Collection<R> items)` Adds the given items to the bottom of this table model.
`protected void`	`addItemsAt(int index, Collection<R> items)` Adds the given items to this table model, non-filtered items are added at the given index.
`protected void`	`addItemsAtSorted(int index, Collection<R> items)` Adds the given items to this table model, non-filtered items are added at the given index.
`protected void`	`addItemSorted(R item)` Adds the given item to the bottom of this table model.
`protected void`	`addItemsSorted(Collection<R> items)` Adds the given items to the bottom of this table model.
`void`	`addRefreshFailedListener(EventDataListener<Throwable> listener)`
`void`	`addRefreshListener(EventListener listener)`
`void`	`addRowsRemovedListener(EventDataListener<FilteredTableModel.RowsRemoved> listener)` Adds a listener that is notified each time rows are removed from this model.
`void`	`addSortListener(EventListener listener)`
`boolean`	`allowSelectionChange()` A default implementation returning true
`void`	`clear()` Clears all items from this table model
`<T> ColumnConditionModel<C,T>`	`columnFilterModel(C columnIdentifier)` Returns the `ColumnConditionModel` for the column with the given identifier.
`Map<C,ColumnConditionModel<? extends C,?>>`	`columnFilterModels()`
`FilteredTableColumnModel<C>`	`columnModel()`
`Optional<ColumnSummaryModel>`	`columnSummaryModel(C columnIdentifier)` Returns the `ColumnSummaryModel` associated with `columnIdentifier`
`boolean`	`containsItem(R item)` Returns true if this model contains the given item, visible or filtered.
`protected <T extends Number> Optional<ColumnSummaryModel.SummaryValueProvider<T>>`	`createColumnValueProvider(C columnIdentifier)` Creates a ColumnValueProvider for the given column
`int`	`filteredItemCount()`
`List<R>`	`filteredItems()`
`void`	`filterItems()` Filters this model according to the condition returned by `FilteredModel.getIncludeCondition()`.
`Class<?>`	`getColumnClass(C columnIdentifier)` Returns the class of the column with the given identifier
`Class<?>`	`getColumnClass(int columnIndex)`
`int`	`getColumnCount()`
`Predicate<R>`	`getIncludeCondition()` Returns the include condition used by this model, null if no include condition has been set.
`int`	`getRowCount()`
`String`	`getStringValueAt(int rowIndex, C columnIdentifier)` Returns a String representation of the value for the given row and column.
`Object`	`getValueAt(int rowIndex, int columnIndex)`
`int`	`indexOf(R item)`
`boolean`	`isAsyncRefresh()`
`boolean`	`isFiltered(R item)` Returns true if this model contains the given item, and it is filtered, that is, is not visible
`boolean`	`isMergeOnRefresh()`
`boolean`	`isVisible(R item)` Returns true if this model contains the given item, and it is visible, that is, not filtered
`R`	`itemAt(int rowIndex)`
`List<R>`	`items()`
`void`	`refresh()` Refreshes the items in this table model, respecting the selection, filtering as well as sorting states.
`StateObserver`	`refreshingObserver()`
`protected Collection<R>`	`refreshItems()` Returns the items this table model should contain.
`void`	`refreshThen(Consumer<Collection<R>> afterRefresh)` Refreshes the data in this model.
`void`	`removeClearListener(EventListener listener)`
`void`	`removeDataChangedListener(EventListener listener)`
`void`	`removeFilterListener(EventListener listener)`
`void`	`removeItem(R item)` Removes the given item from this table model
`void`	`removeItemAt(int index)` Removes from this table model the visible element whose index is between index
`void`	`removeItems(Collection<R> items)` Removes the given items from this table model
`void`	`removeItems(int fromIndex, int toIndex)` Removes from this table model all visible elements whose index is between fromIndex, inclusive and toIndex, exclusive
`void`	`removeRefreshFailedListener(EventDataListener<Throwable> listener)`
`void`	`removeRefreshListener(EventListener listener)`
`void`	`removeRowsRemovedListener(EventDataListener<FilteredTableModel.RowsRemoved> listener)`
`void`	`removeSortListener(EventListener listener)`
`FilteredTableSearchModel`	`searchModel()`
`<T> Collection<T>`	`selectedValues(C columnIdentifier)`
`FilteredTableSelectionModel<R>`	`selectionModel()`
`void`	`setAsyncRefresh(boolean asyncRefresh)` Sometimes we'd like to be able to refresh one or more models and perform some action on the refreshed data, after the refresh has finished, such as selecting a particular item or such.
`void`	`setIncludeCondition(Predicate<R> includeCondition)` Sets the include condition and filters the model
`protected void`	`setItemAt(int index, R item)` Sets the item at the given index.
`void`	`setMergeOnRefresh(boolean mergeOnRefresh)`
`void`	`sortItems()` Sorts the visible items according to the `FilteredTableSortModel`, keeping the selected items.
`FilteredTableSortModel<R,C>`	`sortModel()`
`<T> Collection<T>`	`values(C columnIdentifier)`
`int`	`visibleItemCount()`
`List<R>`	`visibleItems()`

Methods inherited from class javax.swing.table.AbstractTableModel
addTableModelListener, findColumn, fireTableCellUpdated, fireTableChanged, fireTableDataChanged, fireTableRowsDeleted, fireTableRowsInserted, fireTableRowsUpdated, fireTableStructureChanged, getColumnName, getListeners, getTableModelListeners, isCellEditable, removeTableModelListener, setValueAt

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface javax.swing.table.TableModel
addTableModelListener, getColumnName, isCellEditable, removeTableModelListener, setValueAt

- Constructor Detail
  - DefaultFilteredTableModel
```
public DefaultFilteredTableModel(List<FilteredTableColumn<C>> tableColumns,
                                 FilteredTableModel.ColumnValueProvider<R,C> columnValueProvider)
```
    Instantiates a new table model.
    
    Parameters:
    
    tableColumns - the table columns to base this table model on
    
    columnValueProvider - the column value provider
  - DefaultFilteredTableModel
```
public DefaultFilteredTableModel(List<FilteredTableColumn<C>> tableColumns,
                                 FilteredTableModel.ColumnValueProvider<R,C> columnValueProvider,
                                 Collection<? extends ColumnConditionModel<? extends C,?>> columnFilterModels)
```
    Instantiates a new table model.
    
    Parameters:
    
    tableColumns - the table columns to base this table model on
    
    columnValueProvider - the column value provider
    
    columnFilterModels - the filter models if any, may be null
- Method Detail
  - items
```
public final List<R> items()
```
    Specified by:
    
    items in interface FilteredModel<R>
    
    Returns:
    
    an unmodifiable view of all visible and filtered items in this model, in no particular order
    
    See Also:
    
    FilteredModel.visibleItems(), FilteredModel.filteredItems()
  - visibleItems
```
public final List<R> visibleItems()
```
    Specified by:
    
    visibleItems in interface FilteredModel<R>
    
    Returns:
    
    an unmodifiable view of the visible items
  - filteredItems
```
public final List<R> filteredItems()
```
    Specified by:
    
    filteredItems in interface FilteredModel<R>
    
    Returns:
    
    an unmodifiable view of the filtered items
  - visibleItemCount
```
public final int visibleItemCount()
```
    Specified by:
    
    visibleItemCount in interface FilteredModel<R>
    
    Returns:
    
    the number of currently visible items
  - filteredItemCount
```
public final int filteredItemCount()
```
    Specified by:
    
    filteredItemCount in interface FilteredModel<R>
    
    Returns:
    
    the number of currently filtered items
  - getColumnCount
```
public final int getColumnCount()
```
    Specified by:
    
    getColumnCount in interface TableModel
  - getRowCount
```
public final int getRowCount()
```
    Specified by:
    
    getRowCount in interface TableModel
  - containsItem
```
public final boolean containsItem(R item)
```
    Description copied from interface: FilteredModel
    
    Returns true if this model contains the given item, visible or filtered.
    
    Specified by:
    
    containsItem in interface FilteredModel<R>
    
    Parameters:
    
    item - the item
    
    Returns:
    
    true if this model contains the item
  - isVisible
```
public final boolean isVisible(R item)
```
    Description copied from interface: FilteredModel
    
    Returns true if this model contains the given item, and it is visible, that is, not filtered
    
    Specified by:
    
    isVisible in interface FilteredModel<R>
    
    Parameters:
    
    item - the item
    
    Returns:
    
    true if the given item is visible
  - isFiltered
```
public final boolean isFiltered(R item)
```
    Description copied from interface: FilteredModel
    
    Returns true if this model contains the given item, and it is filtered, that is, is not visible
    
    Specified by:
    
    isFiltered in interface FilteredModel<R>
    
    Parameters:
    
    item - the item
    
    Returns:
    
    true if the given item is filtered
  - refresh
```
public final void refresh()
```
    Refreshes the items in this table model, respecting the selection, filtering as well as sorting states. If run on the Event Dispatch Thread the refresh happens asynchronously, unless async refresh has been disabled via FilteredModel.setAsyncRefresh(boolean). Note that an empty selection event will be triggered during a normal refresh, since the model is cleared before it is repopulated, during which the selection is cleared as well. Using merge on insert (FilteredTableModel.setMergeOnRefresh(boolean)) will prevent that at a considerable performance cost.
    
    Specified by:
    
    refresh in interface FilteredModel<R>
    
    Specified by:
    
    refresh in interface FilteredTableModel<R,C>
    
    See Also:
    
    refreshItems()
  - refreshThen
```
public final void refreshThen(Consumer<Collection<R>> afterRefresh)
```
    Description copied from interface: FilteredModel
    
    Refreshes the data in this model. Note that this method only throws exceptions when run synchronously off the EDT. Use FilteredModel.addRefreshFailedListener(EventDataListener) to listen for exceptions that happen during asynchronous refresh.
    
    Specified by:
    
    refreshThen in interface FilteredModel<R>
    
    Parameters:
    
    afterRefresh - called after a successful refresh, may be null
    
    See Also:
    
    FilteredModel.refreshingObserver(), FilteredModel.addRefreshListener(EventListener), FilteredModel.addRefreshFailedListener(EventDataListener), FilteredModel.setAsyncRefresh(boolean)
  - refreshingObserver
```
public final StateObserver refreshingObserver()
```
    Specified by:
    
    refreshingObserver in interface FilteredModel<R>
    
    Returns:
    
    an observer active while a refresh is in progress
  - clear
```
public final void clear()
```
    Description copied from interface: FilteredTableModel
    
    Clears all items from this table model
    
    Specified by:
    
    clear in interface FilteredTableModel<R,C>
  - selectionModel
```
public final FilteredTableSelectionModel<R> selectionModel()
```
    Specified by:
    
    selectionModel in interface FilteredTableModel<R,C>
    
    Returns:
    
    the selection model used by this table model
  - sortModel
```
public final FilteredTableSortModel<R,C> sortModel()
```
    Specified by:
    
    sortModel in interface FilteredTableModel<R,C>
    
    Returns:
    
    the sorting model
  - searchModel
```
public final FilteredTableSearchModel searchModel()
```
    Specified by:
    
    searchModel in interface FilteredTableModel<R,C>
    
    Returns:
    
    the search model
  - columnSummaryModel
```
public final Optional<ColumnSummaryModel> columnSummaryModel(C columnIdentifier)
```
    Description copied from interface: FilteredTableModel
    
    Returns the ColumnSummaryModel associated with columnIdentifier
    
    Specified by:
    
    columnSummaryModel in interface FilteredTableModel<R,C>
    
    Parameters:
    
    columnIdentifier - the column identifier
    
    Returns:
    
    the ColumnSummaryModel for the column identified by the given identifier, an empty Optional if none is available
  - columnFilterModels
```
public final Map<C,ColumnConditionModel<? extends C,?>> columnFilterModels()
```
    Specified by:
    
    columnFilterModels in interface FilteredTableModel<R,C>
    
    Returns:
    
    the column filter models, mapped to their respective column identifier
  - columnFilterModel
```
public final <T> ColumnConditionModel<C,T> columnFilterModel(C columnIdentifier)
```
    Description copied from interface: FilteredTableModel
    
    Returns the ColumnConditionModel for the column with the given identifier.
    
    Specified by:
    
    columnFilterModel in interface FilteredTableModel<R,C>
    
    Type Parameters:
    
    T - the column value type
    
    Parameters:
    
    columnIdentifier - the column identifier
    
    Returns:
    
    the ColumnConditionModel for the column with the given identifier.
  - values
```
public final <T> Collection<T> values(C columnIdentifier)
```
    Specified by:
    
    values in interface FilteredTableModel<R,C>
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    columnIdentifier - the identifier of the column for which to retrieve the values
    
    Returns:
    
    the values (including nulls) of the column identified by the given identifier from the visible rows in the table model
  - selectedValues
```
public final <T> Collection<T> selectedValues(C columnIdentifier)
```
    Specified by:
    
    selectedValues in interface FilteredTableModel<R,C>
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    columnIdentifier - the identifier of the column for which to retrieve the values
    
    Returns:
    
    the values (including nulls) of the column identified by the given identifier from the selected rows in the table model
  - isMergeOnRefresh
```
public final boolean isMergeOnRefresh()
```
    Specified by:
    
    isMergeOnRefresh in interface FilteredTableModel<R,C>
    
    Returns:
    
    true if merge on refresh is enabled
  - setMergeOnRefresh
```
public final void setMergeOnRefresh(boolean mergeOnRefresh)
```
    Specified by:
    
    setMergeOnRefresh in interface FilteredTableModel<R,C>
    
    Parameters:
    
    mergeOnRefresh - true if merge on refresh should be enabled
  - isAsyncRefresh
```
public final boolean isAsyncRefresh()
```
    Specified by:
    
    isAsyncRefresh in interface FilteredModel<R>
    
    Returns:
    
    true if asynchronous refreshing is enabled, true by default
    
    See Also:
    
    FilteredModel.ASYNC_REFRESH
  - setAsyncRefresh
```
public final void setAsyncRefresh(boolean asyncRefresh)
```
    Description copied from interface: FilteredModel
    
    Sometimes we'd like to be able to refresh one or more models and perform some action on the refreshed data, after the refresh has finished, such as selecting a particular item or such. This is quite difficult to achieve with asynchronous refresh enabled, so here's a way to temporarily disable asynchronous refresh, for a more predictable behaviour.
    
    Specified by:
    
    setAsyncRefresh in interface FilteredModel<R>
    
    Parameters:
    
    asyncRefresh - true if asynchronous refreshing should be enabled, true by default
    
    See Also:
    
    FilteredModel.ASYNC_REFRESH
  - itemAt
```
public final R itemAt(int rowIndex)
```
    Specified by:
    
    itemAt in interface FilteredTableModel<R,C>
    
    Parameters:
    
    rowIndex - the row index
    
    Returns:
    
    the item at the given row index in the table model
  - indexOf
```
public final int indexOf(R item)
```
    Specified by:
    
    indexOf in interface FilteredTableModel<R,C>
    
    Parameters:
    
    item - the item
    
    Returns:
    
    the index of the item in the table model
  - sortItems
```
public final void sortItems()
```
    Description copied from interface: FilteredTableModel
    
    Sorts the visible items according to the FilteredTableSortModel, keeping the selected items. Calling this method with the sort model disabled has no effect.
    
    Specified by:
    
    sortItems in interface FilteredTableModel<R,C>
    
    See Also:
    
    FilteredTableModel.sortModel(), FilteredTableModel.addSortListener(EventListener), FilteredTableSortModel.isSortingEnabled()
  - filterItems
```
public final void filterItems()
```
    Description copied from interface: FilteredModel
    
    Filters this model according to the condition returned by FilteredModel.getIncludeCondition(). If no include condition is specified this method does nothing. This method does not interfere with the internal ordering of the visible items.
    
    Specified by:
    
    filterItems in interface FilteredModel<R>
    
    See Also:
    
    FilteredModel.getIncludeCondition(), FilteredModel.setIncludeCondition(Predicate), FilteredModel.addFilterListener(EventListener)
  - getIncludeCondition
```
public final Predicate<R> getIncludeCondition()
```
    Description copied from interface: FilteredModel
    
    Returns the include condition used by this model, null if no include condition has been set.
    
    Specified by:
    
    getIncludeCondition in interface FilteredModel<R>
    
    Returns:
    
    the include condition
  - setIncludeCondition
```
public final void setIncludeCondition(Predicate<R> includeCondition)
```
    Description copied from interface: FilteredModel
    
    Sets the include condition and filters the model
    
    Specified by:
    
    setIncludeCondition in interface FilteredModel<R>
    
    Parameters:
    
    includeCondition - the Predicate to use when filtering, null if no filtering should be performed
  - removeItem
```
public final void removeItem(R item)
```
    Description copied from interface: FilteredTableModel
    
    Removes the given item from this table model
    
    Specified by:
    
    removeItem in interface FilteredTableModel<R,C>
    
    Parameters:
    
    item - the item to remove from the model
  - removeItems
```
public final void removeItems(Collection<R> items)
```
    Description copied from interface: FilteredTableModel
    
    Removes the given items from this table model
    
    Specified by:
    
    removeItems in interface FilteredTableModel<R,C>
    
    Parameters:
    
    items - the items to remove from the model
  - removeItemAt
```
public final void removeItemAt(int index)
```
    Description copied from interface: FilteredTableModel
    
    Removes from this table model the visible element whose index is between index
    
    Specified by:
    
    removeItemAt in interface FilteredTableModel<R,C>
    
    Parameters:
    
    index - the index of the row to be removed
  - removeItems
```
public final void removeItems(int fromIndex,
                              int toIndex)
```
    Description copied from interface: FilteredTableModel
    
    Removes from this table model all visible elements whose index is between fromIndex, inclusive and toIndex, exclusive
    
    Specified by:
    
    removeItems in interface FilteredTableModel<R,C>
    
    Parameters:
    
    fromIndex - index of first row to be removed
    
    toIndex - index after last row to be removed
  - allowSelectionChange
```
public boolean allowSelectionChange()
```
    A default implementation returning true
    
    Specified by:
    
    allowSelectionChange in interface FilteredTableModel<R,C>
    
    Returns:
    
    true
  - addRowsRemovedListener
```
public final void addRowsRemovedListener(EventDataListener<FilteredTableModel.RowsRemoved> listener)
```
    Description copied from interface: FilteredTableModel
    
    Adds a listener that is notified each time rows are removed from this model.
    
    Specified by:
    
    addRowsRemovedListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - the listener
  - removeRowsRemovedListener
```
public final void removeRowsRemovedListener(EventDataListener<FilteredTableModel.RowsRemoved> listener)
```
    Specified by:
    
    removeRowsRemovedListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - the listener to remove
  - columnModel
```
public final FilteredTableColumnModel<C> columnModel()
```
    Specified by:
    
    columnModel in interface FilteredTableModel<R,C>
    
    Returns:
    
    the FilteredTableColumnModel used by this TableModel
  - getColumnClass
```
public final Class<?> getColumnClass(C columnIdentifier)
```
    Description copied from interface: FilteredTableModel
    
    Returns the class of the column with the given identifier
    
    Specified by:
    
    getColumnClass in interface FilteredTableModel<R,C>
    
    Parameters:
    
    columnIdentifier - the column identifier
    
    Returns:
    
    the Class representing the given column
  - getColumnClass
```
public final Class<?> getColumnClass(int columnIndex)
```
    Specified by:
    
    getColumnClass in interface TableModel
    
    Overrides:
    
    getColumnClass in class AbstractTableModel
  - getValueAt
```
public final Object getValueAt(int rowIndex,
                               int columnIndex)
```
    Specified by:
    
    getValueAt in interface TableModel
  - getStringValueAt
```
public final String getStringValueAt(int rowIndex,
                                     C columnIdentifier)
```
    Description copied from interface: FilteredTableModel
    
    Returns a String representation of the value for the given row and column.
    
    Specified by:
    
    getStringValueAt in interface FilteredTableModel<R,C>
    
    Parameters:
    
    rowIndex - the row index
    
    columnIdentifier - the column identifier
    
    Returns:
    
    the string value
  - addRefreshListener
```
public final void addRefreshListener(EventListener listener)
```
    Specified by:
    
    addRefreshListener in interface FilteredModel<R>
    
    Parameters:
    
    listener - a listener to be notified each time this model has been successfully refreshed
    
    See Also:
    
    FilteredModel.refresh()
  - removeRefreshListener
```
public final void removeRefreshListener(EventListener listener)
```
    Specified by:
    
    removeRefreshListener in interface FilteredModel<R>
    
    Parameters:
    
    listener - the listener to remove
    
    See Also:
    
    FilteredModel.refresh()
  - addRefreshFailedListener
```
public final void addRefreshFailedListener(EventDataListener<Throwable> listener)
```
    Specified by:
    
    addRefreshFailedListener in interface FilteredModel<R>
    
    Parameters:
    
    listener - a listener to be notified each time an asynchronous refresh has failed
    
    See Also:
    
    FilteredModel.refresh()
  - removeRefreshFailedListener
```
public final void removeRefreshFailedListener(EventDataListener<Throwable> listener)
```
    Specified by:
    
    removeRefreshFailedListener in interface FilteredModel<R>
    
    Parameters:
    
    listener - the listener to remove
  - addFilterListener
```
public final void addFilterListener(EventListener listener)
```
    Specified by:
    
    addFilterListener in interface FilteredModel<R>
    
    Parameters:
    
    listener - a listener notified each time this model is filtered
  - removeFilterListener
```
public final void removeFilterListener(EventListener listener)
```
    Specified by:
    
    removeFilterListener in interface FilteredModel<R>
    
    Parameters:
    
    listener - the listener to remove
  - addSortListener
```
public final void addSortListener(EventListener listener)
```
    Specified by:
    
    addSortListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - a listener to be notified each time the model has been sorted
  - removeSortListener
```
public final void removeSortListener(EventListener listener)
```
    Specified by:
    
    removeSortListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - the listener to remove
  - addDataChangedListener
```
public final void addDataChangedListener(EventListener listener)
```
    Specified by:
    
    addDataChangedListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - a listener to be notified each time the table data changes
  - removeDataChangedListener
```
public final void removeDataChangedListener(EventListener listener)
```
    Specified by:
    
    removeDataChangedListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - the listener to remove
  - addClearListener
```
public final void addClearListener(EventListener listener)
```
    Specified by:
    
    addClearListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - a listener to be notified each time the table model is cleared
  - removeClearListener
```
public final void removeClearListener(EventListener listener)
```
    Specified by:
    
    removeClearListener in interface FilteredTableModel<R,C>
    
    Parameters:
    
    listener - the listener to remove
  - refreshItems
```
protected Collection<R> refreshItems()
```
    Returns the items this table model should contain. By default, this simply returns the items already in the model. Override to fetch data from a datasource of some kind.
    
    Returns:
    
    the items this table model should contain, an empty Collection in case of no items.
  - createColumnValueProvider
```
protected <T extends Number> Optional<ColumnSummaryModel.SummaryValueProvider<T>> createColumnValueProvider(C columnIdentifier)
```
    Creates a ColumnValueProvider for the given column
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    columnIdentifier - the column identifier
    
    Returns:
    
    a ColumnValueProvider for the column identified by the given identifier, an empty Optional if not applicable
  - addItems
```
protected final void addItems(Collection<R> items)
```
    Adds the given items to the bottom of this table model.
    
    Parameters:
    
    items - the items to add
  - addItemsSorted
```
protected final void addItemsSorted(Collection<R> items)
```
    Adds the given items to the bottom of this table model. If sorting is enabled this model is sorted after the items have been added.
    
    Parameters:
    
    items - the items to add
  - addItemsAt
```
protected final void addItemsAt(int index,
                                Collection<R> items)
```
    Adds the given items to this table model, non-filtered items are added at the given index.
    
    Parameters:
    
    index - the index at which to add the items
    
    items - the items to add
  - addItemsAtSorted
```
protected final void addItemsAtSorted(int index,
                                      Collection<R> items)
```
    Adds the given items to this table model, non-filtered items are added at the given index. If sorting is enabled this model is sorted after the items have been added.
    
    Parameters:
    
    index - the index at which to add the items
    
    items - the items to add
    
    See Also:
    
    FilteredTableSortModel.isSortingEnabled()
  - addItem
```
protected final void addItem(R item)
```
    Adds the given item to the bottom of this table model.
    
    Parameters:
    
    item - the item to add
  - addItemSorted
```
protected final void addItemSorted(R item)
```
    Adds the given item to the bottom of this table model. If sorting is enabled this model is sorted after the item has been added.
    
    Parameters:
    
    item - the item to add
  - setItemAt
```
protected final void setItemAt(int index,
                               R item)
```
    Sets the item at the given index. If the item should be filtered calling this method has no effect.
    
    Parameters:
    
    index - the index
    
    item - the item
    
    See Also:
    
    setIncludeCondition(Predicate)

Class DefaultFilteredTableModel<R,C>

Nested Class Summary

Nested classes/interfaces inherited from interface is.codion.swing.common.model.component.table.FilteredTableModel

Field Summary

Fields inherited from class javax.swing.table.AbstractTableModel

Fields inherited from interface is.codion.common.model.FilteredModel

Constructor Summary

Method Summary

Methods inherited from class javax.swing.table.AbstractTableModel

Methods inherited from class java.lang.Object

Methods inherited from interface javax.swing.table.TableModel

Constructor Detail

DefaultFilteredTableModel

DefaultFilteredTableModel

Method Detail

items

visibleItems

filteredItems

visibleItemCount

filteredItemCount

getColumnCount

getRowCount

containsItem

isVisible

isFiltered

refresh

refreshThen

refreshingObserver

clear

selectionModel

sortModel

searchModel

columnSummaryModel

columnFilterModels

columnFilterModel

values

selectedValues

isMergeOnRefresh

setMergeOnRefresh

isAsyncRefresh

setAsyncRefresh

itemAt

indexOf

sortItems

filterItems

getIncludeCondition

setIncludeCondition

removeItem

removeItems

removeItemAt

removeItems

allowSelectionChange

addRowsRemovedListener

removeRowsRemovedListener

columnModel

getColumnClass

getColumnClass

getValueAt

getStringValueAt

addRefreshListener

removeRefreshListener

addRefreshFailedListener

removeRefreshFailedListener

addFilterListener

removeFilterListener

addSortListener

removeSortListener

addDataChangedListener

removeDataChangedListener

addClearListener

removeClearListener

refreshItems

createColumnValueProvider

addItems

addItemsSorted

addItemsAt

addItemsAtSorted

addItem

addItemSorted

setItemAt