anchor.diff:  The former method is just a way of adding multiple attribute filters at once. The supplied object values are used
   by the filter provider to append the appropriate restrictions to the query builder.
   
  -If an entity view attribute is annotated with multiple attribute filters, the filter with empty name will be active
  -by default. If you want any of the other named annotated filters to be used instead, you need to activate them by
  -calling `com.blazebit.persistence.view.EntityViewSetting.addAttributeNamedFilter`:
  +If an entity view attribute is annotated with multiple attribute filters, the filter with empty name will activated
  +if no filter name is specified when adding an attribute filter to the entity view settings. If you want any of the
  +other named annotated filters to be used instead, you need to use an overloaded form of
  +`com.blazebit.persistence.view.EntityViewSetting.addAttributeNamedFilter` which accepts the filter name as parameter:
   
   ```java
   EntityViewSetting<CatView, CriteriaBuilder<CatView>> setting = EntityViewSetting.create(CatView.class);
  -setting.addAttributeFilter("name", "pete"); // default filter applied, so 'PETE' matches
  -setting.addAttributeFilter("name", "containsCaseSensitive", "pete"); 'PETE' does not match
  +setting.addAttributeFilter("name", "kitty"); // default filter applied, so 'KITTY' matches
  +setting.addAttributeFilter("name", "containsCaseSensitive", "kitty"); 'KITTY' does not match
   ```
   
   At most one attribute filter can be activated per attribute.
  
positive.code: 
  ```java
  settings.addAttributeSorter("name", com.blazebit.persistence.view.Sorters.ascending());
  getActiveCustomers(settings);
  ```
  
  *Note that all attribute names specified when using the filter or sorter API refer to the
  
negative.code: that the filters and sorters can be added/enabled without the need to explicitly modify the entity view type itself
  or the criteria builder which the entity view is based on.
  
  [[introductory-example]]
  Example: Assume a data access method
  
  ```java
  <V, C extends CriteriaBuilder<V>> getHungryCats(EntityViewSettings<V, C> settings) { ... }
  ```
  
  which implements the basic business logic of how to obtain all hungry cats from your database. The method supports
  entity views to allow you to only fetch the fields needed for a concrete use cases, e.g. when displaying the
  cats in a dropdown, their names might be sufficient but when displaying them in a table it might be desirable
  to include more details.
  
  Likewise, one might want to retrieve the cats sorted by name or by age depending on the use case. Having to
  introduce 2 new methods for this purpose would be painful:
  ```java
  <V, C extends CriteriaBuilder<V>> getHungryCatsSortedByName(EntityViewSettings<V, C> settings);
  
  <V, C extends CriteriaBuilder<V>> getHungryCatsSortedByAge(EntityViewSettings<V, C> settings);
  ```
  The above approach does not even account for different sort orders so in reality we might rather go for
  parameterizing the original method which is painful nevertheless:
  ```java
  <V, C extends CriteriaBuilder<V>> getHungryCats(EntityViewSettings<V, C> settings, String sortField, String sortOrder);
  ```
  
  Instead it is possible to apply the sorting to the EntityViewSettings instance that is passed to
  