@Override public void addContainerFilter(Filter filter) throws UnsupportedFilterException { if (filterableContainer == null) { throw new UnsupportedOperationException( "Wrapped container is not filterable"); } List<Filter> addedFilters = new ArrayList<Filter>(); for (Entry<?, PropertyValueGenerator<?>> entry : propertyGenerators .entrySet()) { Object property = entry.getKey(); if (filter.appliesToProperty(property)) { // Have generated property modify filter to fit the original // data in the container. Filter modifiedFilter = entry.getValue().modifyFilter(filter); filterableContainer.addContainerFilter(modifiedFilter); // Keep track of added filters addedFilters.add(modifiedFilter); } } if (addedFilters.isEmpty()) { // No generated property modified this filter, use it as is addedFilters.add(filter); filterableContainer.addContainerFilter(filter); } // Map filter to actually added filters activeFilters.put(filter, addedFilters); }
/** * Remove all container filters for a given property identifier and * re-filter the view. This also removes filters applying to multiple * properties including the one identified by propertyId. * * This can be used to implement * {@link Filterable#removeContainerFilters(Object)}. * * @param propertyId * @return Collection<Filter> removed filters */ protected Collection<Filter> removeFilters(Object propertyId) { if (getFilters().isEmpty() || propertyId == null) { return Collections.emptyList(); } List<Filter> removedFilters = new LinkedList<Filter>(); for (Iterator<Filter> iterator = getFilters().iterator(); iterator .hasNext();) { Filter f = iterator.next(); if (f.appliesToProperty(propertyId)) { removedFilters.add(f); iterator.remove(); } } if (!removedFilters.isEmpty()) { filterAll(); return removedFilters; } return Collections.emptyList(); }
/** * Checks if the given itemId passes the filters set for the container. The * caller should make sure the itemId exists in the container. For * non-existing itemIds the behavior is undefined. * * @param itemId * An itemId that exists in the container. * @return true if the itemId passes all filters or no filters are set, * false otherwise. */ protected boolean passesFilters(Object itemId) { ITEMCLASS item = getUnfilteredItem(itemId); if (getFilters().isEmpty()) { return true; } for (final Filter f : getFilters()) { if (!f.passesFilter(itemId, item)) { return false; } } return true; }
/** * Returns true if a change in the named property may affect the filtering * result. If some of the sub-filters are not in-memory filters, true is * returned. * * By default, all sub-filters are iterated to check if any of them applies. * If there are no sub-filters, false is returned - override in subclasses * to change this behavior. */ @Override public boolean appliesToProperty(Object propertyId) { for (Filter filter : getFilters()) { if (filter.appliesToProperty(propertyId)) { return true; } } return false; }
/** * Checks if there is a filter that applies to a given property. * * @param propertyId * @return true if there is an active filter for the property */ protected boolean isPropertyFiltered(Object propertyId) { if (getFilters().isEmpty() || propertyId == null) { return false; } for (final Filter f : getFilters()) { if (f.appliesToProperty(propertyId)) { return true; } } return false; }
@Override protected void registerNewItem(int position, IDTYPE itemId, MhuBeanItem<BEANTYPE> item) { itemIdToItem.put(itemId, item); // add listeners to be able to update filtering on property // changes for (Filter filter : getFilters()) { for (String propertyId : getContainerPropertyIds()) { if (filter.appliesToProperty(propertyId)) { // addValueChangeListener avoids adding duplicates addValueChangeListener(item, propertyId); } } } }
@Override protected void registerNewItem(int position, IDTYPE itemId, BeanItem<BEANTYPE> item) { itemIdToItem.put(itemId, item); // add listeners to be able to update filtering on property // changes for (Filter filter : getFilters()) { for (String propertyId : getContainerPropertyIds()) { if (filter.appliesToProperty(propertyId)) { // addValueChangeListener avoids adding duplicates addValueChangeListener(item, propertyId); } } } }
/** * {@inheritDoc} */ public void removeContainerFilters(Object propertyId) { List<Filter> toRemove = new ArrayList<Filter>(); for (Filter f : filters) { if (f.appliesToProperty(propertyId)) { toRemove.add(f); } } filters.removeAll(toRemove); refresh(); }
private boolean itemPassesFilters(RowItem item) { for (Filter filter : filters) { if (!filter.passesFilter(item.getId(), item)) { return false; } } return true; }
/** * Returns true if a change in the named property may affect the filtering * result. Return value is the same as {@link #appliesToProperty(Object)} * for the negated filter. * * @return boolean */ @Override public boolean appliesToProperty(Object propertyId) { return filter.appliesToProperty(propertyId); }
@Override public boolean passesFilter(Object itemId, Item item) throws UnsupportedFilterException { for (Filter filter : getFilters()) { if (!filter.passesFilter(itemId, item)) { return false; } } return true; }
@Override public boolean passesFilter(Object itemId, Item item) throws UnsupportedOperationException { return !filter.passesFilter(itemId, item); }
private boolean passesFilters(T itemId) { if (isFiltered()) { Item item = super.getItem(itemId); for (Filter f : getFilters()) { if (!f.passesFilter(itemId, item)) { return false; } } } return true; }
@Override public boolean passesFilter(Object itemId, Item item) throws UnsupportedFilterException { for (Filter filter : getFilters()) { if (filter.passesFilter(itemId, item)) { return true; } } return false; }