Method allow to specify custom template filtering predicate

@param predicate is not null filtering expression
@return {@link AutoscalePolicyFilter}
512720
public AutoscalePolicyFilter where(Predicate<AutoscalePolicyMetadata> predicate) {
        checkNotNull(predicate, "Predicate must be not a null");

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

        return this;
    }
487011
public void bindFilterPredicate(ObjectProperty<TreeItemPredicate<Category>> predicateProperty) {
    predicateProperty.bind(Bindings.createObjectBinding(() -> {
      if (searchText.get() == null || searchText.get().isEmpty()) {
        return null;
      }
      return TreeItemPredicate.create(filterPredicate);
    }, searchText));
  }
384610
private Collection<ConfigAttribute> wrap(final AccessPredicate predicate) {
        requireNonNull(predicate, "predicate");
        if (predicate == AccessPredicates.PERMIT_ALL) {
            return of(); // Empty collection => public invocation
        }
        return of(new AccessPredicateConfigAttribute(predicate));
    }
1241996
public RelationGraph filterByVertex(@NonNull Predicate<? super Annotation> vertexPredicate) {
      RelationGraph gPrime = new RelationGraph();
      vertices().stream().filter(vertexPredicate).forEach(gPrime::addVertex);
      edges().stream()
             .filter(e -> gPrime.containsVertex(e.getFirstVertex()) && gPrime.containsVertex(e.getSecondVertex()))
             .forEach(gPrime::addEdge);
      return gPrime;
   }
239800
public static <T> Iterator<T> filteringIterator(
        Iterator<? extends T> iterator, 
        Predicate<? super T> predicate)
    {
        Objects.requireNonNull(iterator, "The iterator is null");
        Objects.requireNonNull(predicate, "The predicate is null");
        return new FilteringIterator<T>(iterator, predicate);
    }
1051981
function Predicate(name, parameter1, parameter2) {
              this.name = name;
              this.meta = RuleTemplates[name];
              if (!this.meta) {
                this.meta = RuleTemplates["DEFAULT"];
              }
              //if (this.meta.nrParameters > 0) {
                this.parameter1 = parameter1;
              //}
              //if (this.meta.nrParameters > 1) {
                this.parameter2 = parameter2;
              //}
              //logger.debug('Predicate\n' + JSON.toString(this.meta, null, 2));
            }
755698
public void with(@javax.annotation.Nonnull final java.util.function.Consumer<T> f, final Predicate<T> filter) {
    final T prior = currentValue.get();
    if (null != prior) {
      f.accept(prior);
    }
    else {
      final T poll = get(filter);
      try {
        currentValue.set(poll);
        f.accept(poll);
      } finally {
        this.pool.add(poll);
        currentValue.remove();
      }
    }
  }
710109
@NotNull
    public LongStream filterNot(@NotNull final LongPredicate predicate) {
        return filter(LongPredicate.Util.negate(predicate));
    }
1255073
public AntiAffinityPolicyFilter where(Predicate<AntiAffinityPolicyMetadata> filter) {
        checkNotNull(filter, "Filter predicate must be not a null");

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

        return this;
    }
548733
public static <T extends Annotation> Predicate<T> annotationAnnotatedWith(Class<? extends Annotation>
            annotationClass, boolean includeMetaAnnotations) {
        return candidate -> elementAnnotatedWith(annotationClass, includeMetaAnnotations)
                .test(candidate.annotationType());
    }
625496
public static <T> CloseableIterable<T> filter(final CloseableIterable<T> iterable, final Predicate<? super T> filter) {
        return wrap(Iterables.filter(iterable, filter::test), iterable);
    }
972594
public function filter(callable $predicate): self
    {
        $intervals = array_filter($this->intervals, $predicate, ARRAY_FILTER_USE_BOTH);
        if ($intervals === $this->intervals) {
            return $this;
        }

        return new self(...$intervals);
    }
666250
public InjectorBuilder filter(ElementVisitor<Boolean> predicate) {
        List<Element> elements = new ArrayList<Element>();
        for (Element element : Elements.getElements(Stage.TOOL, module)) {
            if (element.acceptVisitor(predicate)) {
                elements.add(element);
            }
        }
        this.module = Elements.getModule(elements);
        return this;
    }
854646
@CheckReturnValue
  public ScannerSupplier filter(Predicate<? super BugCheckerInfo> predicate) {
    ImmutableSet.Builder<String> disabled = ImmutableSet.builder();
    for (BugCheckerInfo check : getAllChecks().values()) {
      if (!predicate.apply(check)) {
        disabled.add(check.canonicalName());
      }
    }
    return new ScannerSupplierImpl(getAllChecks(), severities(), disabled.build(), getFlags());
  }
383216
public static autoscalepolicy[] get_filtered(nitro_service service, String filter) throws Exception{
		autoscalepolicy obj = new autoscalepolicy();
		options option = new options();
		option.set_filter(filter);
		autoscalepolicy[] response = (autoscalepolicy[]) obj.getfiltered(service, option);
		return response;
	}
1067127
public AutoscalePolicyFilter names(String... names) {
        allItemsNotNull(names, "Autoscale policies names");

        predicate = predicate.and(combine(
            AutoscalePolicyMetadata::getName, in(names)
        ));

        return this;
    }
811113
public T filter(@NonNull SerializablePredicate<? super HString> filter) {
      this.filter = filter;
      return Cast.as(this);
   }