Add DataProvider.setFilter method

Change-Id: I87193d3d2c66a880c2be165cfd49926fa290010b

server/src/main/java/com/vaadin/server/data/DataProvider.java

      */
     Registration addDataProviderListener(DataProviderListener listener);
 
+    /**
+     * Returns a new wrapped data provider with given default filter. Default
+     * filter will apply to each query and further filtering will not be
+     * supported in the wrapped data provider.
+     *
+     * @param filter
+     *            the default filter
+     * @return wrapped data provider with provided filter
+     */
+    public default DataProvider<T, Void> setFilter(F filter) {
+        return new FilteringDataProviderWrapper<>(this, filter);
+    }
+
     /**
      * Convert the data provider to use a different filter type. It is used for
      * adapting this data provider to a filter type provided by a Component such
      *
      * @return wrapped data provider
      */
-    default <M> DataProvider<T, M> convertFilter(
+    public default <M> DataProvider<T, M> convertFilter(
             SerializableFunction<M, F> mapper) {
         return new FilteringDataProviderWrapper<>(this, mapper);
     }

server/src/main/java/com/vaadin/server/data/FilteringDataProviderWrapper.java

 
     private DataProvider<T, M> dataProvider;
     private SerializableFunction<F, M> mapper;
+    private M staticFilter = null;
 
+    /**
+     * Constructs a filtering wrapper for a data provider with always applied
+     * static filter.
+     *
+     * @param dataProvider
+     *            the wrapped data provider
+     * @param filter
+     *            the static filter
+     */
+    public FilteringDataProviderWrapper(DataProvider<T, M> dataProvider,
+            M filter) {
+        this.dataProvider = dataProvider;
+        this.staticFilter = filter;
+    }
+
+    /**
+     * Constructs a filtering wrapper for a data provider with a mapping from
+     * one filter type to another.
+     *
+     * @param dataProvider
+     *            the wrapped data provider
+     * @param mapper
+     *            the filter mapping function
+     */
     public FilteringDataProviderWrapper(DataProvider<T, M> dataProvider,
             SerializableFunction<F, M> mapper) {
         this.dataProvider = dataProvider;
     @Override
     public int size(Query<F> t) {
         return dataProvider.size(new Query<M>(t.getOffset(), t.getLimit(),
-                t.getSortOrders(), t.getFilter().map(mapper).orElse(null)));
+                t.getSortOrders(), getFilter(t)));
     }
 
     @Override
     public Stream<T> fetch(Query<F> t) {
         return dataProvider.fetch(new Query<M>(t.getOffset(), t.getLimit(),
-                t.getSortOrders(), t.getFilter().map(mapper).orElse(null)));
+                t.getSortOrders(), getFilter(t)));
     }
 
+    private M getFilter(Query<F> query) {
+        if (staticFilter != null) {
+            return staticFilter;
+        }
+        return query.getFilter().map(mapper).orElse(null);
+    }
 }

server/src/test/java/com/vaadin/server/data/provider/ListDataProviderTest.java

 import org.junit.Before;
 import org.junit.Test;
 
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.server.data.DataProvider;
 import com.vaadin.server.data.ListDataProvider;
 import com.vaadin.server.data.Query;
                 dataProvider.size(new Query<>(
                         strBean -> strBean.getValue().contains("Foo"))));
     }
+
+    @Test
+    public void filteringListDataProvider_defaultFilter() {
+        SerializablePredicate<StrBean> filter = s -> s.getRandomNumber() > 4;
+        // Intentionally lost filter type. Not actually filterable anymore.
+        DataProvider<StrBean, ?> filtered = dataProvider.setFilter(filter);
+
+        Assert.assertEquals("Filter not applied, unexpected item count",
+                dataProvider.size(new Query<>(filter)),
+                filtered.size(new Query<>()));
+
+        Assert.assertEquals("Further filtering succeeded",
+                filtered.size(new Query<>()),
+                filtered.size((Query) new Query<SerializablePredicate<StrBean>>(
+                        s -> s.getValue().equals("Foo"))));
+    }
 }