ConfigurableFilterDataProvider<Person, String, Set<String>> wrapper =
personProvider.withConfigurableFilter(
- (Set<String> configuredFilters, String queryFilter) -> {
+ (String queryFilter, Set<String> configuredFilters) -> {
Set<String> combinedFilters = new HashSet<>();
combinedFilters.addAll(configuredFilters);
combinedFilters.add(queryFilter);
// For use with ComboBox and separate department filtering
ConfigurableDataProvider<Person, String, Department> mixed =
dataProvider.withConfigurableFilter(
- (department, filterText) -> {
+ // Can be shortened as PersonFilter::new
+ (filterText, department) -> {
return new PersonFilter(filterText, department);
}
);
* the query filter type
* @param <C>
* the configurable filter type
+ * @param <F>
+ * the filter type of the wrapped data provider
*/
-public abstract class ConfigurableFilterDataProviderWrapper<T, Q, C>
- extends DataProviderWrapper<T, Q, C>
+public abstract class ConfigurableFilterDataProviderWrapper<T, Q, C, F>
+ extends DataProviderWrapper<T, Q, F>
implements ConfigurableFilterDataProvider<T, Q, C> {
private C configuredFilter;
* the data provider to wrap, not <code>null</code>
*/
public ConfigurableFilterDataProviderWrapper(
- DataProvider<T, C> dataProvider) {
+ DataProvider<T, F> dataProvider) {
super(dataProvider);
}
@Override
- protected C getFilter(Query<T, Q> query) {
- return query.getFilter().map(
- queryFilter -> combineFilters(configuredFilter, queryFilter))
- .orElse(configuredFilter);
+ protected F getFilter(Query<T, Q> query) {
+ Q queryFilter = query.getFilter().orElse(null);
+ if (configuredFilter == null && queryFilter == null) {
+ return null;
+ }
+ return combineFilters(queryFilter, configuredFilter);
}
/**
* Combines the configured filter and the filter from the query into one
- * filter instance that can be passed to the wrapped data provider. This
- * method is called only if there is a query filter, otherwise the
- * configured filter will be directly passed to the query.
- *
+ * filter instance that can be passed to the wrapped data provider. Will not
+ * be called if the configured filter is <code>null</code> and the query has
+ * no filter.
+ *
+ * @param queryFilter
+ * the filter received through the query, or <code>null</code> if
+ * no filter was provided in the query
* @param configuredFilter
* the filter that this data provider is configured to use, or
* <code>null</code> if no filter has been configured
- * @param queryFilter
- * the filter received through the query, not <code>null</code>
* @return a filter that combines the two provided queries, or
* <code>null</code> to not pass any filter to the wrapped data
* provider
*/
- protected abstract C combineFilters(C configuredFilter, Q queryFilter);
+ protected abstract F combineFilters(Q queryFilter, C configuredFilter);
@Override
public void setFilter(C filter) {
* @param filterCombiner
* a callback for combining and the configured filter with the
* filter from the query to get a filter to pass to the wrapped
- * provider. Will only be called if the query contains a filter.
- * Not <code>null</code>
+ * provider. Either parameter might be <code>null</code>, but the
+ * callback will not be invoked at all if both would be
+ * <code>null</code>. Not <code>null</code>.
*
* @return a data provider with a configurable filter, not <code>null</code>
*/
- public default <C> ConfigurableFilterDataProvider<T, C, F> withConfigurableFilter(
- SerializableBiFunction<F, C, F> filterCombiner) {
- return new ConfigurableFilterDataProviderWrapper<T, C, F>(this) {
+ public default <Q, C> ConfigurableFilterDataProvider<T, Q, C> withConfigurableFilter(
+ SerializableBiFunction<Q, C, F> filterCombiner) {
+ return new ConfigurableFilterDataProviderWrapper<T, Q, C, F>(this) {
@Override
- protected F combineFilters(F configuredFilter, C queryFilter) {
- return filterCombiner.apply(configuredFilter, queryFilter);
+ protected F combineFilters(Q queryFilter, C configuredFilter) {
+ return filterCombiner.apply(queryFilter, configuredFilter);
}
};
}
* @return a data provider with a configurable filter, not <code>null</code>
*/
public default ConfigurableFilterDataProvider<T, Void, F> withConfigurableFilter() {
- return withConfigurableFilter((configuredFilter, queryFilter) -> {
+ return withConfigurableFilter((queryFilter, configuredFilter) -> {
assert queryFilter == null : "Filter from Void query must be null";
return configuredFilter;
StrBean.generateRandomBeans(100));
private ConfigurableFilterDataProvider<StrBean, Void, SerializablePredicate<StrBean>> configurableVoid = backEndProvider
.withConfigurableFilter();
- private ConfigurableFilterDataProvider<StrBean, SerializablePredicate<StrBean>, SerializablePredicate<StrBean>> configurablePredicate = backEndProvider
- .withConfigurableFilter((configuredFilter, queryFilter) -> item -> {
- if (configuredFilter != null && !configuredFilter.test(item)) {
+ private ConfigurableFilterDataProvider<StrBean, String, Integer> configurablePredicate = backEndProvider
+ .withConfigurableFilter((queryFilter, configuredFilter) -> item -> {
+ if (queryFilter != null
+ && !item.getValue().equals(queryFilter)) {
return false;
}
- return queryFilter.test(item);
+ if (configuredFilter != null
+ && item.getId() < configuredFilter.intValue()) {
+ return false;
+ }
+
+ return true;
});
@Test
@Test
public void predicate_setFilter() {
- configurablePredicate.setFilter(xyzFilter);
+ configurablePredicate.setFilter(Integer.valueOf(50));
- Assert.assertEquals("Set filter should be used", 1,
+ Assert.assertEquals("Set filter should be used", 49,
configurablePredicate.size(new Query<>()));
configurablePredicate.setFilter(null);
@Test
public void predicate_queryFilter() {
Assert.assertEquals("Query filter should be used", 1,
- configurablePredicate.size(new Query<>(xyzFilter)));
+ configurablePredicate.size(new Query<>("Xyz")));
Assert.assertEquals("null query filter should return all items", 100,
configurablePredicate.size(new Query<>()));
@Test
public void predicate_combinedFilters() {
- configurablePredicate.setFilter(item -> item.getValue().equals("Foo"));
+ configurablePredicate.setFilter(Integer.valueOf(50));
Assert.assertEquals("Both filters should be used", 0,
- configurablePredicate.size(new Query<>(xyzFilter)));
+ configurablePredicate.size(new Query<>("Xyz")));
configurablePredicate.setFilter(null);
Assert.assertEquals("Only zyz filter should be used", 1,
- configurablePredicate.size(new Query<>(xyzFilter)));
+ configurablePredicate.size(new Query<>("Xyz")));
}
}