1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/*
* Copyright 2000-2022 Vaadin Ltd.
*
* 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.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 <T>
* bean type
* @param <F>
* filter type
*
* @since 8.0
*/
public class Query<T, F> implements Serializable {
private final int offset;
private final int limit;
private final List<QuerySortOrder> sortOrders;
private final Comparator<T> 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<QuerySortOrder> sortOrders,
Comparator<T> 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.
* <p>
* <strong>Note: </strong>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.
* <p>
* <strong>Note: </strong> 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<QuerySortOrder> getSortOrders() {
return sortOrders;
}
/**
* Gets the filter for items to fetch.
*
* @return optional filter
*/
public Optional<F> 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.
* <p>
* <strong>Note: </strong> 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<T> getInMemorySorting() {
return inMemorySorting;
}
}
|
