Refactor DataProvider filtering and sorting according to the new design

[Legioth]

The filtering and sorting implementation in Framework 8.0 beta 1 has a couple of design issues that should be fixed by refactoring the current implementation.

The most obvious issues are:

• The design is based on building a chain wrappers, but this doesn't work with the "appendable" concept since you cannot append after converting. (Data provider should still be appendable after filter conversion framework8-issues#554)
• Basing the design on stateless data providers makes things difficult when you need to have state, i.e. when the filtering terms are provided by the application developers.
• The design did not anticipate cases where there are two completely unrelated pieces of filtering input (e.g. String name + Department department for listing employees). This is a common case when using e.g. Spring Data or DeltaSpike to define service APIs.

A new design that avoids these problems could look like this:

• Data providers are stateful with regards to sorting and filtering provided by the application developer, while still being stateless from the point of view of a component that used the data provider.
• Appendability of filters is an aspect of stateful configuration and doesn't warrant any special framework APIs. In practice ListDataProvider should have methods for adding filters, but there's no common base type that defines those methods.
• Lightweight data provider wrappers are provided for at least two cases. Both cases are considered "terminal", i.e. the wrapper is not intended to be further wrapped.
  • Conversion for the filtering type used by a specific component. ListDataProvider provides shorthands for common cases, e.g. case insensitive substring match based on a getter that returns a string.
  • Converting a DataProvider<T, F> into a DataProvider<T, Void> with a setFilter(F filter) method that puts the filter into the query for the wrapped provider.
• BackEndDataProvider is changed to an abstract class with factory methods for creating instances based on simple callbacks.

A rough outline of steps needed to refactor the current implementation:

1. Make sorting configuration stateful and remove the currently implemented wrapper functionality
2. Make filtering configuration stateful in ListDataProvider.
3. Extract BackEndDataProvider callback functionality to a separate class and make BackEndDataProivder subclassable.
4. Provide a wrapper for a "terminal" filter conversion
5. Provide a wrapper for setting the query in a filter based on state
6. Remove the current generic wrapping support
7. Ensure there's documentation for basic list and lazy cases, and especially for the stateful wrapper and a lazy provider with one filer value set by the application and one set by ComboBox.