Convenience method for notifying a listener (if any) of a query filter change event.

@param filter The filter that changed.
430710
protected void notifyListeners(IQueryFilter<T> filter) {
        for (IQueryFilterChanged<T> listener : listeners) {
            listener.onFilterChanged(filter);
        }
    }
1135111
@InterfaceAudience.Public
    public void setFilter(String filterName) {
        properties.put(ReplicationField.FILTER_NAME, filterName);
        replicationInternal.setFilter(filterName);
    }
287305
public void addFilter(Filter filter) {
    filter.setInitialContext(initialContext);

    int minIndex = Integer.MAX_VALUE;
    String[] before = filter.before();
    for (int i = 0; i < before.length; i++) {
        String s = before[i];
        int index = index(activeFilters, s);
        if (index < minIndex) {
          minIndex = index;
        }
      }
      if (minIndex == Integer.MAX_VALUE) {
        // -1 is more usable for not-found than MAX_VALUE
        minIndex = -1;
      }

    if (contains(filter.before(), FIRST_IN_PIPE)) {
      activeFilters.add(0, filter);
    } else if (minIndex != -1) {
      activeFilters.add(minIndex, filter);
    } else {
      activeFilters.add(filter);
    }
  }
354269
public void addFilter(Filter filter) {
		List<Filter> filters = filterFactory.getAllFilter();
		
		int index = searchFilterIndex(filters, filter.getId(), 0, filters.size());
		
		if (index == -1) {
			// not found - put at the end
			filters.add(filter);
		} else {
			filters.add(index, filter);
		}
	}
855118
public void addFilterAfter(IRuleFilter filter, Class<? extends IRuleFilter> afterFilter) {
        int index = getIndexOfClass(filters, afterFilter);
        if (index == -1) {
            throw new FilterAddException("filter " + afterFilter.getSimpleName() + " has not been added");
        }
        filters.add(index + 1, filter);
    }
205182
public void afterAfter(Filter filter) {
        addFilter(HttpMethod.afterafter, FilterImpl.create(SparkUtils.ALL_PATHS, filter));
    }
262061
public static synchronized void setLogFilter(LogFilter logFilter) {
        Preconditions.checkArgument(logFilter == null, "logFilter == null");
        Limb.log(LogLevel.DEBUG, "Set LogFilter to instance of class " + logFilter.getClass().getName() + '.');
        LOG_FILTER = logFilter;
    }
687491
public void updateClientNotificationListener(RESTRequest request, String objectNameStr, NotificationFilter[] filters, JSONConverter converter) {
        NotificationTargetInformation nti = toNotificationTargetInformation(request, objectNameStr);

        ClientNotificationListener listener = listeners.get(nti);

        if (listener == null) {
            throw ErrorHelper.createRESTHandlerJsonException(new RuntimeException("There are no listeners registered for " + nti), converter, APIConstants.STATUS_BAD_REQUEST);
        }

        //Make the update
        listener.addClientNotification(filters);
    }
248327
public void addListenerMessageFilter(BaseMessageFilter messageFilter)
    {
        if (m_messageFilterList == null)
            m_messageFilterList = new MessageListenerFilterList(this);
        m_messageFilterList.addMessageFilter(messageFilter);
    }
371154
public void setFilters(java.util.Collection<Filter> filters) {
        if (filters == null) {
            this.filters = null;
            return;
        }

        this.filters = new java.util.ArrayList<Filter>(filters);
    }
756472
@Override
    public void onFilterEnabled(Displayer displayer, DataSetGroup groupOp) {
        currentPage = 1;
        super.onFilterEnabled(displayer, groupOp);
    }
629043
public void addFilter(final String columnFamily, Filter filter)
    {
        FilterList filterList = this.filters.get(columnFamily);
        if (filterList == null)
        {
            filterList = new FilterList();
        }
        if (filter != null)
        {
            filterList.addFilter(filter);
        }
        this.filters.put(columnFamily, filterList);
    }
1353188
protected void onRemoved() {
        List<FilterChangeListener> listeners = getAllListeners();
        for (FilterChangeListener listener : listeners) {
            listener.onRemove(this);
        }
    }
1234219
@Override
    public final void onApplicationEvent(E event) {
        for (final ApplicationEventFilter<E> applicationEventFilter :
                this.applicationEventFilters) {
            if (!applicationEventFilter.supports(event)) {
                logger.debug(
                        "Filter {} does not support event {} it will be ignored",
                        applicationEventFilter,
                        event);
                return;
            }
        }

        this.onFilteredApplicationEvent(event);
    }
767685
public void modifiedService(ServiceReference<FilterFactory> reference, FilterFactoryReference service) {
        if (service != null) {
            service.setProperties(reference);
            LOGGER.debug("updated FilterFactory {} for application {}", service.getFactory().getClass().getName(),
                applicationName);
        }
    }
1314409
void setFilter(Filter filter)
    {
        this.filter = Optional.ofNullable(filter).orElse(FilterNone.INSTANCE);
        transform = getTransform();
    }
495600
public void setFilters(List<Service.Filter> filters) {
        for (Service.Filter filter: filters) setFilter(filter);
    }