com.vaadin.data.provider.Query Maven / Gradle / Ivy
/*
* Copyright (C) 2000-2024 Vaadin Ltd
*
* This program is available under Vaadin Commercial License and Service Terms.
*
* See for the full
* license.
*/
package com.vaadin.data.provider;
import java.io.Serializable;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
/**
* Immutable query object used to request data from a backend. Contains index
* limits, sorting and filtering information.
*
* @param
* bean type
* @param
* filter type
*
* @since 8.0
*/
public class Query implements Serializable {
private final int offset;
private final int limit;
private final List sortOrders;
private final Comparator inMemorySorting;
private final F filter;
/**
* Constructs a Query for all rows from 0 to {@link Integer#MAX_VALUE}
* without sorting and filtering.
*/
public Query() {
offset = 0;
limit = Integer.MAX_VALUE;
sortOrders = Collections.emptyList();
inMemorySorting = null;
filter = null;
}
/**
* Constructs a Query for all rows from 0 to {@link Integer#MAX_VALUE} with
* filtering.
*
* @param filter
* back end filter of a suitable type for the data provider; can
* be null
*/
public Query(F filter) {
offset = 0;
limit = Integer.MAX_VALUE;
sortOrders = Collections.emptyList();
inMemorySorting = null;
this.filter = filter;
}
/**
* Constructs a new Query object with given offset, limit, sorting and
* filtering.
*
* @param offset
* first index to fetch
* @param limit
* fetched item count
* @param sortOrders
* sorting order for fetching; used for sorting backends
* @param inMemorySorting
* comparator for sorting in-memory data
* @param filter
* filtering for fetching; can be null
*/
public Query(int offset, int limit, List sortOrders,
Comparator inMemorySorting, F filter) {
this.offset = offset;
this.limit = limit;
this.sortOrders = sortOrders;
this.inMemorySorting = inMemorySorting;
this.filter = filter;
}
/**
* Gets the first index of items to fetch. The offset is only used when
* fetching items, but not when counting the number of available items.
*
* @return offset for data request
*/
public int getOffset() {
return offset;
}
/**
* Gets the limit of items to fetch. The limit is only used when fetching
* items, but not when counting the number of available items.
*
* Note: It is possible that
* {@code offset + limit > item count}
*
* @return number of items to fetch
*/
public int getLimit() {
return limit;
}
/**
* Gets the sorting for items to fetch. This list of sort orders is used for
* sorting backends. The sort orders are only used when fetching items, but
* not when counting the number of available items.
*
* Note: Sort orders and in-memory sorting are mutually
* exclusive. If the {@link DataProvider} handles one, it should ignore the
* other.
*
* @return list of sort orders
*/
public List getSortOrders() {
return sortOrders;
}
/**
* Gets the filter for items to fetch.
*
* @return optional filter
*/
public Optional getFilter() {
return Optional.ofNullable(filter);
}
/**
* Gets the comparator for sorting in-memory data. The comparator is only
* used when fetching items, but not when counting the number of available
* items.
*
* Note: Sort orders and in-memory sorting are mutually
* exclusive. If the {@link DataProvider} handles one, it should ignore the
* other.
*
* @return sorting comparator
*/
public Comparator getInMemorySorting() {
return inMemorySorting;
}
}