Adds a {@link PropFilter} to send with the request.

@param filter
A {@link CompFilter}.
320647
public void addFilter(PropFilter filter)
	{
		if (mFilter == null)
		{
			mFilter = new ArrayList<PropFilter>(8);
		}

		mFilter.add(filter);
	}
843484
public NetworkFilter where(Predicate<NetworkMetadata> filter) {
        checkNotNull(filter, "Filter predicate must be not a null");

        this.predicate = this.predicate.and(filter);

        return this;
    }
621951
public void applyFilter(int filter) {
        Filters.checkFilterArgument(filter);
        mDisplayRenderer.changeFilterMode(filter);
        synchronized (mReadyForFrameFence) {
            mNewFilter = filter;
        }
    }
891465
public void addMessageFilter(MessageFilter messageFilter)
    {
        boolean bThinTarget = ((BaseMessageFilter)messageFilter).isThinTarget();
        ((BaseMessageFilter)messageFilter).setThinTarget(false);  // If this is replicated to a server, the server needs to know that I am thick.
        super.addMessageFilter(messageFilter);
        ((BaseMessageFilter)messageFilter).setThinTarget(bThinTarget);
    }
706296
public void addResponseFilter(String name, ResponseFilter responseFilter) {
    if (responseFilters.containsKey(name)) {
      throw new IllegalArgumentException("Duplicate response filter: " + name);
    }
    proxy.addResponseFilter(responseFilter);
    responseFilters.put(name, responseFilter);
  }
109061
public void addFilter(AbstractLogFilter<E> filter) {
                Validate.notNull(filter);
                filters.add(filter);
                uptodate = false;
                filter.addObserver(this);
        }
819434
public FilterBuilder<T> addWithOr(final Filter<T> filter) {
    filterInstance = ComposableFilter.or(filterInstance, filter);
    return this;
  }
86092
public int addMessageFilter(MessageFilter messageFilter)
    {
        MessageReceiver receiver = this.getMessageQueue(messageFilter.getQueueName(), messageFilter.getQueueType()).getMessageReceiver();
        receiver.addMessageFilter(messageFilter);
        return Constant.NORMAL_RETURN;
    }
718610
public static<T> Filter<T> not(final Filter<T> filter) {
		return new AbstractFilter<T>() {
			@Override
			public boolean apply(final T x) {
				return ! filter.apply(x);
			}

			@Override
			public String toString() {
				return "(not " + filter + ")";
			}

			@Override
			public Filter<T> copy() {
				return not(filter.copy());
			}
		};
	}
120941
public boolean contains(PropertyFilter<S> propFilter) {
        if (mPropFilter == propFilter) {
            return true;
        }
        if (mNext == null) {
            return false;
        }
        // Tail recursion.
        return mNext.contains(propFilter);
    }
79381
public void removeFilter(AbstractLogFilter<E> filter) {
                Validate.notNull(filter);
                filters.remove(filter);
                uptodate = false;
                filter.deleteObserver(this);
        }
392689
public AndMessageFilter add(IFeedbackMessageFilter... filters) {
		for (IFeedbackMessageFilter filter : filters) {
			this.filters.add(filter);
		}
		return this;
	}
452512
public void setNewFilterProperties(BaseMessageFilter messageFilter, Object[][] mxProperties, Map<String, Object> propFilter)
    {
        super.setNewFilterProperties(messageFilter, mxProperties, propFilter);      // Does nothing.
        try   {
            if (messageFilter.isUpdateRemoteFilter())   // Almost always true
                if (messageFilter.getRemoteFilterID() != null)     // If the remote filter exists
                    m_receiveQueue.updateRemoteFilterProperties(messageFilter, mxProperties, propFilter);
        } catch (RemoteException ex)    {
            ex.printStackTrace();
        }
    }
1222071
public void addFilter(final WebAppFilter filter) {
		NullArgumentException.validateNotNull(filter, "Filter");
		NullArgumentException.validateNotNull(filter.getFilterName(),
				"Filter name");
		NullArgumentException.validateNotNull(filter.getFilterClass(),
				"Filter class");
		filters.put(filter.getFilterName(), filter);
		// add url patterns and servlet names for filter mappings added before
		// filter
		for (WebAppFilterMapping mapping : getFilterMappings(filter
				.getFilterName())) {
			if (mapping.getUrlPattern() != null
					&& mapping.getUrlPattern().trim().length() > 0) {
				filter.addUrlPattern(mapping.getUrlPattern());
			}
			if (mapping.getServletName() != null
					&& mapping.getServletName().trim().length() > 0) {
				filter.addServletName(mapping.getServletName());
			}
		}
	}
216468
@Bind(aggregate = true, optional = true)
    public void bindFilter(Filter filter) {
        filters.add(filter);
    }
567868
public void addMessageFilter(BaseMessageFilter messageFilter)
    {
        if (messageFilter == null)
            return;
        m_mapFilters.put(m_intNext, messageFilter);
        messageFilter.setMessageReceiver(this.getMessageReceiver(), m_intNext);
        int i = m_intNext.intValue();
        if (i == Integer.MAX_VALUE)
            i = 0;
        m_intNext = new Integer(i + 1);
    }
447212
public OrMessageFilter add(IFeedbackMessageFilter... filters) {
		for (IFeedbackMessageFilter filter : filters) {
			this.filters.add(filter);
		}
		return this;
	}