com.landawn.abacus.util.DataSet Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abacus-common Show documentation
Show all versions of abacus-common Show documentation
A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.
The newest version!
/*
* Copyright (c) 2015, Haiyang Li.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.landawn.abacus.util;
import java.io.File;
import java.io.OutputStream;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collector;
import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.exception.UncheckedIOException;
import com.landawn.abacus.util.If.OrElse;
import com.landawn.abacus.util.NoCachingNoUpdating.DisposableObjArray;
import com.landawn.abacus.util.Tuple.Tuple2;
import com.landawn.abacus.util.Tuple.Tuple3;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.function.IntObjFunction;
import com.landawn.abacus.util.function.TriFunction;
import com.landawn.abacus.util.function.TriPredicate;
import com.landawn.abacus.util.stream.Stream;
/**
* The DataSet interface represents a data structure that holds a collection of data in a tabular format.
* It provides a variety of methods for manipulating and accessing the data, such as sorting, filtering, joining, and grouping.
* It also supports operations like union, intersection, and difference between two DataSets.
* The data in a DataSet is organized into rows and columns, similar to a table in a relational database.
* Each column in a DataSet has a name(case-sensitive), and the data within a column is of a specific type.
*
* @see com.landawn.abacus.util.Builder.DataSetBuilder
* @see com.landawn.abacus.util.Sheet
* @see com.landawn.abacus.util.CSVUtil
* @see com.landawn.abacus.util.Fn.Factory
* @see com.landawn.abacus.util.Clazz
* @see com.landawn.abacus.util.N#newEmptyDataSet()
* @see com.landawn.abacus.util.N#newEmptyDataSet(Collection)
* @see com.landawn.abacus.util.N#newDataSet(Map)
* @see com.landawn.abacus.util.N#newDataSet(Collection)
* @see com.landawn.abacus.util.N#newDataSet(Collection, Collection)
* @see com.landawn.abacus.util.N#newDataSet(String, String, Map)
*/
public interface DataSet {
/**
* Returns an empty immutable {@code DataSet}.
* This method can be used when you need an empty DataSet for initialization or comparison purposes.
*
* @return an empty immutable {@code DataSet}
*/
static DataSet empty() {
return RowDataSet.EMPTY_DATA_SET;
}
/**
* Creates a new DataSet with the specified column names and rows.
*
* The DataSet is a data structure that stores data in a tabular format, similar to a table in a database.
* Each item in the columnNames collection represents a column in the DataSet.
* The rows parameter is a 2D array where each sub-array represents a row in the DataSet.
* The order of elements in each row should correspond to the order of column names.
*
* @param columnNames A collection of strings representing the names of the columns in the DataSet.
* @param rows A 2D array representing the data in the DataSet. Each sub-array is a row.
* @return A new DataSet with the specified column names and rows.
* @throws IllegalArgumentException If the provided columnNames and rows do not align properly.
* @see N#newDataSet(Collection, Object[][])
*/
static DataSet rows(final Collection columnNames, final Object[][] rows) throws IllegalArgumentException {
return N.newDataSet(columnNames, rows);
}
/**
* Creates a new DataSet with the specified column names and rows.
*
* The DataSet is a data structure that stores data in a tabular format, similar to a table in a database.
* Each item in the columnNames collection represents a column in the DataSet.
* The rows parameter is a collection of collections where each sub-collection represents a row in the DataSet.
* The order of elements in each row should correspond to the order of column names.
*
* @param columnNames A collection of strings representing the names of the columns in the DataSet.
* @param rows A collection of collections representing the data in the DataSet. Each sub-collection is a row which can be: Map/Bean/Array/List.
* @return A new DataSet with the specified column names and rows.
* @throws IllegalArgumentException If the provided columnNames and rows do not align properly.
* @see N#newDataSet(Collection, Collection)
*/
static DataSet rows(final Collection columnNames, final Collection> rows) throws IllegalArgumentException {
return N.newDataSet(columnNames, rows);
}
/**
* Creates a new DataSet with the specified column names and columns.
*
* The DataSet is a data structure that stores data in a tabular format, similar to a table in a database.
* Each item in the columnNames collection represents a column in the DataSet.
* The columns parameter is a 2D array where each sub-array represents a column in the DataSet.
* The order of elements in each column should correspond to the order of column names.
*
* @param columnNames A collection of strings representing the names of the columns in the DataSet.
* @param columns A 2D array representing the data in the DataSet. Each sub-array is a column.
* @return A new DataSet with the specified column names and columns.
* @throws IllegalArgumentException If the length of columnNames is not equal to the length of columns or the size of the sub-collection in columns is not equal.
*/
static DataSet columns(final Collection columnNames, final Object[][] columns) throws IllegalArgumentException {
if (N.size(columnNames) != N.len(columns)) {
throw new IllegalArgumentException("The length of 'columnNames' is not equal to the length of the sub-collections in 'columns'.");
}
final int columnCount = N.size(columnNames);
final int rowCount = N.len(N.firstOrNullIfEmpty(columns));
final List columnNameList = N.newArrayList(columnNames);
final List> columnList = new ArrayList<>(columnCount);
for (final Object[] column : columns) {
if (N.len(column) != rowCount) {
throw new IllegalArgumentException("The size of the sub-collection in 'columns' is not equal.");
}
columnList.add(Array.asList(column));
}
return new RowDataSet(columnNameList, columnList);
}
/**
* Creates a new DataSet with the specified column names and columns.
*
* The DataSet is a data structure that stores data in a tabular format, similar to a table in a database.
* Each item in the columnNames collection represents a column in the DataSet.
* The columns parameter is a collection of collections where each sub-collection represents a column in the DataSet.
*
* @param columnNames A collection of strings representing the names of the columns in the DataSet.
* @param columns A collection of collections representing the data in the DataSet. Each sub-collection is a column.
* @return A new DataSet with the specified column names and columns.
* @throws IllegalArgumentException If the length of columnNames is not equal to the length of columns or the size of the sub-collection in columns is not equal.
*/
static DataSet columns(final Collection columnNames, final Collection> columns) throws IllegalArgumentException {
if (N.size(columnNames) != N.size(columns)) {
throw new IllegalArgumentException("The length of 'columnNames' is not equal to the length of the sub-collections in 'columns'.");
}
final int columnCount = N.size(columnNames);
final int rowCount = N.size(N.firstOrNullIfEmpty(columns));
final List columnNameList = N.newArrayList(columnNames);
final List> columnList = new ArrayList<>(columnCount);
for (final Collection column : columns) {
if (N.size(column) != rowCount) {
throw new IllegalArgumentException("The size of the sub-collection in 'columns' is not equal.");
}
columnList.add(N.newArrayList(column));
}
return new RowDataSet(columnNameList, columnList);
}
// /**
// * Creates a new DataSet with a single column.
// *
// * The DataSet is a data structure that stores data in a tabular format, similar to a table in a database.
// * The 'columnName' parameter represents the name of the column in the DataSet.
// * The 'column' parameter is a collection where each item represents a row in the DataSet.
// *
// * @param columnName A string representing the name of the column in the DataSet.
// * @param column A collection of objects representing the data in the DataSet. Each object is a row.
// * @return A new DataSet with the specified column name and column data.
// * @throws IllegalArgumentException If the provided columnName is empty.
// * @see #columns(Collection, Collection)
// * @see N#newDataSet(String, Collection)
// */
// static DataSet singleColumn(final String columnName, final Collection column) throws IllegalArgumentException {
// return N.newDataSet(columnName, column);
// }
// /**
// * Returns the bean name associated with the query.
// *
// * @return
// */
// String beanName();
//
// /**
// * Returns the target bean class associated with the query.
// *
// * @return
// */
// Class rowType();
/**
* Returns an immutable list of column names in this DataSet.
* The order of the column names in the list reflects the order of the columns in the DataSet.
*
* @return an ImmutableList of column names
*/
ImmutableList columnNameList();
/**
* Returns the number of columns in this DataSet.
*
* @return the count of columns
*/
int columnCount();
/**
* Returns the column name for the specified column index.
*
* @param columnIndex the index of the column.
* @return the name of the column at the specified index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds
*/
String getColumnName(int columnIndex) throws IndexOutOfBoundsException;
/**
* Returns the index of the specified column in the DataSet.
*
* @param columnName the name(case-sensitive) of the column for which the index is required.
* @return the index of the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
*/
int getColumnIndex(String columnName) throws IllegalArgumentException;
/**
* Returns an array of column indexes corresponding to the provided column names.
*
* @param columnNames the collection of column names(case-sensitive) for which indexes are required.
* @return an array of integers representing the indexes of the specified columns.
* @throws IllegalArgumentException if any of the provided column names does not exist in the DataSet.
*/
int[] getColumnIndexes(Collection columnNames) throws IllegalArgumentException;
/**
* Checks if the specified column name exists in this DataSet.
*
* @param columnName the name(case-sensitive) of the column to check.
* @return {@code true} if the column exists, {@code false} otherwise.
*/
boolean containsColumn(String columnName);
/**
* Check if this {@code DataSet} contains all the specified columns.
*
* @param columnNames the collection of column names(case-sensitive) to check.
* @return {@code true} if all the specified columns are included in the this {@code DataSet}
*/
boolean containsAllColumns(Collection columnNames);
/**
* Renames a column in the DataSet.
*
* @param columnName the current name of the column.
* @param newColumnName the new name for the column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet or the new column name exists in the DataSet.
*/
void renameColumn(String columnName, String newColumnName) throws IllegalArgumentException;
/**
* Renames multiple columns in the DataSet.
*
* @param oldNewNames a map where the key is the current name of the column and the value is the new name for the column.
* @throws IllegalArgumentException if any of the specified old column names does not exist in the DataSet or any of the new column names already exists in the DataSet.
*/
void renameColumns(Map oldNewNames) throws IllegalArgumentException;
// /**
// *
// * @param columnName
// * @param func
// */
// void renameColumn(String columnName, Function func) ;
/**
* Renames multiple columns in the DataSet using a function to determine the new names.
*
* @param columnNames the collection of current column names to be renamed.
* @param func a function that takes the current column name as input and returns the new column name.
* @throws IllegalArgumentException if any of the specified old column names does not exist in the DataSet or any of the new column names already exists in the DataSet.
*/
void renameColumns(Collection columnNames, Function func) throws IllegalArgumentException;
/**
* Renames all columns in the DataSet using a function to determine the new names.
*
* @param func a function that takes the current column name as input and returns the new column name.
* @throws IllegalArgumentException if any of the new column names already exists in the DataSet.
*/
void renameColumns(Function func) throws IllegalArgumentException;
/**
* Moves a column in the DataSet to a new position.
*
* @param columnName the name of the column to be moved.
* @param newPosition the new position for the column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet or the new position is out of bounds.
*/
void moveColumn(String columnName, int newPosition) throws IllegalArgumentException;
/**
* Moves multiple columns in the DataSet to new positions.
*
* @param columnNameNewPositionMap a map where the key is the current name of the column and the value is the new position for the column.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or any of the new positions are out of bounds.
*/
void moveColumns(Map columnNameNewPositionMap) throws IllegalArgumentException;
/**
* Swaps the positions of two columns in the DataSet.
*
* @param columnNameA the name of the first column to be swapped.
* @param columnNameB the name of the second column to be swapped.
* @throws IllegalArgumentException if either of the specified column names does not exist in the DataSet.
*/
void swapColumns(String columnNameA, String columnNameB) throws IllegalArgumentException;
/**
* Moves a row in the DataSet to a new position.
*
* @param rowIndex the index of the row to be moved.
* @param newRowIndex the new position for the row.
* @throws IllegalArgumentException if the specified row index is out of bounds or the new position is out of bounds.
*/
void moveRow(int rowIndex, int newRowIndex) throws IllegalArgumentException;
/**
* Swaps the positions of two rows in the DataSet.
*
* @param rowIndexA the index of the first row to be swapped.
* @param rowIndexB the index of the second row to be swapped.
* @throws IllegalArgumentException if either of the specified row indexes is out of bounds.
*/
void swapRows(int rowIndexA, int rowIndexB) throws IllegalArgumentException;
/**
* Retrieves the value at the specified row and column index in the DataSet.
*
* There is NO underline auto-conversion from column value to target type: {@code T}.
* So the column values must be the type which is assignable to target type.
*
* @param the type of the value to be returned.
* @param rowIndex the index of the row.
* @param columnIndex the index of the column.
* @return the value at the specified row and column index.
* @throws IndexOutOfBoundsException if the specified row or column index is out of bounds.
*/
T get(int rowIndex, int columnIndex) throws IndexOutOfBoundsException;
// /**
// * There is NO underline auto-conversion from column value to target type: {@code T}.
// * So the column values must be the type which is assignable to target type.
// *
// * @param rowIndex
// * @param columnIndex
// * @param targetType
// *
// * @param
// * @return
// * @throws UnsupportedOperationException
// * @deprecated may be misused because it implies there is an underline auto-conversion from column values to target return type but actually there is not.
// */
// @SuppressWarnings("unused")
// @Deprecated
// default T get(int rowIndex, int columnIndex, Class targetType) throws UnsupportedOperationException {
// throw new UnsupportedOperationException();
// }
/**
* Sets the value at the specified row and column index in the DataSet.
*
* @param rowIndex the index of the row.
* @param columnIndex the index of the column.
* @param element the new value to be set at the specified row and column index.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if the specified row or column index is out of bounds.
*/
void set(int rowIndex, int columnIndex, Object element) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Checks if the value at the specified row and column index in the DataSet is {@code null}.
*
* @param rowIndex the index of the row.
* @param columnIndex the index of the column.
* @return {@code true} if the value at the specified row and column index is {@code null}, {@code false} otherwise.
* @throws IndexOutOfBoundsException if the specified row or column index is out of bounds.
*/
boolean isNull(int rowIndex, int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code T}.
* So the column values must be the type which is assignable to target type.
*
* @param the type of the value to be returned.
* @param columnIndex the index of the column.
* @return the value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
T get(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code T}.
* So the column values must be the type which is assignable to target type.
*
* Using {@code get(int)} for better performance.
*
* @param the type of the value to be returned.
* @param columnName the name of the column.
* @return the value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #get(int)
*/
T get(String columnName);
// /**
// * There is NO underline auto-conversion from column value to target type: {@code T}.
// * So the column values must be the type which is assignable to target type.
// *
// *
// * @param
// * @return
// * @throws UnsupportedOperationException
// * @deprecated may be misused because it implies there is an underline auto-conversion from column values to target return type but actually there is not.
// */
// @SuppressWarnings("unused")
// @Deprecated
// default T get(int columnIndex, Class targetType) throws UnsupportedOperationException {
// throw new UnsupportedOperationException();
// }
//
// /**
// *
// * There is NO underline auto-conversion from column value to target type: {@code T}.
// * So the column values must be the type which is assignable to target type.
// *
// * @param columnName
// * @param targetType
// *
// * @param
// * @return
// * @throws UnsupportedOperationException
// * @deprecated may be misused because it implies there is an underline auto-conversion from column values to target return type but actually there is not.
// */
// @SuppressWarnings("unused")
// @Deprecated
// default T get(String columnName, Class targetType) throws UnsupportedOperationException {
// throw new UnsupportedOperationException();
// }
//
// /**
// * Returns the value from the current row and specified column if the specified {@code columnIndex} is equal or bigger than zero,
// * or the specified {@code defaultValue} otherwise.
// *
// * There is NO underline auto-conversion from column value to target type: {@code T}.
// * So the column values must be the type which is assignable to target type.
// *
// * @param
// * @param columnIndex
// * @param defaultValue
// * @return
// * @throws UnsupportedOperationException
// * @deprecated
// */
// @SuppressWarnings("unused")
// @Deprecated
// default T getOrDefault(int columnIndex, T defaultValue) throws UnsupportedOperationException {
// throw new UnsupportedOperationException();
// }
//
// /**
// * Returns the value from the current row and specified column if the specified {@code columnName} exists,
// * or the specified {@code defaultValue} otherwise.
// *
// * There is NO underline auto-conversion from column value to target type: {@code T}.
// * So the column values must be the type which is assignable to target type.
// *
// * @param
// * @param columnName
// * @param defaultValue
// * @return
// * @throws UnsupportedOperationException
// * @deprecated
// */
// @SuppressWarnings("unused")
// @Deprecated
// default T getOrDefault(String columnName, T defaultValue) throws UnsupportedOperationException {
// throw new UnsupportedOperationException();
// }
/**
* Retrieves the boolean value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Boolean}.
* So the column values must be the type which is assignable to target type.
*
* Returns default value (false) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the boolean value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
boolean getBoolean(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the boolean value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Boolean}.
* So the column values must be the type which is assignable to target type.
*
* Returns default value (false) if the property is {@code null}.
*
* Using {@code getBoolean(int)} for better performance.
*
* @param columnName the name of the column.
* @return the boolean value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getBoolean(int)
*/
boolean getBoolean(String columnName) throws IllegalArgumentException;
/**
* Retrieves the char value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Character}.
* So the column values must be the type which is assignable to target type.
*
* Returns default value (0) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the char value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
char getChar(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the char value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Character}.
* So the column values must be the type which is assignable to target type.
*
* Returns default value (0) if the property is {@code null}.
*
* Using {@code getChar(int)} for better performance.
*
* @param columnName the name of the column.
* @return the char value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getChar(int)
*/
char getChar(String columnName) throws IllegalArgumentException;
/**
* Retrieves the byte value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Byte}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the byte value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
byte getByte(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the byte value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Byte}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* Using {@code getByte(int)} for better performance.
*
* @param columnName the name of the column.
* @return the byte value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getByte(int)
*/
byte getByte(String columnName) throws IllegalArgumentException;
/**
* Retrieves the short value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Short}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the short value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
short getShort(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the short value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Short}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* Using {@code getShort(int)} for better performance.
*
* @param columnName the name of the column.
* @return the short value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getShort(int)
*/
short getShort(String columnName) throws IllegalArgumentException;
/**
* Retrieves the integer value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Integer}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the integer value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
int getInt(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the integer value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Integer}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* Using {@code getInt(int)} for better performance.
*
*
* @param columnName the name of the column.
* @return the integer value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getInt(int)
*/
int getInt(String columnName) throws IllegalArgumentException;
/**
* Retrieves the long value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Long}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the long value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
long getLong(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the long value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Long}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0) if the property is {@code null}.
*
* Using {@code getLong(int)} for better performance.
*
* @param columnName the name of the column.
* @return the long value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getLong(int)
*/
long getLong(String columnName) throws IllegalArgumentException;
/**
* Retrieves the float value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Float}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0f) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the float value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
float getFloat(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the float value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Float}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0f) if the property is {@code null}.
*
* Using {@code getFloat(int)} for better performance.
*
* @param columnName the name of the column.
* @return the float value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getFloat(int)
*/
float getFloat(String columnName) throws IllegalArgumentException;
/**
* Retrieves the double value at the specified column index in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Double}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0d) if the property is {@code null}.
*
* @param columnIndex the index of the column.
* @return the double value at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
double getDouble(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the double value at the specified column in the DataSet for the current row.
*
* There is NO underline auto-conversion from column value to target type: {@code Double}.
* So the column values must be the type which is assignable to target type, or {@code Number}.
*
* Returns default value (0d) if the property is {@code null}.
*
* Using {@code getDouble(int)} for better performance.
*
* @param columnName the name of the column.
* @return the double value at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #getDouble(int)
*/
double getDouble(String columnName) throws IllegalArgumentException;
/**
* Checks if the value at the specified column index in the DataSet for the current row is {@code null}.
*
* This method can be used to validate the data before performing operations that do not support {@code null} values.
*
* @param columnIndex the index of the column.
* @return {@code true} if the value at the specified column index is {@code null}, {@code false} otherwise.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
boolean isNull(int columnIndex) throws IndexOutOfBoundsException;
/**
* Checks if the value at the specified column in the DataSet for the current row is {@code null}.
*
* This method can be used to validate the data before performing operations that do not support {@code null} values.
*
* Using {@code isNull(int)} for better performance.
*
* @param columnName the name of the column.
* @return {@code true} if the value at the specified column is {@code null}, {@code false} otherwise.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #isNull(int)
*/
boolean isNull(String columnName) throws IllegalArgumentException;
/**
* Sets the value at the specified column index in the DataSet for the current row.
*
* @param columnIndex the index of the column.
* @param value the new value to be set at the specified column index.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
void set(int columnIndex, Object value) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Sets the value at the specified column in the DataSet for the current row.
*
* Using {@code set(int, Object)} for better performance.
*
* @param columnName the name of the column.
* @param value the new value to be set at the specified column.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
* @see #set(int, Object)
*/
void set(String columnName, Object value) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Retrieves the values of the specified column index in the DataSet as an ImmutableList.
*
* The returned list is immutable and any attempt to modify it will result in an UnsupportedOperationException.
*
* The type of the values in the list will be the same as the type of the column.
*
* The order of the values in the list reflects the order of the rows in the DataSet.
*
* @param the type of the values to be returned.
* @param columnIndex the index of the column.
* @return an ImmutableList of values at the specified column index.
* @throws IndexOutOfBoundsException if the specified column index is out of bounds.
*/
ImmutableList getColumn(int columnIndex) throws IndexOutOfBoundsException;
/**
* Retrieves the values of the specified column in the DataSet as an ImmutableList.
*
* The returned list is immutable and any attempt to modify it will result in an UnsupportedOperationException.
*
* The type of the values in the list will be the same as the type of the column.
*
* The order of the values in the list reflects the order of the rows in the DataSet.
*
* @param the type of the values to be returned.
* @param columnName the name of the column.
* @return an ImmutableList of values at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
*/
ImmutableList getColumn(String columnName) throws IllegalArgumentException;
/**
* Retrieves the values of the specified column in the DataSet as a List.
*
* The returned list is a copy and modifications to it will not affect the original DataSet.
*
* The type of the values in the list will be the same as the type of the column.
*
* @param the type of the values to be returned.
* @param columnName the name of the column.
* @return a List of values at the specified column.
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
*/
List copyColumn(String columnName) throws IllegalArgumentException;
/**
* Adds a new column to the DataSet.
*
* The new column is added at the end of the existing columns.
* The size of this list should match the number of rows in the DataSet.
*
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param column The data for the new column. It should be a list where each element represents a row in the column.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the new column name already exists in the DataSet or the provided collection is not empty and its size does not match the number of rows in the DataSet.
*/
void addColumn(String newColumnName, Collection column) throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet at the specified position.
*
* The new column is added at the position specified by newColumnPosition. Existing columns at and after this position are shifted to the right.
* The size of the list provided should match the number of rows in the DataSet.
*
* @param newColumnPosition The position at which the new column should be added. It should be a valid index within the current column range.
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param column The data for the new column. It should be a collection where each element represents a row in the column.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified {@code newColumnPosition} is less than zero or bigger than column size or the new column name already exists in the DataSet,
* or if the provided collection is not empty and its size does not match the number of rows in the DataSet, or the newColumnPosition is out of bounds.
*/
void addColumn(int newColumnPosition, String newColumnName, Collection column) throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet.
*
* The new column is generated by applying a function to an existing column. The function takes the value of the existing column for each row and returns the value for the new column for that row.
*
* The new column is added at the end of the existing columns.
*
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnName The name of the existing column to be used as input for the function.
* @param func The function to generate the values for the new column. It takes the value of the existing column for each row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the new column name already exists in the DataSet or the existing column name does not exist in the DataSet.
*/
void addColumn(String newColumnName, String fromColumnName, Function func) throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet at the specified position.
*
* The new column is generated by applying a function to an existing column. The function takes the value of the existing column for each row and returns the value for the new column for that row.
*
* The new column is added at the position specified by newColumnPosition. Existing columns at and after this position are shifted to the right.
*
* @param newColumnPosition The position at which the new column should be added. It should be a valid index within the current column range.
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnName The name of the existing column to be used as input for the function.
* @param func The function to generate the values for the new column. It takes the value of the existing column for each row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified {@code newColumnPosition} is less than zero or bigger than column size or the new column name already exists in the DataSet, or if the existing column name does not exist in the DataSet.
*/
void addColumn(int newColumnPosition, String newColumnName, String fromColumnName, Function func)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet.
*
* The new column is generated by applying a function to multiple existing columns. The function takes the values of the existing columns for each row and returns the value for the new column for that row.
*
* The new column is added at the end of the existing columns.
*
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnNames The names of the existing columns to be used as input for the function.
* @param func The function to generate the values for the new column. It takes the values of the existing columns for each row and returns the value for the new column for that row. The input to the function is a DisposableObjArray containing the values of the existing columns for a particular row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the new column name already exists in the DataSet or any of the existing column names does not exist in the DataSet.
*/
void addColumn(String newColumnName, Collection fromColumnNames, Function func)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet at the specified position.
*
* The new column is generated by applying a function to multiple existing columns. The function takes the values of the existing columns for each row and returns the value for the new column for that row.
*
* The new column is added at the position specified by newColumnPosition. Existing columns at and after this position are shifted to the right.
*
* @param newColumnPosition The position at which the new column should be added. It should be a valid index within the current column range.
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnNames The names of the existing columns to be used as input for the function.
* @param func The function to generate the values for the new column. It takes the values of the existing columns for each row and returns the value for the new column for that row. The input to the function is a DisposableObjArray containing the values of the existing columns for a particular row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified {@code newColumnPosition} is less than zero or bigger than column size or the new column name already exists in the DataSet, or if any of the existing column names does not exist in the DataSet.
*/
void addColumn(int newColumnPosition, String newColumnName, Collection fromColumnNames, Function func)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet.
*
* The new column is generated by applying a BiFunction to two existing columns. The BiFunction takes the values of the existing columns for each row and returns the value for the new column for that row.
*
* The new column is added at the end of the existing columns.
*
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnNames A Tuple2 containing the names of the two existing columns to be used as input for the BiFunction.
* @param func The BiFunction to generate the values for the new column. It takes the values of the two existing columns for each row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the new column name already exists in the DataSet or any of the existing column names does not exist in the DataSet.
*/
void addColumn(String newColumnName, Tuple2 fromColumnNames, BiFunction func)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet at the specified position.
*
* The new column is generated by applying a BiFunction to two existing columns. The BiFunction takes the values of the two existing columns for each row and returns the value for the new column for that row.
*
* The new column is added at the position specified by newColumnPosition. Existing columns at and after this position are shifted to the right.
*
* @param newColumnPosition The position at which the new column should be added. It should be a valid index within the current column range.
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnNames A Tuple2 containing the names of the two existing columns to be used as input for the BiFunction.
* @param func The BiFunction to generate the values for the new column. It takes the values of the two existing columns for each row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified {@code newColumnPosition} is less than zero or bigger than column size or the new column name already exists in the DataSet, or if any of the existing column names does not exist in the DataSet.
*/
void addColumn(int newColumnPosition, String newColumnName, Tuple2 fromColumnNames, BiFunction func)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet.
*
* The new column is generated by applying a TriFunction to three existing columns. The TriFunction takes the values of the three existing columns for each row and returns the value for the new column for that row.
*
* The new column is added at the end of the existing columns.
*
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnNames A Tuple3 containing the names of the three existing columns to be used as input for the TriFunction.
* @param func The TriFunction to generate the values for the new column. It takes the values of the three existing columns for each row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the new column name already exists in the DataSet or any of the existing column names does not exist in the DataSet.
*/
void addColumn(String newColumnName, Tuple3 fromColumnNames, TriFunction func)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new column to the DataSet at the specified position.
*
* The new column is generated by applying a TriFunction to three existing columns. The TriFunction takes the values of the three existing columns for each row and returns the value for the new column for that row.
*
* The new column is added at the position specified by newColumnPosition. Existing columns at and after this position are shifted to the right.
*
* @param newColumnPosition The position at which the new column should be added. It should be a valid index within the current column range.
* @param newColumnName The name of the new column to be added. It should not be a name that already exists in the DataSet.
* @param fromColumnNames A Tuple3 containing the names of the three existing columns to be used as input for the TriFunction.
* @param func The TriFunction to generate the values for the new column. It takes the values of the three existing columns for each row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified {@code newColumnPosition} is less than zero or bigger than column size or the new column name already exists in the DataSet, or if any of the existing column names does not exist in the DataSet.
*/
void addColumn(int newColumnPosition, String newColumnName, Tuple3 fromColumnNames, TriFunction func)
throws IllegalStateException, IllegalArgumentException;
/**
* Removes a column from the DataSet.
*
* The column is identified by its name. All data in the column is removed and returned as a List.
*
* The order of the values in the returned list reflects the order of the rows in the DataSet.
*
* @param The type of the values in the column.
* @param columnName The name of the column to be removed. It should be a name that exists in the DataSet.
* @return A List containing the values of the removed column.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
*/
List removeColumn(String columnName) throws IllegalStateException, IllegalArgumentException;
/**
* Removes multiple columns from the DataSet.
*
* The columns are identified by their names provided in the collection. All data in these columns are removed.
*
* @param columnNames A collection containing the names of the columns to be removed. These should be names that exist in the DataSet.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty.
*/
void removeColumns(Collection columnNames) throws IllegalStateException, IllegalArgumentException;
/**
* Removes multiple columns from the DataSet.
*
* The columns to be removed are identified by a Predicate function. The function is applied to each column name, and if it returns {@code true}, the column is removed.
*
* @param filter A Predicate function to determine which columns should be removed. It should return {@code true} for column names that should be removed, and {@code false} for those that should be kept.
* @throws IllegalStateException if the DataSet is frozen (read-only).
*/
void removeColumns(Predicate filter) throws IllegalStateException;
// /**
// * Remove the column(s) whose name matches the specified {@code filter}.
// *
// * @param filter column name filter
// * @deprecated replaced by {@code removeColumns}.
// */
// @Deprecated
// void removeColumnsIf(Predicate filter);
/**
* Updates the values in a specified column of the DataSet.
*
* The update is performed by applying a function to each value in the column. The function takes the current value and returns the new value.
*
* @param columnName The name of the column to be updated. It should be a name that exists in the DataSet.
* @param func The function to be applied to each value in the column. It takes the current value and returns the new value.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet.
*/
void updateColumn(String columnName, Function func) throws IllegalStateException, IllegalArgumentException;
/**
* Updates the values in multiple specified columns of the DataSet.
*
* The update is performed by applying a function to each value in the specified columns. The function takes the current value and returns the new value.
*
* @param columnNames A collection containing the names of the columns to be updated. These should be names that exist in the DataSet.
* @param func The function to be applied to each value in the columns. It takes the current value and returns the new value.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty.
*/
void updateColumns(Collection columnNames, Function func) throws IllegalStateException, IllegalArgumentException;
/**
* Converts the values in a specified column of the DataSet to a specified target type.
*
* @param columnName The name of the column to be converted. It should be a name that exists in the DataSet.
* @param targetType The Class object representing the target type to which the column values should be converted.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet or a value cannot be cast to the target type.
* @throws NumberFormatException if string value of the column cannot be parsed to the target(Number) type.
* @throws RuntimeException if any other error occurs during the conversion.
* @see N#convert(Object, Class)
*/
void convertColumn(String columnName, Class targetType) throws IllegalStateException, IllegalArgumentException, NumberFormatException, RuntimeException;
/**
* Converts the values in multiple specified columns of the DataSet to their respective target types.
*
* @param columnTargetTypes A map where the key is the column name and the value is the Class object representing the target type to which the column values should be converted. The column names should exist in the DataSet.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnTargetTypes} is empty or a value cannot be cast to the target type.
* @throws NumberFormatException if string value of the column cannot be parsed to the target(Number) type.
* @throws RuntimeException if any other error occurs during the conversion.
* @see N#convert(Object, Class)
*/
void convertColumns(Map> columnTargetTypes)
throws IllegalStateException, IllegalArgumentException, NumberFormatException, RuntimeException;
//
// /**
// * convert the specified columns to target types.
// *
// * @param targetColumnTypes fill the element with {@code null} if don't wan to convert the target column.
// */
// void convertColumn(Class[] targetColumnTypes);
/**
* Combines multiple columns into a new column in the DataSet.
*
* The new column is created by combining the values of the specified columns for each row. The type of the new column is specified by the newColumnType parameter.
*
* @param columnNames A collection containing the names of the columns to be combined. These should be names that exist in the DataSet.
* @param newColumnName The name of the new column to be created. It should not be a name that already exists in the DataSet.
* @param newColumnType The Class object representing the type of the new column.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the new column name already exists in the DataSet.
*/
void combineColumns(Collection columnNames, String newColumnName, Class newColumnType) throws IllegalStateException, IllegalArgumentException;
/**
* Combines multiple columns into a new column in the DataSet.
*
* The new column is created by applying a function to the values of the specified columns for each row. The function takes a DisposableObjArray of the values in the existing columns for a particular row and returns the value for the new column for that row.
*
* @param columnNames A collection containing the names of the columns to be combined. These should be names that exist in the DataSet.
* @param newColumnName The name of the new column to be created. It should not be a name that already exists in the DataSet.
* @param combineFunc The function to generate the values for the new column. It takes a DisposableObjArray of the values in the existing columns for a particular row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the new column name already exists in the DataSet.
*/
void combineColumns(Collection columnNames, String newColumnName, Function combineFunc)
throws IllegalStateException, IllegalArgumentException;
/**
* Combines two columns into a new column in the DataSet.
*
* The new column is created by applying a BiFunction to the values of the specified columns for each row.
* The BiFunction takes the values of the two existing columns for a particular row and returns the value for the new column for that row.
*
* @param columnNames A Tuple2 containing the names of the two columns to be combined. These should be names that exist in the DataSet.
* @param newColumnName The name of the new column to be created. It should not be a name that already exists in the DataSet.
* @param combineFunc The BiFunction to generate the values for the new column. It takes the values of the two existing columns for a particular row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or the new column name already exists in the DataSet.
*/
void combineColumns(Tuple2 columnNames, String newColumnName, BiFunction combineFunc)
throws IllegalStateException, IllegalArgumentException;
/**
* Combines three columns into a new column in the DataSet.
*
* The new column is created by applying a TriFunction to the values of the specified columns for each row.
* The TriFunction takes the values of the three existing columns for a particular row and returns the value for the new column for that row.
*
* @param columnNames A Tuple3 containing the names of the three columns to be combined. These should be names that exist in the DataSet.
* @param newColumnName The name of the new column to be created. It should not be a name that already exists in the DataSet.
* @param combineFunc The TriFunction to generate the values for the new column. It takes the values of the three existing columns for a particular row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet is empty or the new column name already exists in the DataSet.
*/
void combineColumns(Tuple3 columnNames, String newColumnName, TriFunction combineFunc)
throws IllegalStateException, IllegalArgumentException;
/**
* Combines multiple columns into a new column in the DataSet based on a column name filter.
*
* The new column is created by combining the values of the specified columns for each row. The type of the new column is specified by the newColumnType parameter.
*
* The columns to be combined are determined by the columnNameFilter. If the columnNameFilter returns {@code true} for a column name, that column is included in the combination.
*
* @param columnNameFilter A Predicate function to determine which columns should be combined. It should return {@code true} for column names that should be combined, and {@code false} for those that should be kept.
* @param newColumnName The name of the new column to be created. It should not be a name that already exists in the DataSet.
* @param newColumnType The Class object representing the type of the new column.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if none of column name matches the specified {@code columnNameFilter} or the new column name already exists in the DataSet.
*/
void combineColumns(Predicate columnNameFilter, String newColumnName, Class newColumnType)
throws IllegalStateException, IllegalArgumentException;
/**
* Combines multiple columns into a new column in the DataSet based on a column name filter.
*
* The new column is created by applying a function to the values of the specified columns for each row. The function takes a DisposableObjArray of the values in the existing columns for a particular row and returns the value for the new column for that row.
*
* The columns to be combined are determined by the columnNameFilter. If the columnNameFilter returns {@code true} for a column name, that column is included in the combination.
*
* @param columnNameFilter A Predicate function to determine which columns should be combined. It should return {@code true} for column names that should be combined, and {@code false} for those that should be kept.
* @param newColumnName The name of the new column to be created. It should not be a name that already exists in the DataSet.
* @param combineFunc The function to generate the values for the new column. It takes a DisposableObjArray of the values in the existing columns for a particular row and returns the value for the new column for that row.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if none of column name matches the specified {@code columnNameFilter} or the new column name already exists in the DataSet.
*/
void combineColumns(Predicate columnNameFilter, String newColumnName, Function combineFunc)
throws IllegalStateException, IllegalArgumentException;
/**
* Divides a column into multiple new columns in the DataSet.
*
* The division is performed by applying a function to each value in the specified column. The function takes the current value and returns a List of new values, each of which will be a value in one of the new columns.
*
* The new columns are added at the end of the existing columns.
*
* @param columnName The name of the column to be divided. It should be a name that exists in the DataSet.
* @param newColumnNames A collection containing the names of the new columns to be created. These should not be names that already exist in the DataSet. The size of this collection should match the size of the Lists returned by the divideFunc.
* @param divideFunc The function to be applied to each value in the column. It takes the current value and returns a List of new values. The size of this List should match the size of the newColumnNames collection.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet, any of the new column names already exist in the DataSet, or {@code newColumnNames} is empty, or the size of the Lists returned by the divideFunc does not match the size of the newColumnNames collection.
*/
void divideColumn(String columnName, Collection newColumnNames, Function> divideFunc)
throws IllegalStateException, IllegalArgumentException;
/**
* Divides a column into multiple new columns in the DataSet.
*
* The division is performed by applying a BiConsumer to each value in the specified column. The BiConsumer takes the current value and an Object array, and it should populate the array with the new values for the new columns.
*
* The new columns are added at the end of the existing columns.
*
* @param columnName The name of the column to be divided. It should be a name that exists in the DataSet.
* @param newColumnNames A collection containing the names of the new columns to be created. These should not be names that already exist in the DataSet. The size of this collection should match the size of the Object array populated by the output BiConsumer.
* @param output The BiConsumer to be applied to each value in the column. It takes the current value and an Object array, and it should populate the array with the new values for the new columns.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet, any of the new column names already exist in the DataSet, or {@code newColumnNames} is empty.
*/
void divideColumn(String columnName, Collection newColumnNames, BiConsumer output)
throws IllegalStateException, IllegalArgumentException;
/**
* Divides a column into two new columns in the DataSet.
*
* The division is performed by applying a BiConsumer to each value in the specified column. The BiConsumer takes the current value and a Pair object, and it should populate the Pair with the new values for the new columns.
*
* The new columns are added at the end of the existing columns.
*
* @param columnName The name of the column to be divided. It should be a name that exists in the DataSet.
* @param newColumnNames A Tuple2 containing the names of the two new columns to be created. These should not be names that already exist in the DataSet.
* @param output The BiConsumer to be applied to each value in the column. It takes the current value and a Pair object, and it should populate the Pair with the new values for the new columns.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet, any of the new column names already exist in the DataSet.
*/
void divideColumn(String columnName, Tuple2 newColumnNames, BiConsumer> output)
throws IllegalStateException, IllegalArgumentException;
/**
* Divides a column into three new columns in the DataSet.
*
* The division is performed by applying a BiConsumer to each value in the specified column. The BiConsumer takes the current value and a Triple object, and it should populate the Triple with the new values for the new columns.
*
* The new columns are added at the end of the existing columns.
*
* @param columnName The name of the column to be divided. It should be a name that exists in the DataSet.
* @param newColumnNames A Tuple3 containing the names of the three new columns to be created. These should not be names that already exist in the DataSet.
* @param output The BiConsumer to be applied to each value in the column. It takes the current value and a Triple object, and it should populate the Triple with the new values for the new columns.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified column name does not exist in the DataSet, any of the new column names already exist in the DataSet.
*/
void divideColumn(String columnName, Tuple3 newColumnNames, BiConsumer> output)
throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new row to the DataSet.
*
* The row can be represented in various formats such as an Object array, List, Map, or a Bean with getter/setter methods.
*
* @param row The new row to be added to the DataSet. It can be an Object array, List, Map, or a Bean with getter/setter methods.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the structure of the row does not match the required type - Object array, List, Map, or Bean.
*/
void addRow(Object row) throws IllegalStateException, IllegalArgumentException;
/**
* Adds a new row to the DataSet at the specified position.
*
* The row can be represented in various formats such as an Object array, List, Map, or a Bean with getter/setter methods.
* Existing rows at and after the new row position are shifted down.
*
* @param newRowPosition The position at which the new row should be added. It should be a valid index within the current row range.
* @param row The new row to be added to the DataSet. It can be an Object array, List, Map, or a Bean with getter/setter methods.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IllegalArgumentException if the specified {@code newRowPosition} is less than zero or bigger than row size, or the structure of the row does not match the required type - Object array, List, Map, or Bean.
*/
void addRow(int newRowPosition, Object row) throws IllegalStateException, IllegalArgumentException;
/**
* Removes a row from the DataSet.
*
* The row is identified by its index. All data in the row is removed.
*
* @param rowIndex The index of the row to be removed. It should be a valid index within the current row range.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
*/
void removeRow(int rowIndex) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Removes multiple rows from the DataSet.
*
* The rows are identified by their indices. All data in these rows are removed.
*
* @param indices The indices of the rows to be removed. Each index should be a valid index within the current row range.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if any of the specified indices is out of bounds.
*/
void removeRows(int... indices) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Removes a range of rows from the DataSet.
*
* The range is specified by an inclusive start index and an exclusive end index. All rows within this range are removed.
*
* @param inclusiveFromRowIndex The start index of the range. It should be a valid index within the current row range. The row at this index is included in the removal.
* @param exclusiveToRowIndex The end index of the range. It should be a valid index within the current row range. The row at this index is not included in the removal.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if the specified {@code inclusiveFromRowIndex} is less than zero, or the specified {@code exclusiveToRowIndex} is bigger than row size, or {@code inclusiveFromRowIndex} is bigger than {@code exclusiveToRowIndex}.
*/
void removeRowRange(int inclusiveFromRowIndex, int exclusiveToRowIndex) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Updates a specific row in the DataSet.
*
* The update is performed by applying a function to each value in the specified row. The function takes the current value and returns the new value.
*
* @param rowIndex The index of the row to be updated. It should be a valid index within the current row range.
* @param func The function to be applied to each value in the row. It takes the current value and returns the new value.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
*/
void updateRow(int rowIndex, Function func) throws IllegalStateException, IndexOutOfBoundsException;
/**
* Updates the values in the specified rows of the DataSet.
*
* The update is performed by applying a function to each value in the specified rows. The function takes the current value and returns the new value.
*
* @param indices An array of integers representing the indices of the rows to be updated. Each index should be a valid index within the current row range.
* @param func The function to be applied to each value in the rows. It takes the current value and returns the new value.
* @throws IllegalStateException if the DataSet is frozen (read-only).
* @throws IndexOutOfBoundsException if any of the specified indices is out of bounds.
*/
void updateRows(int[] indices, Function func) throws IllegalStateException, IndexOutOfBoundsException;
// TODO should the method name be "replaceAll"? If change the method name to replaceAll, what about updateColumn/updateRow?
/**
* Updates all the values in the DataSet.
*
* The update is performed by applying a function to each value in the DataSet. The function takes the current value and returns the new value.
*
* @param func The function to be applied to each value in the DataSet. It takes the current value and returns the new value.
* @throws IllegalStateException if the DataSet is frozen (read-only).
*/
void updateAll(Function func) throws IllegalStateException;
/**
* Replaces values in the DataSet that satisfy a specified condition with a new value.
*
* The predicate takes each value in the DataSet as input and returns a boolean indicating whether the value should be replaced.
*
* @param predicate The predicate to test each value in the sheet. It takes a value from the DataSet as input and returns a boolean indicating whether the value should be replaced.
* @param newValue The new value to replace the values that satisfy the condition.
* @throws IllegalStateException if the DataSet is frozen (read-only).
*/
void replaceIf(Predicate predicate, Object newValue) throws IllegalStateException;
/**
* Prepends the provided DataSet to the current DataSet.
*
* The operation is performed by adding all rows from the provided DataSet to the beginning of the current DataSet.
* The structure (columns and their types) of the provided DataSet should match the structure of the current DataSet.
*
* @param other The DataSet to be prepended to the current DataSet. It should have the same structure as the current DataSet.
* @throws IllegalStateException if the current DataSet is frozen (read-only).
* @throws IllegalArgumentException if this DataSet and the provided DataSet don't have the same column names.
* @see #merge(DataSet)
*/
void prepend(DataSet other) throws IllegalStateException, IllegalArgumentException;
/**
* Appends the provided DataSet to the current DataSet.
*
* The operation is performed by adding all rows from the provided DataSet to the end of the current DataSet.
* The structure (columns and their types) of the provided DataSet should match the structure of the current DataSet.
*
* @param other The DataSet to be appended to the current DataSet. It should have the same structure as the current DataSet.
* @throws IllegalStateException if the current DataSet is frozen (read-only).
* @throws IllegalArgumentException if this DataSet and the provided DataSet don't have the same column names.
* @see #merge(DataSet)
*/
void append(DataSet other) throws IllegalStateException, IllegalArgumentException;
/**
* Retrieves the current row number in the DataSet.
* This method is typically used when iterating over the rows in the DataSet.
*
* @return The current row number as an integer. The first row is number 0.
*/
int currentRowNum();
/**
* Moves the cursor to the row in this DataSet object specified by the given index.
* This method is typically used when navigating through the rows in the DataSet.
*
* @param rowIndex The index of the row to move to. The first row is 0, the second is 1, and so on.
* @return The DataSet object itself with the cursor moved to the specified row.
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
*/
DataSet absolute(int rowIndex);
/**
* Retrieves a row from the DataSet as an array of Objects.
*
* This method is typically used when accessing the data in a specific row.
*
* @param rowIndex The index of the row to retrieve. The first row is 0, the second is 1, and so on.
* @return An array of Objects representing the data in the specified row.
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
*/
Object[] getRow(int rowIndex) throws IndexOutOfBoundsException;
/**
* Retrieves a row from the DataSet and converts it to a specific type.
*
* This method is typically used when accessing the data in a specific row and converting it to a specific type.
*
* @param rowIndex The index of the row to retrieve. The first row is 0, the second is 1, and so on.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @param The type to which the row data should be converted.
* @return An instance of the specified type representing the data in the specified row.
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
T getRow(int rowIndex, Class rowType) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Retrieves a row from the DataSet as an instance of the specified type.
*
* This method is typically used when accessing the data in a specific row and converting it to a specific type.
* The type can be an array, List, Set, Map, or a Bean.
*
* @param The target type of the row.
* @param rowIndex The index of the row to retrieve. The first row is 0, the second is 1, and so on.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return An instance of the specified type representing the data in the specified row.
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
T getRow(int rowIndex, Collection columnNames, Class rowType) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Retrieves a row from the DataSet as an instance of the specified type.
*
* This method is typically used when accessing the data in a specific row and converting it to a specific type.
* The type is determined by the provided IntFunction. It must be Object[], Collection, Map, or Bean class.
*
* @param The target type of the row.
* @param rowIndex The index of the row to retrieve. The first row is 0, the second is 1, and so on.
* @param rowSupplier The IntFunction that generates an instance of the target type. It takes an integer as input, which is the number of columns in the row, and returns an instance of the target type.
* @return An instance of the specified type representing the data in the specified row.
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
T getRow(int rowIndex, IntFunction rowSupplier) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Retrieves a row from the DataSet as an instance of the specified type.
*
* This method is typically used when accessing the data in a specific row and converting it to a specific type.
* The type is determined by the provided IntFunction. It must be Object[], Collection, Map, or Bean class.
* Only the columns specified in the {@code columnNames} collection will be included in the returned row.
*
* @param The target type of the row.
* @param rowIndex The index of the row to retrieve. The first row is 0, the second is 1, and so on.
* @param columnNames The collection of column names to be included in the returned row.
* @param rowSupplier The IntFunction that generates an instance of the target type. It takes an integer as input, which is the number of columns in the row, and returns an instance of the target type.
* @return An instance of the specified type representing the data in the specified row.
* @throws IndexOutOfBoundsException if the specified {@code rowIndex} is out of bounds.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class, or if any of the specified {@code columnNames} does not exist in the DataSet.
*/
T getRow(int rowIndex, Collection columnNames, IntFunction rowSupplier) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Retrieves the first row from the DataSet as an Optional array of Objects.
*
* This method is typically used when you need to access the first row of data in the DataSet.
* If the DataSet is empty, the returned Optional will be empty.
*
* @return An Optional array of Objects representing the data in the first row. If the DataSet is empty, the Optional will be empty.
*/
Optional firstRow();
/**
* Retrieves the first row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the first row of data in the DataSet and convert it to a specific type.
* The type can be an Object[], Collection, Map, or a Bean class.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return An Optional instance of the specified type representing the data in the first row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional firstRow(Class rowType) throws IllegalArgumentException;
/**
* Retrieves the first row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the first row of data in the DataSet and convert it to a specific type.
* The type is determined by the provided Class object. It can be an Object[], Collection, Map, or a Bean class.
* Only the columns specified in the {@code columnNames} collection will be included in the returned row.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the returned row.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return An Optional instance of the specified type representing the data in the first row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional firstRow(Collection columnNames, Class rowType) throws IllegalArgumentException;
/**
* Retrieves the first row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the first row of data in the DataSet and convert it to a specific type.
* The type is determined by the provided IntFunction. It can be an Object[], Collection, Map, or a Bean class.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param rowSupplier The IntFunction that generates an instance of the target type. It takes an integer as input, which is the number of columns in the row, and returns an instance of the target type.
* @return An Optional instance of the specified type representing the data in the first row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional firstRow(IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Retrieves the first row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the first row of data in the DataSet and convert it to a specific type.
* The type is determined by the provided IntFunction. It can be an Object[], Collection, Map, or a Bean class.
* Only the columns specified in the {@code columnNames} collection will be included in the returned row.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the returned row.
* @param rowSupplier The IntFunction that generates an instance of the target type. It takes an integer as input, which is the number of columns in the row, and returns an instance of the target type.
* @return An Optional instance of the specified type representing the data in the first row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional firstRow(Collection columnNames, IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Retrieves the last row from the DataSet as an Optional array of Objects.
*
* This method is typically used when you need to access the last row of data in the DataSet.
* If the DataSet is empty, the returned Optional will be empty.
*
* @return An Optional array of Objects representing the data in the last row. If the DataSet is empty, the Optional will be empty.
*/
Optional lastRow();
/**
* Retrieves the last row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the last row of data in the DataSet and convert it to a specific type.
* The type can be an Object[], Collection, Map, or a Bean class.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return An Optional instance of the specified type representing the data in the last row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional lastRow(Class rowType) throws IllegalArgumentException;
/**
* Retrieves the last row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the last row of data in the DataSet and convert it to a specific type.
* The type can be an Object[], Collection, Map, or a Bean class.
* Only the columns specified in the {@code columnNames} collection will be included in the returned row.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the returned row.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return An Optional instance of the specified type representing the data in the last row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional lastRow(Collection columnNames, Class rowType) throws IllegalArgumentException;
/**
* Retrieves the last row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the last row of data in the DataSet and convert it to a specific type.
* The type is determined by the provided IntFunction. It can be an Object[], Collection, Map, or a Bean class.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param rowSupplier The IntFunction that generates an instance of the target type. It takes an integer as input, which is the number of columns in the row, and returns an instance of the target type.
* @return An Optional instance of the specified type representing the data in the last row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional lastRow(IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Retrieves the last row from the DataSet as an instance of the specified type wrapped in an Optional.
*
* This method is typically used when you need to access the last row of data in the DataSet and convert it to a specific type.
* The type is determined by the provided IntFunction. It can be an Object[], Collection, Map, or a Bean class.
* Only the columns specified in the {@code columnNames} collection will be included in the returned row.
* If the DataSet is empty, the returned Optional will be empty.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the returned row.
* @param rowSupplier The IntFunction that generates an instance of the target type. It takes an integer as input, which is the number of columns in the row, and returns an instance of the target type.
* @return An Optional instance of the specified type representing the data in the last row. If the DataSet is empty, the Optional will be empty.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty or the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Optional lastRow(Collection columnNames, IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Performs the given action for each row of the DataSet until all rows.
*
* This method is typically used when you need to perform an operation on each row in the DataSet.
* The action is a Consumer function that takes a DisposableObjArray as input, which represents a row in the DataSet.
* The action is applied to each row in the DataSet in the order they appear.
*
* @param The type of the exception that the action can throw.
* @param action The action to be performed on each row. It takes a DisposableObjArray as input, which represents a row in the DataSet. The action should not cache or update the input DisposableObjArray or its values(Array).
* @throws E if the action throws an exception.
*/
void forEach(Throwables.Consumer action) throws E;
/**
* Performs the given action for each row of the DataSet until all rows.
*
* This method is typically used when you need to perform an operation on each row in the DataSet.
* The action is a Consumer function that takes a DisposableObjArray as input, which represents a row in the DataSet.
* The action is applied to each row in the DataSet in the order they appear.
* Only the columns specified in the {@code columnNames} collection will be included in the DisposableObjArray.
*
* @param The type of the exception that the action can throw.
* @param columnNames The collection of column names to be included in the DisposableObjArray.
* @param action The action to be performed on each row. It takes a DisposableObjArray as input, which represents a row in the DataSet. The action should not cache or update the input DisposableObjArray or its values(Array).
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty.
* @throws E if the action throws an exception.
*/
void forEach(Collection columnNames, Throwables.Consumer action)
throws IllegalArgumentException, E;
/**
* Performs the given action for each row of the DataSet within the specified range until all rows.
*
* This method is typically used when you need to perform an operation on a specific range of rows in the DataSet.
* The action is a Consumer function that takes a DisposableObjArray as input, which represents a row in the DataSet.
* The action is applied to each row in the DataSet in the order they appear, starting from the row at the index specified by {@code fromRowIndex} and ending at the row before the index specified by {@code toRowIndex}.
*
* @param The type of the exception that the action can throw.
* @param fromRowIndex The starting index of the range of rows to be processed. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be processed. This index is exclusive, meaning the row at this index will not be processed.
* @param action The action to be performed on each row. It takes a DisposableObjArray as input, which represents a row in the DataSet. The action should not cache or update the input DisposableObjArray or its values(Array).
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws E if the action throws an exception.
*/
void forEach(int fromRowIndex, int toRowIndex, Throwables.Consumer action)
throws IndexOutOfBoundsException, E;
/**
* Performs the given action for each row of the DataSet within the specified range.
*
* This method is typically used when you need to perform an operation on a specific range of rows in the DataSet.
* The action is a Consumer function that takes a DisposableObjArray as input, which represents a row in the DataSet.
* The action is applied to each row in the DataSet in the order they appear, starting from the row at the index specified by {@code fromRowIndex} and ending at the row before the index specified by {@code toRowIndex}.
* Only the columns specified in the {@code columnNames} collection will be included in the DisposableObjArray.
*
* @param The type of the exception that the action can throw.
* @param fromRowIndex The starting index of the range of rows to be processed. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be processed. This index is exclusive, meaning the row at this index will not be processed.
* @param columnNames The collection of column names to be included in the DisposableObjArray.
* @param action The action to be performed on each row. It takes a DisposableObjArray as input, which represents a row in the DataSet. The action should not cache or update the input DisposableObjArray or its values(Array).
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty.
* @throws E if the action throws an exception.
*/
void forEach(int fromRowIndex, int toRowIndex, Collection columnNames,
Throwables.Consumer action) throws IndexOutOfBoundsException, IllegalArgumentException, E;
/**
* Performs the given action for each row of the DataSet.
*
* This method is typically used when you need to perform an operation on each row in the DataSet.
* The action is a BiConsumer function that takes two inputs, which represent the values of the two columns specified in the Tuple {@code columnNames}.
* The action is applied to each row in the DataSet in the order they appear.
* Only the columns specified in the Tuple {@code columnNames} will be included in the action.
*
* @param The type of the exception that the action can throw.
* @param columnNames A Tuple2 representing the names of the two columns to be included in the action.
* @param action The action to be performed on each row. It takes two inputs, which represent the values of the two columns specified in the Tuple {@code columnNames}. The action should not cache or update the input values.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet.
* @throws E if the action throws an exception.
*/
void forEach(Tuple2 columnNames, Throwables.BiConsumer action) throws IllegalArgumentException, E;
/**
* Performs the given action for each row of the DataSet within the specified range.
*
* This method is typically used when you need to perform an operation on a specific range of rows in the DataSet.
* The action is a BiConsumer function that takes two inputs, which represent the values of the two columns specified in the Tuple {@code columnNames}.
* The action is applied to each row in the DataSet in the order they appear, starting from the row at the index specified by {@code fromRowIndex} and ending at the row before the index specified by {@code toRowIndex}.
* Only the columns specified in the Tuple {@code columnNames} will be included in the action.
*
* @param The type of the exception that the action can throw.
* @param fromRowIndex The starting index of the range of rows to be processed. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be processed. This index is exclusive, meaning the row at this index will not be processed.
* @param columnNames A Tuple2 representing the names of the two columns to be included in the action.
* @param action The action to be performed on each row. It takes two inputs, which represent the values of the two columns specified in the Tuple {@code columnNames}. The action should not cache or update the input values.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet.
* @throws E if the action throws an exception.
*/
void forEach(int fromRowIndex, int toRowIndex, Tuple2 columnNames, Throwables.BiConsumer action)
throws IndexOutOfBoundsException, IllegalArgumentException, E;
/**
* Performs the given action for each row of the DataSet.
*
* This method is typically used when you need to perform an operation on each row in the DataSet.
* The action is a TriConsumer function that takes three inputs, which represent the values of the three columns specified in the Tuple {@code columnNames}.
* The action is applied to each row in the DataSet in the order they appear.
* Only the columns specified in the Tuple {@code columnNames} will be included in the action.
*
* @param The type of the exception that the action can throw.
* @param columnNames A Tuple3 representing the names of the three columns to be included in the action.
* @param action The action to be performed on each row. It takes three inputs, which represent the values of the three columns specified in the Tuple {@code columnNames}. The action should not cache or update the input values.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet.
* @throws E if the action throws an exception.
*/
void forEach(Tuple3 columnNames, Throwables.TriConsumer action)
throws IllegalArgumentException, E;
/**
* Performs the given action for each row of the DataSet within the specified range.
*
* This method is typically used when you need to perform an operation on a specific range of rows in the DataSet.
* The action is a TriConsumer function that takes three inputs, which represent the values of the three columns specified in the Tuple {@code columnNames}.
* The action is applied to each row in the DataSet in the order they appear, starting from the row at the index specified by {@code fromRowIndex} and ending at the row before the index specified by {@code toRowIndex}.
* Only the columns specified in the Tuple {@code columnNames} will be included in the action.
*
* @param The type of the exception that the action can throw.
* @param fromRowIndex The starting index of the range of rows to be processed. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be processed. This index is exclusive, meaning the row at this index will not be processed.
* @param columnNames A Tuple3 representing the names of the three columns to be included in the action.
* @param action The action to be performed on each row. It takes three inputs, which represent the values of the three columns specified in the Tuple {@code columnNames}. The action should not cache or update the input values.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet.
* @throws E if the action throws an exception.
*/
void forEach(int fromRowIndex, int toRowIndex, Tuple3 columnNames, Throwables.TriConsumer action)
throws IndexOutOfBoundsException, IllegalArgumentException, E;
/**
* Converts the entire DataSet into a list of Object arrays.
*
* This method is typically used when you need to export the data in the DataSet to a different format or system.
* Each row in the DataSet is converted into an Object array, where each element in the array corresponds to a column in the row.
* The order of the elements in the array matches the order of the columns in the DataSet.
* The resulting list of Object arrays is in the same order as the rows in the DataSet.
*
* @return A List of Object arrays representing the data in the DataSet. Each Object array is a row in the DataSet.
*/
List toList();
/**
* Converts a specified range of the DataSet into a list of Object arrays.
*
* This method is typically used when you need to export a specific range of data in the DataSet to a different format or system.
* Each row in the specified range of the DataSet is converted into an Object array, where each element in the array corresponds to a column in the row.
* The order of the elements in the array matches the order of the columns in the DataSet.
* The resulting list of Object arrays is in the same order as the rows in the DataSet.
*
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @return A List of Object arrays representing the data in the specified range of the DataSet. Each Object array is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
*/
List toList(int fromRowIndex, int toRowIndex) throws IndexOutOfBoundsException;
/**
* Converts the entire DataSet into a list of instances of the specified type.
*
* This method is typically used when you need to export the data in the DataSet to a specific type of objects.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(Class rowType) throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type.
*
* This method is typically used when you need to export a specific range of data in the DataSet to a specific type of objects.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(int fromRowIndex, int toRowIndex, Class rowType) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type, including only the specified columns.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns specified in the {@code columnNames} collection will be included in the instance.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the instance.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty, or the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(Collection columnNames, Class rowType) throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type, including only the specified columns.
*
* This method is typically used when you need to export a specific range of data and specific columns of data in the DataSet to a specific type of objects.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns specified in the {@code columnNames} collection will be included in the instance.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param columnNames The collection of column names to be included in the instance.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty, or the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(int fromRowIndex, int toRowIndex, Collection columnNames, Class rowType)
throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export the data in the DataSet to a specific type of objects.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param rowSupplier The function to create a new instance of the target type. It takes an integer as input, which represents the number of columns in the DataSet.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export a specific range of data in the DataSet to a specific type of objects.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param rowSupplier The function to create a new instance of the target type. It takes an integer as input, which represents the number of columns in the DataSet.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(int fromRowIndex, int toRowIndex, IntFunction rowSupplier) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class, including only the specified columns.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns specified in the {@code columnNames} collection will be included in the instance.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the instance.
* @param rowSupplier The function to create a new instance of the target type. It takes an integer as input, which represents the number of columns in the DataSet.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty, or the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(Collection columnNames, IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class, including only the specified columns.
*
* This method is typically used when you need to export a specific range of data and specific columns of data in the DataSet to a specific type of objects.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns specified in the {@code columnNames} collection will be included in the instance.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param columnNames The collection of column names to be included in the instance.
* @param rowSupplier The function to create a new instance of the target type. It takes an integer as input, which represents the number of columns in the DataSet.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty, or the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(int fromRowIndex, int toRowIndex, Collection columnNames, IntFunction rowSupplier)
throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class, including only the columns that pass the specified filter.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns that pass the {@code columnNameFilter} will be included in the instance.
* The names of the properties in the instance are determined by the {@code columnNameConverter}.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param columnNameFilter The predicate to filter the column names. Only the columns that pass this filter will be included in the instance.
* @param columnNameConverter The function to convert the column names into property names in the instance.
* @param rowType The Class object representing the target type of the row. It must be Object[], Collection, Map, or Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(Predicate columnNameFilter, Function columnNameConverter, Class rowType)
throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class, including only the columns that pass the specified filter.
*
* This method is typically used when you need to export a specific range of data and specific columns of data in the DataSet to a specific type of objects.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns that pass the {@code columnNameFilter} will be included in the instance.
* The names of the properties in the instance are determined by the {@code columnNameConverter}.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param columnNameFilter The predicate to filter the column names. Only the columns that pass this filter will be included in the instance.
* @param columnNameConverter The function to convert the column names into property names in the instance.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(int fromRowIndex, int toRowIndex, Predicate columnNameFilter, Function columnNameConverter,
Class rowType) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class, including only the columns that pass the specified filter.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns that pass the {@code columnNameFilter} will be included in the instance.
* The names of the properties in the instance are determined by the {@code columnNameConverter}.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param columnNameFilter The predicate to filter the column names. Only the columns that pass this filter will be included in the instance.
* @param columnNameConverter The function to convert the column names into property names in the instance.
* @param rowSupplier The function to create a new instance of the target type. It takes an integer as input, which represents the number of columns in the DataSet.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(Predicate columnNameFilter, Function columnNameConverter, IntFunction rowSupplier);
/**
* Converts a specified range of the DataSet into a list of instances of the specified type - Object[], Collection, Map, or Bean class, including only the columns that pass the specified filter.
*
* This method is typically used when you need to export a specific range of data and specific columns of data in the DataSet to a specific type of objects.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns that pass the {@code columnNameFilter} will be included in the instance.
* The names of the properties in the instance are determined by the {@code columnNameConverter}.
* The order of the properties in the instance matches the order of the columns in the DataSet.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param columnNameFilter The predicate to filter the column names. Only the columns that pass this filter will be included in the instance.
* @param columnNameConverter The function to convert the column names into property names in the instance.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
List toList(int fromRowIndex, int toRowIndex, Predicate columnNameFilter, Function columnNameConverter,
IntFunction rowSupplier) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, mapping column names to field names based on the provided map.
*
* This method is typically used when you need to export data in the DataSet to a specific type of objects (entities), and the column names in the DataSet do not directly match the field names in the entity class.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The mapping between column names and field names is determined by the {@code prefixAndFieldNameMap}.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param prefixAndFieldNameMap The map that defines the mapping between column names and field names. The key is the column name prefix, and the value is the corresponding field name.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if the mapping defined by {@code prefixAndFieldNameMap} is invalid, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toEntities(Map prefixAndFieldNameMap, Class beanClass) throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type - Bean class, mapping column names to field names based on the provided map.
*
* This method is typically used when you need to export a specific range of data in the DataSet to a specific type of objects (entities), and the column names in the DataSet do not directly match the field names in the entity class.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The mapping between column names and field names is determined by the {@code prefixAndFieldNameMap}.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param prefixAndFieldNameMap The map that defines the mapping between column names and field names. The key is the column name prefix, and the value is the corresponding field name.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the mapping defined by {@code prefixAndFieldNameMap} is invalid, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toEntities(int fromRowIndex, int toRowIndex, Map prefixAndFieldNameMap, Class beanClass)
throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, mapping column names to field names based on the provided map.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects (entities), and the column names in the DataSet do not directly match the field names in the entity class.
* Each row in the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* The mapping between column names and field names is determined by the {@code prefixAndFieldNameMap}.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param columnNames The collection of column names to be included in the instance.
* @param prefixAndFieldNameMap The map that defines the mapping between column names and field names. The key is the column name prefix, and the value is the corresponding field name.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a row in the DataSet.
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty, or if the mapping defined by {@code prefixAndFieldNameMap} is invalid, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toEntities(Collection columnNames, Map prefixAndFieldNameMap, Class beanClass)
throws IllegalArgumentException;
/**
* Converts a specified range of the DataSet into a list of instances of the specified type - Bean class, including only the specified columns, mapping column names to field names based on the provided map.
*
* This method is typically used when you need to export a specific range of data and specific columns of data in the DataSet to a specific type of objects (entities), and the column names in the DataSet do not directly match the field names in the entity class.
* Each row in the specified range of the DataSet is converted into an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Only the columns specified in the {@code columnNames} collection will be included in the instance.
* The mapping between column names and field names is determined by the {@code prefixAndFieldNameMap}.
* The resulting list of instances is in the same order as the rows in the DataSet.
*
* @param The target type of the row.
* @param fromRowIndex The starting index of the range of rows to be converted. The first row is 0, the second is 1, and so on.
* @param toRowIndex The ending index of the range of rows to be converted. This index is exclusive, meaning the row at this index will not be converted.
* @param columnNames The collection of column names to be included in the instance.
* @param prefixAndFieldNameMap The map that defines the mapping between column names and field names. The key is the column name prefix, and the value is the corresponding field name.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the specified range of the DataSet. Each instance is a row in the DataSet.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if any of the specified column names does not exist in the DataSet or {@code columnNames} is empty, or if the mapping defined by {@code prefixAndFieldNameMap} is invalid, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toEntities(int fromRowIndex, int toRowIndex, Collection columnNames, Map prefixAndFieldNameMap,
Class beanClass) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, merging rows with the same ID into a single instance.
*
* This method is typically used when you need to export data in the DataSet to a specific type of objects (entities), and the rows in the DataSet have duplicate IDs.
* Each unique ID in the DataSet corresponds to an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Rows with the same ID are merged into a single instance, with the properties of the instance being the union of the properties of the rows.
* The resulting list of instances is in the same order as the unique IDs in the DataSet.
*
* @param The target type of the row.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a merged entity in the DataSet.
* @throws IllegalArgumentException if the specified {@code beanClass} is not a supported type - Bean class or no id defined in {@code beanClass}.
*/
List toMergedEntities(Class beanClass) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, merging rows with the same ID into a single instance.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects (entities), and the rows in the DataSet have duplicate IDs.
* Each unique ID in the DataSet corresponds to an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Rows with the same ID are merged into a single instance, with the properties of the instance being the union of the properties of the rows.
* The resulting list of instances is in the same order as the unique IDs in the DataSet.
*
* @param The target type of the row.
* @param selectPropNames The collection of property names to be included in the instance.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a merged entity in the DataSet.
* @throws IllegalArgumentException if any of the specified property names does not exist in the DataSet or {@code selectPropNames} is empty, or if the specified {@code beanClass} is not a supported type - Bean class or no id defined in {@code beanClass}.
*/
List toMergedEntities(Collection selectPropNames, Class beanClass) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, merging rows with the same ID into a single instance.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects (entities), and the rows in the DataSet have duplicate IDs.
* Each unique ID in the DataSet corresponds to an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Rows with the same ID are merged into a single instance, with the properties of the instance being the union of the properties of the rows.
* The resulting list of instances is in the same order as the unique IDs in the DataSet.
*
* @param The target type of the row.
* @param idPropName The property name that is used as the ID for merging rows. Rows with the same ID will be merged into a single instance.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a merged entity in the DataSet.
* @throws IllegalArgumentException if the specified {@code idPropName} does not exist in the DataSet or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toMergedEntities(String idPropName, Class beanClass) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, merging rows with the same ID into a single instance.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects (entities), and the rows in the DataSet have duplicate IDs.
* Each unique ID in the DataSet corresponds to an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Rows with the same ID are merged into a single instance, with the properties of the instance being the union of the properties of the rows.
* The resulting list of instances is in the same order as the unique IDs in the DataSet.
*
* @param The target type of the row.
* @param idPropName The property name that is used as the ID for merging rows. Rows with the same ID will be merged into a single instance.
* @param selectPropNames The collection of property names to be included in the instance.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a merged entity in the DataSet.
* @throws IllegalArgumentException if the specified {@code idPropName} does not exist in the DataSet or {@code idPropNames} is empty, or if any of the specified property names does not exist in the DataSet or {@code selectPropNames} is empty, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toMergedEntities(String idPropName, Collection selectPropNames, Class beanClass) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, merging rows with the same IDs into a single instance.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects (entities), and the rows in the DataSet have duplicate IDs.
* Each unique ID in the DataSet corresponds to an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Rows with the same IDs are merged into a single instance, with the properties of the instance being the union of the properties of the rows.
* The resulting list of instances is in the same order as the unique IDs in the DataSet.
*
* @param The target type of the row.
* @param idPropNames The collection of property names that are used as the IDs for merging rows. Rows with the same IDs will be merged into a single instance.
* @param selectPropNames The collection of property names to be included in the instance.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a merged entity in the DataSet.
* @throws IllegalArgumentException if any of the specified ID property names does not exist in the DataSet or {@code idPropNames} is empty, or if any of the specified property names does not exist in the DataSet or {@code selectPropNames} is empty, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toMergedEntities(Collection idPropNames, Collection selectPropNames, Class beanClass)
throws IllegalArgumentException;
/**
* Converts the entire DataSet into a list of instances of the specified type - Bean class, merging rows with the same IDs into a single instance.
*
* This method is typically used when you need to export specific columns of data in the DataSet to a specific type of objects (entities), and the rows in the DataSet have duplicate IDs.
* Each unique ID in the DataSet corresponds to an instance of the specified type, where each property in the instance corresponds to a column in the row.
* Rows with the same IDs are merged into a single instance, with the properties of the instance being the union of the properties of the rows.
* The resulting list of instances is in the same order as the unique IDs in the DataSet.
*
* @param The target type of the row.
* @param idPropNames The collection of property names that are used as the IDs for merging rows. Rows with the same IDs will be merged into a single instance.
* @param selectPropNames The collection of property names to be included in the instance.
* @param prefixAndFieldNameMap The map that defines the mapping between column names and field names. The key is the column name prefix, and the value is the corresponding field name.
* @param beanClass The Class object representing the target type of the row. It must be a Bean class.
* @return A List of instances of the specified type representing the data in the DataSet. Each instance is a merged entity in the DataSet.
* @throws IllegalArgumentException if any of the specified ID property names does not exist in the DataSet or {@code idPropNames} is empty, or if any of the specified property names does not exist in the DataSet or {@code selectPropNames} is empty, or if the mapping defined by {@code prefixAndFieldNameMap} is invalid, or if the specified {@code beanClass} is not a supported type - Bean class.
*/
List toMergedEntities(Collection idPropNames, Collection selectPropNames, Map prefixAndFieldNameMap,
Class beanClass) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the value of each entry is the value of the specified value column in the row.
*
* This method is typically used when you need to export data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnName The name of the column in the DataSet that will be used as the values in the resulting map.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is the value of the specified value column in the row.
* @throws IllegalArgumentException if the specified {@code keyColumnName} or {@code valueColumnName} does not exist in the DataSet.
*/
Map toMap(String keyColumnName, String valueColumnName) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the value of each entry is the value of the specified value column in the row.
*
* This method is typically used when you need to export data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
* The map is created by a provided supplier function, which allows the user to control the type of the map.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param The type of the map to be returned.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnName The name of the column in the DataSet that will be used as the values in the resulting map.
* @param supplier A function that generates a new map. The function takes an integer argument, which is the initial map capacity.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is the value of the specified value column in the row.
* @throws IllegalArgumentException if the specified {@code keyColumnName} or {@code valueColumnName} does not exist in the DataSet.
*/
> M toMap(String keyColumnName, String valueColumnName, IntFunction supplier) throws IllegalArgumentException;
/**
* Converts a range of rows in the DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the value of each entry is the value of the specified value column in the row.
*
* This method is typically used when you need to export a range of data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param fromRowIndex The starting index of the row range to be included in the map.
* @param toRowIndex The ending index of the row range to be included in the map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnName The name of the column in the DataSet that will be used as the values in the resulting map.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is the value of the specified value column in the row.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the specified {@code keyColumnName} or {@code valueColumnName} does not exist in the DataSet.
*/
Map toMap(int fromRowIndex, int toRowIndex, String keyColumnName, String valueColumnName)
throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts a range of rows in the DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the value of each entry is the value of the specified value column in the row.
*
* This method is typically used when you need to export a range of data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
* The map is created by a provided supplier function, which allows the user to control the type of the map.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param The type of the map to be returned.
* @param fromRowIndex The starting index of the row range to be included in the map.
* @param toRowIndex The ending index of the row range to be included in the map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnName The name of the column in the DataSet that will be used as the values in the resulting map.
* @param supplier A function that generates a new map. The function takes an integer argument, which is the initial map capacity.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is the value of the specified value column in the row.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the specified {@code keyColumnName} or {@code valueColumnName} does not exist in the DataSet.
*/
> M toMap(int fromRowIndex, int toRowIndex, String keyColumnName, String valueColumnName, IntFunction supplier)
throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the values of each entry are the values of the specified value columns in the row, represented as an instance of the specified row type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnNames The collection of names of the columns in the DataSet that will be used as the values in the resulting map. Each value in the map is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @param rowType The Class object representing the type of the values in the resulting map. It must be Object[], Collection, Map, or Bean class.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @throws IllegalArgumentException if the specified {@code keyColumnName} does not exist in the DataSet, or if any of the specified value column names does not exist in the DataSet or {@code valueColumnNames} is empty, or if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Map toMap(String keyColumnName, Collection valueColumnNames, Class rowType) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the values of each entry are the values of the specified value columns in the row, represented as an instance of the specified row type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
* The map is created by a provided supplier function, which allows the user to control the type of the map.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param The type of the map to be returned.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnNames The collection of names of the columns in the DataSet that will be used as the values in the resulting map. Each value in the map is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @param rowType The Class object representing the type of the values in the resulting map. It must be Object[], Collection, Map, or Bean class.
* @param supplier A function that generates a new map. The function takes an integer argument, which is the initial map capacity.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @throws IllegalArgumentException if the specified {@code keyColumnName} does not exist in the DataSet, or if any of the specified value column names does not exist in the DataSet or {@code valueColumnNames} is empty, or if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
> M toMap(String keyColumnName, Collection valueColumnNames, Class rowType,
IntFunction supplier) throws IllegalArgumentException;
/**
* Converts a range of rows in the DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the values of each entry are the values of the specified value columns in the row, represented as an instance of the specified row type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export a range of data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param fromRowIndex The starting index of the row range to be included in the map.
* @param toRowIndex The ending index of the row range to be included in the map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnNames The collection of names of the columns in the DataSet that will be used as the values in the resulting map. Each value in the map is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @param rowType The Class object representing the type of the values in the resulting map. It must be Object[], Collection, Map, or Bean class.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the specified {@code keyColumnName} does not exist in the DataSet, or if any of the specified value column names does not exist in the DataSet or {@code valueColumnNames} is empty, or if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Map toMap(int fromRowIndex, int toRowIndex, String keyColumnName, Collection valueColumnNames, Class rowType)
throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts a range of rows in the DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the values of each entry are the values of the specified value columns in the row, represented as an instance of the specified row type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export a range of data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
* The map is created by a provided supplier function, which allows the user to control the type of the map.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param The type of the map to be returned.
* @param fromRowIndex The starting index of the row range to be included in the map.
* @param toRowIndex The ending index of the row range to be included in the map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnNames The collection of names of the columns in the DataSet that will be used as the values in the resulting map. Each value in the map is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @param rowType The Class object representing the type of the values in the resulting map. It must be Object[], Collection, Map, or Bean class.
* @param supplier A function that generates a new map. The function takes an integer argument, which is the initial map capacity.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @throws IndexOutOfBoundsException if the specified {@code fromRowIndex} or {@code toRowIndex} is out of the range of the DataSet
* @throws IllegalArgumentException if the specified {@code keyColumnName} does not exist in the DataSet, or if any of the specified value column names does not exist in the DataSet or {@code valueColumnNames} is empty, or if the specified {@code rowType} is not a supported type - Object[], Collection, Map, or Bean class.
*/
> M toMap(int fromRowIndex, int toRowIndex, String keyColumnName, Collection valueColumnNames, Class rowType,
IntFunction supplier) throws IndexOutOfBoundsException, IllegalArgumentException;
/**
* Converts the entire DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the values of each entry are the values of the specified value columns in the row, represented as an instance of the specified row type - Object[], Collection, Map, or Bean class.
*
* This method is typically used when you need to export data in the DataSet to a Map, where each key-value pair in the map corresponds to a row in the DataSet.
* The resulting map does not preserve the order of the rows in the DataSet.
*
* @param The type of the keys in the resulting map.
* @param The type of the values in the resulting map.
* @param keyColumnName The name of the column in the DataSet that will be used as the keys in the resulting map.
* @param valueColumnNames The collection of names of the columns in the DataSet that will be used as the values in the resulting map. Each value in the map is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @param rowSupplier A function that generates a new row. The function takes an integer argument, which is the initial row capacity.
* @return A Map where each key-value pair corresponds to a row in the DataSet. The key of each pair is the value of the specified key column in the row, and the value of each pair is an instance of the specified row type, where each property in the instance corresponds to a column in the row.
* @throws IllegalArgumentException if the specified {@code keyColumnName} does not exist in the DataSet, or if any of the specified value column names does not exist in the DataSet or {@code valueColumnNames} is empty, or the return value created by specified {@code rowSupplier} is not a supported type - Object[], Collection, Map, or Bean class.
*/
Map toMap(String keyColumnName, Collection valueColumnNames, IntFunction rowSupplier) throws IllegalArgumentException;
/**
* Converts the entire DataSet into a Map, where each entry in the map corresponds to a row in the DataSet.
* The key of each entry is the value of the specified key column in the row, and the values of each entry are the values of the specified value columns in the row, represented as an instance of the specified row type - Object[], Collection, Map, or Bean class.
*