Verifies a sequence of codepoints using the specified filter

@param aIter
Codepoint iterator
@param aFilter
Filter to use
7796
public static void verifyNot (final ICodepointIterator aIter, final IntPredicate aFilter)
  {
    final CodepointIteratorRestricted rci = aIter.restrict (aFilter, false, true);
    while (rci.hasNext ())
      rci.next ();
  }
205182
public void afterAfter(Filter filter) {
        addFilter(HttpMethod.afterafter, FilterImpl.create(SparkUtils.ALL_PATHS, filter));
    }
707180
private void checkRuleMapping(final QName attName, final List<String> attValue) {
        if (attValue == null || attValue.isEmpty()) {
            return;
        }
        for (final String attSubValue: attValue) {
            final FilterKey filterKey = new FilterKey(attName, attSubValue);
            final Action filterAction = filterMap.get(filterKey);
            if (filterAction == null && logMissingAction) {
                if (!alreadyShowed(filterKey)) {
                    logger.info(MessageUtils.getMessage("DOTJ031I", filterKey.toString()).toString());
                }
            }
        }
    }
98676
private void validateFilters() {
    Set<String> ids = new HashSet<String>();
    for (Filter filter : filters) {
      ids.add(filter.getId());
    }

    for(Metric metric : metrics) {
      if (metric.getFilter() != null && 
          !metric.getFilter().isEmpty() && 
          !ids.contains(metric.getFilter())) {
        throw new IllegalArgumentException(
            String.format("unrecognized filter id %s in metric %s",
                metric.getFilter(), metric.getId()));
      }
    }
  }
120941
public boolean contains(PropertyFilter<S> propFilter) {
        if (mPropFilter == propFilter) {
            return true;
        }
        if (mNext == null) {
            return false;
        }
        // Tail recursion.
        return mNext.contains(propFilter);
    }
733933
public List<String> list(NfsFilenameFilter filter) throws IOException {
        List<String> children = list();
        if ((children == null) || (children.size() == 0) || (filter == null)) {
            return children;
        }
        List<String> filteredChildren = new ArrayList<String>();
        for (String child : children) {
            if (filter.accept(this, child)) {
                filteredChildren.add(child);
            }
        }
        return filteredChildren;
    }
1038414
protected boolean loadFilters(final boolean cleanOnFail, boolean asynchronous)
   {
      if (!filtersSupported.get())
      {
         if (LOG.isWarnEnabled())
         {
            LOG.warn("The bloom filters are not supported therefore they cannot be reloaded");
         }
         return false;
      }
      filtersEnabled.set(false);
      this.filterPermissions = new BloomFilter<String>(bfProbability, bfElementNumber);
      this.filterOwner = new BloomFilter<String>(bfProbability, bfElementNumber);

      if (asynchronous)
      {
         new Thread(new Runnable()
         {
            public void run()
            {
               doLoadFilters(cleanOnFail);
            }
         }, "BloomFilter-Loader-" + dataContainer.getName()).start();

         return true;
      }
      else
      {
         return doLoadFilters(cleanOnFail);
      }
   }
875442
private boolean checkFilter(SCIMFilter filter) {
        switch (filter.getFilterType()) {
            case AND:
            case OR:
                return checkFilter(filter.getFilterComponents().get(0)) | checkFilter(filter.getFilterComponents().get(1));
            case EQUALITY:
                String name = filter.getFilterAttribute().getAttributeName();
                if ("id".equalsIgnoreCase(name) ||
                    "userName".equalsIgnoreCase(name)) {
                    return true;
                } else if (OriginKeys.ORIGIN.equalsIgnoreCase(name)) {
                    return false;
                } else {
                    throw new ScimException("Invalid filter attribute.", HttpStatus.BAD_REQUEST);
                }
            case PRESENCE:
            case STARTS_WITH:
            case CONTAINS:
                throw new ScimException("Wildcards are not allowed in filter.", HttpStatus.BAD_REQUEST);
            case GREATER_THAN:
            case GREATER_OR_EQUAL:
            case LESS_THAN:
            case LESS_OR_EQUAL:
                throw new ScimException("Invalid operator.", HttpStatus.BAD_REQUEST);
        }
        return false;
    }
279969
def _verify_filters(self, kwargs, obj, encode=False):
        """"""
        return (filters.legacy_filter_formatter if encode else filters.filter_formatter)(
            kwargs,
            obj._get_attributes_map()
        )
671315
public void after(Filter filter) {
        addFilter(HttpMethod.after, FilterImpl.create(SparkUtils.ALL_PATHS, filter));
    }
1099626
public void addAutofilter(final Table table, final int r1, final int c1, final int r2, final int c2) {
        this.contentElement.addAutofilter(table, r1, c1, r2, c2);
    }
681856
@Nonnegative
  public int getAllCount (@Nullable final Predicate <? super IError> aFilter)
  {
    int ret = 0;
    for (final ValidationResult aItem : this)
      ret += aItem.getErrorList ().getCount (aFilter);
    return ret;
  }
176819
private static VisitorAttributes checkAttributes(VirtualFileFilter filter, VisitorAttributes attributes) {
        if (filter == null) {
            throw MESSAGES.nullArgument("filter");
        }
        // Specified
        if (attributes != null) { return attributes; }
        // From the filter
        if (filter instanceof VirtualFileFilterWithAttributes) { return ((VirtualFileFilterWithAttributes) filter).getAttributes(); }
        // It will use the default
        return null;
    }
106305
public static void verifyNot (final ICodepointIterator aIter, @Nonnull final ECodepointProfile eProfile)
  {
    final CodepointIteratorRestricted rci = aIter.restrict (eProfile.getFilter (), false, true);
    while (rci.hasNext ())
      rci.next ();
  }
1264101
public static void verify (final AbstractCodepointIterator aIter, @Nonnull final ECodepointProfile eProfile)
  {
    verify (aIter, eProfile.getFilter ());
  }
320647
public void addFilter(PropFilter filter)
	{
		if (mFilter == null)
		{
			mFilter = new ArrayList<PropFilter>(8);
		}

		mFilter.add(filter);
	}
1002674
private static void parseFilters(final FilterType filterType, final WebApp webApp) {
		final WebAppFilter filter = new WebAppFilter();
		if (filterType.getFilterName() != null) {
			filter.setFilterName(filterType.getFilterName().getValue());
		}
		if (filterType.getFilterClass() != null) {
			filter.setFilterClass(filterType.getFilterClass().getValue());
		}

		if (filterType.getAsyncSupported() != null) {
			filter.setAsyncSupported(filterType.getAsyncSupported().isValue());
		}

		webApp.addFilter(filter);
		List<ParamValueType> initParams = filterType.getInitParam();
		if (initParams != null && initParams.size() > 0) {
			for (ParamValueType initParamElement : initParams) {
				final WebAppInitParam initParam = new WebAppInitParam();
				initParam.setParamName(initParamElement.getParamName().getValue());
				initParam.setParamValue(initParamElement.getParamValue().getValue());
				filter.addInitParam(initParam);
			}
		}

		List<DescriptionType> description = filterType.getDescription();
		for (DescriptionType descriptionType : description) {
			filter.addDispatcherType(DispatcherType.valueOf(descriptionType.getValue()));
		}
	}