com.softicar.platform.common.container.data.table.in.memory.AbstractInMemoryDataTable Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of platform-common Show documentation
The SoftiCAR Platform is a lightweight, Java-based library to create interactive business web applications.
There is a newer version: 50.0.0
package com.softicar.platform.common.container.data.table.in.memory;

import com.softicar.platform.common.container.data.table.DataTableFilterListOperator;
import com.softicar.platform.common.container.data.table.IDataTable;
import com.softicar.platform.common.container.data.table.IDataTableColumn;
import com.softicar.platform.common.container.data.table.IDataTableFilterList;
import com.softicar.platform.common.container.data.table.IDataTableSorterList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/**
 * Abstract implementation of memory based {@link IDataTable}.
 *
 * @author Alexander Schmidt
 * @author Oliver Richers
 */
public abstract class AbstractInMemoryDataTable implements IDataTable {

	private final InMemoryDataTableFilterList filterList;
	private final InMemoryDataTableSorterList sorterList;
	private final IInMemoryRowProvider rowProvider;
	private final InMemoryDataTableStructure tableStructure;

	/**
	 * Constructs a new instance with an empty table structure.
	 * 
	 * The table structure can be defined by calling {@link #newColumn}.
	 */
	public AbstractInMemoryDataTable() {

		this(new InMemoryDataTableStructure<>());
	}

	/**
	 * Constructs a new instance with the given table structure.
	 *
	 * @param tableStructure
	 *            the predefined table structure (never null)
	 */
	public AbstractInMemoryDataTable(InMemoryDataTableStructure tableStructure) {

		this.filterList = new InMemoryDataTableFilterList<>(DataTableFilterListOperator.AND, this::onFilterChanged);
		this.sorterList = new InMemoryDataTableSorterList<>(this::onSorterChanged);
		this.rowProvider = new InMemoryCachingRowProvider<>(this::getTableRows, filterList, sorterList);
		this.tableStructure = Objects.requireNonNull(tableStructure);
	}

	// -------------------- IDataTable -------------------- //

	@Override
	public List> getTableColumns() {

		return tableStructure.getTableColumns();
	}

	@Override
	public  List getDistinctColumnValues(IDataTableColumn column, int limit) {

		return new InMemoryDataTableColumnValuesLoader<>(column).loadDistinctValues(getTableRows(), limit);
	}

	@Override
	public List list(int offset, int limit) {

		return rowProvider.getFilteredAndSortedRows(offset, limit);
	}

	@Override
	public Iterator iterator(int offset, int limit) {

		return rowProvider.getFilteredAndSortedRows(offset, limit).iterator();
	}

	@Override
	public int count() {

		return rowProvider.getRowCount();
	}

	@Override
	public IDataTableFilterList getFilters() {

		return filterList;
	}

	@Override
	public IDataTableSorterList getSorters() {

		return sorterList;
	}

	@Override
	public void invalidateCaches() {

		rowProvider.invalidateCaches();
	}

	/**
	 * Initiates the creation of a new table column.
	 *
	 * @param valueClass
	 *            the value class of the column
	 * @return a column builder instance
	 */
	public  InMemoryDataTableColumnBuilder.GetterSetter newColumn(Class valueClass) {

		return tableStructure.newColumn(valueClass);
	}

	// -------------------- protected -------------------- //

	protected InMemoryDataTableStructure getTableStructure() {

		return tableStructure;
	}

	/**
	 * Returns all rows of this table as an {@link Iterable}.
	 *
	 * @return all table rows (never null)
	 */
	protected abstract Iterable getTableRows();

	// -------------------- private -------------------- //

	private void onFilterChanged() {

		rowProvider.onFilterChanged();
	}

	private void onSorterChanged() {

		rowProvider.onSorterChanged();
	}
}