Update the remote filter with this new map information.
@param propFilter New filter information (ie, bookmark=345).
964943
public final void setFilterMap(Map<String, Object> propFilter)
    {
        if (this.getMessageReceiver() != null)
            this.getMessageReceiver().setNewFilterProperties(this, null, propFilter);   // Update any remote copy of this.
    }
1061653
public void addThisMessageFilter(BaseMessageFilter filter)
    {
        if (m_filter == null)
            m_filter = filter;
        else
        {
            if (m_filter instanceof BaseMessageFilter)
            {
                BaseMessageFilter filterFirst = (BaseMessageFilter)m_filter;
                m_filter = new Hashtable<String,Object>();
                ((Map)m_filter).put(filterFirst.getFilterID(), filterFirst);
            }
            ((Map)m_filter).put(filter.getFilterID(), filter);
        }
    }
79381
public void removeFilter(AbstractLogFilter<E> filter) {
                Validate.notNull(filter);
                filters.remove(filter);
                uptodate = false;
                filter.deleteObserver(this);
        }
1369422
public void setFilter(Filter filter)
    {
        if (this.filter == null)
        {
            this.filter = new FilterList();
        }
        if (filter != null)
        {
            this.filter.addFilter(filter);
        }
    }
568804
public void filterUpdate(DataSetFilter filter) {
        if (displayerSettings.isFilterEnabled()) {

            DataSetFilter oldFilter = currentFilter;
            this.currentFilter = filter;

            // Notify to those interested parties the selection event.
            if (displayerSettings.isFilterNotificationEnabled()) {
                for (DisplayerListener listener : listenerList) {
                    listener.onFilterUpdate(this, oldFilter, filter);
                }
            }
            // Drill-down support
            if (displayerSettings.isFilterSelfApplyEnabled()) {
                dataSetHandler.unfilter(oldFilter);
                dataSetHandler.filter(filter);
                redraw();
            }
        }
    }
1030456
public void setDependencyFilter(ObjectNode filter) {
        if (filter == null) {
            return;
        }
        final JsonNode patterns = filter.get("patterns");
        if (patterns != null && patterns.isArray()) {
            List<String> ids = new ArrayList<>();
            for (JsonNode exclusion : patterns) {
                ids.add(exclusion.asText());
            }
            setDependencyFilter(new ExcludesArtifactFilter(ids));
        }
    }
1224106
public static void addPropertyId(
        CmsCmisTypeManager typeManager,
        PropertiesImpl props,
        String typeId,
        Set<String> filter,
        String id,
        String value) {

        if (!checkAddProperty(typeManager, props, typeId, filter, id)) {
            return;
        }
        PropertyIdImpl result = new PropertyIdImpl(id, value);
        result.setQueryName(id);

        props.addProperty(result);
    }
351639
void setFilters(Map<Object, Object> filters) {

        for (Object column : filters.keySet()) {
            Object filterValue = filters.get(column);
            if ((filterValue != null) && !filterValue.toString().isEmpty() && !m_table.isColumnCollapsed(column)) {
                m_table.setFilterFieldValue(column, filterValue);
            }
        }
    }
143523
private void setPropertyFilters(String filters) {
		this.filterProperties = new HashSet<>();
		if (!"-".equals(filters)) {
			for (String pid : filters.split(",")) {
				this.filterProperties.add(Datamodel
						.makeWikidataPropertyIdValue(pid));
			}
		}
	}
906366
public void setFilterParams(Map<String, Object> filterParams) {
        properties.put(ReplicationField.FILTER_PARAMS, filterParams);
        replicationInternal.setFilterParams(filterParams);
    }
1201457
public static void updateMetadata(final File file, final PropertyMap map) throws FrameworkException {
		updateMetadata(file, map, false);
	}
357268
def update_filter(self):
        
        # Consider the filter invalid
        self.valid_filter = False

        try:
            # Format the new filter
            filter_str = self._original_filter.format(
                **self._component_context.properties
            )
        except KeyError as ex:
            # An entry is missing: abandon
            logging.warning("Missing filter value: %s", ex)
            raise ValueError("Missing filter value")

        try:
            # Parse the new LDAP filter
            new_filter = ldapfilter.get_ldap_filter(filter_str)
        except (TypeError, ValueError) as ex:
            logging.warning("Error parsing filter: %s", ex)
            raise ValueError("Error parsing filter")

        # The filter is valid
        self.valid_filter = True

        # Compare to the "old" one
        if new_filter != self.requirement.filter:
            # Replace the requirement filter
            self.requirement.filter = new_filter
            return True

        # Same filter
        return False
609554
public void setNewFilterTree(BaseMessageFilter messageFilter, Object[][] propKeys)
    {
        if (propKeys != null)
            if (!propKeys.equals(messageFilter.getNameValueTree()))
        {   // This moves the filter to the new leaf
            this.getRegistry().removeMessageFilter(messageFilter);
            super.setNewFilterTree(messageFilter, propKeys);
            this.getRegistry().addMessageFilter(messageFilter);
        }
    }
879660
protected void applyQueryFilter(Map<String, Object> params, QueryFilter queryFilter) {
    	if (queryFilter != null) {
    	    applyQueryContext(params, queryFilter);
        	if (queryFilter.getFilterParams() != null && !queryFilter.getFilterParams().isEmpty()) {
        		params.put(FILTER, queryFilter.getFilterParams());
        		for(String key : queryFilter.getParams().keySet()){
                    params.put(key, queryFilter.getParams().get(key));
                }
        	}
        }
    }
577800
@SuppressWarnings("unchecked")
    public Q filter(Filter filter) {
        if (filters.isEmpty()) {
            this.filter = filter;
            filters = ImmutableList.of(filter);
        } else {
            this.filter = null;
            if (filters.size() == 1) {
                filters = new ArrayList<Filter>();
            }
            filters.add(filter);
        }
        return (Q) this;
    }
169832
public OperationFuture<List<Network>> update(NetworkFilter filter, UpdateNetworkConfig config) {
        checkFilter(filter);

        List<Network> networkList = findLazy(filter)
            .map(metadata -> Network.refById(metadata.getId()))
            .collect(toList());

        return update(networkList, config);
    }
557773
public void set_filter(filtervalue[] filter) 
	{
		String str = null;
		for (int i = 0; i < filter.length; i++)
		{
			if (str != null)
				str = str + ",";
			if (str == null)
				str = filter[i].get_name() + ":" + nitro_util.encode(filter[i].get_value());
			else
				str = str + filter[i].get_name() + ":" + nitro_util.encode(filter[i].get_value());;
		}
		this.filter = str;
	}