Initialize a @{@link SquigglyPropertyFilter} with a static filter expression.

@param mappers the Jackson Object Mappers to init
@param filter the filter expressions
@throws IllegalStateException if the filter was unable to be registered
194621
public static void init(Iterable<ObjectMapper> mappers, String filter) throws IllegalStateException {
        init(mappers, new SimpleSquigglyContextProvider(new SquigglyParser(), filter));
    }
1264059
public void setFilter (SiteTreeFilter filter) {
		this.filter = filter;
		SiteNode root = getRoot();
		setFilter(filter, root);
		// Never filter the root node
		root.setFiltered(false);
	}
805278
public void setMapperProperties(Properties properties) {
        if (this.mapperHelper == null) {
            this.mapperHelper = new MapperHelper();
        }
        this.mapperHelper.setProperties(properties);
    }
54455
protected T getTypedFilter(Filter filter) {
    if (isFilterAProperSublcass(filter)) {
      return unchecked(filter);
    }
    throw new IllegalStateException(
        String.format(
            "FilterAdapter %s cannot operate on a filter of type %s",
            getClass().getCanonicalName(),
            filter.getClass().getCanonicalName()));
  }
1036545
@Override
    public void setFilter(Service.Filter filter) {
        _filter = _filter == null ? filter : new CompoundServiceFilter(filter, _filter);
    }
320647
public void addFilter(PropFilter filter)
	{
		if (mFilter == null)
		{
			mFilter = new ArrayList<PropFilter>(8);
		}

		mFilter.add(filter);
	}
1277309
public void setFilters(java.util.Collection<DocumentKeyValuesFilter> filters) {
        if (filters == null) {
            this.filters = null;
            return;
        }

        this.filters = new com.amazonaws.internal.SdkInternalList<DocumentKeyValuesFilter>(filters);
    }
246853
private void initFilter() {
        EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClass);
        Metamodel metaModel = kunderaMetadata.getApplicationMetadata().getMetamodel(getPersistenceUnit());
        EntityType entityType = metaModel.entity(entityClass);

        if (null == filter) {
            List<String> clauses = new ArrayList<String>();
            addDiscriminatorClause(clauses, entityType);
            return;
        }
        WhereClause whereClause = KunderaQueryUtils.getWhereClause(getJpqlExpression());

        KunderaQueryUtils.traverse(whereClause.getConditionalExpression(), metadata, kunderaMetadata, this, false);

        for (Object filterClause : filtersQueue) {

            if (!(filterClause instanceof String)) {
                onTypedParameter(((FilterClause) filterClause));
            }

        }

        addDiscriminatorClause(null, entityType);
    }
903683
public static void shootBowgunPropertyFilter(PropertyFilter propertyFilter) { // should be before initialize()
        synchronized (ObjectiveConfig.class) { // to block while using provider
            assertUnlocked();
            if (logger.isInfoEnabled()) {
                logger.info("...Shooting bowgun property filter: " + propertyFilter);
            }
            bowgunPropertyFilter = propertyFilter;
            lock(); // auto-lock here, because of deep world
        }
    }
546847
public void setPatchFilters(java.util.Collection<PatchFilter> patchFilters) {
        if (patchFilters == null) {
            this.patchFilters = null;
            return;
        }

        this.patchFilters = new com.amazonaws.internal.SdkInternalList<PatchFilter>(patchFilters);
    }
1096067
public VaadinForHeroku withFilterDefinition(final FilterDefinitionBuilder... filterDefs){
        checkVarArgsArguments(filterDefs);
        this.filterDefinitions.addAll(Arrays.asList(filterDefs));
        return self();
    }
109061
public void addFilter(AbstractLogFilter<E> filter) {
                Validate.notNull(filter);
                filters.add(filter);
                uptodate = false;
                filter.addObserver(this);
        }
702626
@Override
    public void initialize(Settings settings) {
        super.initialize(settings);
        if (this.isEnabled()) {
            this.filters = settings.getArray(Settings.KEYS.ANALYZER_RETIREJS_FILTERS);
        }
    }
1281763
public final void updateFilterMap(Map<String,Object> propFilter)
    {
        if (propFilter == null)
            propFilter = new HashMap<String,Object>();     // Then handleUpdateFilterMap can modify the filter
        propFilter = this.handleUpdateFilterMap(propFilter);   // Update this object's local filter.
        this.setFilterMap(propFilter);            // Update any remote copy of this.
    }
248538
public void setFilters(Filter[] filters) {
        if (filters != null && filters.length > 0
                && this.filters != null && this.filters.length > 0) {
            Filter[] oldFilters = this.filters;
            this.filters = new Filter[oldFilters.length + filters.length];
            System.arraycopy(oldFilters, 0, this.filters, 0, oldFilters.length);
            System.arraycopy(filters, 0, this.filters, oldFilters.length, filters.length);
        } else {
            this.filters = filters;
        }
    }
858296
public static <R> Set<R> filterAndListKeys(Iterator<R> keys, KeyFilter<R> filter) {
        Set<R> ret = new HashSet<R>();
        while (keys.hasNext()) {
            R key = keys.next();
            R filtered = filter.filter(key);
            if (filtered != null) {
                ret.add(filtered);
            }
        }
        return ret;
    }
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);
            }
        }
    }