Binds the predicateProperty to ensure filtering according to the searchText.

@param predicateProperty of the rootItem of a {@link FilterableTreeItem}
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));
  }
307756
public static <T> ActionPredicate<T> fromPredicate(final Predicate<T> predicate) {
	return new ActionPredicate<T>() {
	    public boolean actionPredicate(T obj) {
		return predicate.check(obj);
	    }
	};
    }
842353
public boolean shouldSelectProperty(String property) {
        // no restriction
        if (getRoot().eagerLoad || restrictedProperties == null) {
            return true;
        }
        // explicit restriction
        if (getRoot().eagerLoad || restrictedProperties.contains(property)) {
            return true;
        }
        return false;
    }
538723
@Override
	public boolean filter(Object entity) {
		if (fixture instanceof FilterableFixture) {
			return filterableFixture().filter(entity);
		}

		return true;
	}
701771
@CheckReturnValue
  public final FluentIterable<E> filter(Predicate<? super E> predicate) {
    return from(Iterables.filter(iterable, predicate));
  }
1227014
@GwtIncompatible // NavigableMap
  private static <K, V> NavigableMap<K, V> filterFiltered(
      FilteredEntryNavigableMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) {
    Predicate<Entry<K, V>> predicate =
        Predicates.<Entry<K, V>>and(map.entryPredicate, entryPredicate);
    return new FilteredEntryNavigableMap<K, V>(map.unfiltered, predicate);
  }
1323819
protected <R> Predicate byMandatoryPredicate(CriteriaQuery<?> criteriaQuery, Root<E> root, CriteriaBuilder builder, E entity, SearchParameters sp) {
        return null;
    }
1070908
@SuppressWarnings("unchecked")
    public <T extends Identifiable<?>, M2O extends Identifiable<?>> List<Predicate> byExampleOnXToOne(ManagedType<T> mt, Root<T> mtPath, T mtValue,
                                                                                                      SearchParameters sp, CriteriaBuilder builder) {
        List<Predicate> predicates = newArrayList();
        for (SingularAttribute<? super T, ?> attr : mt.getSingularAttributes()) {
            if (attr.getPersistentAttributeType() == MANY_TO_ONE || attr.getPersistentAttributeType() == ONE_TO_ONE) {
                M2O m2oValue = (M2O) jpaUtil.getValue(mtValue, mt.getAttribute(attr.getName()));
                Class<M2O> m2oType = (Class<M2O>) attr.getBindableJavaType();
                Path<M2O> m2oPath = (Path<M2O>) mtPath.get(attr);
                ManagedType<M2O> m2oMt = em.getMetamodel().entity(m2oType);
                if (m2oValue != null) {
                    if (m2oValue.isIdSet()) { // we have an id, let's restrict only on this field
                        predicates.add(builder.equal(m2oPath.get("id"), m2oValue.getId()));
                    } else {
                        predicates.addAll(byExample(m2oMt, m2oPath, m2oValue, sp, builder));
                    }
                }
            }
        }
        return predicates;
    }
1248475
public void setFilteredValue(final java.util.List _filteredValue) {
        getStateHelper().put(PropertyKeys.filteredValue, _filteredValue);
    }
905056
@Override
	public Predicate generateJPAPredicate(CriteriaBuilder criteriaBuilder, Root<?> root) {
		
		// On retourne le predicat
		return criteriaBuilder.like(criteriaBuilder.lower(this.<String>buildPropertyPath(root, property)), value.toLowerCase());
	}
70624
public static PrefsTransform lookup(PrefsProperty property) {
		TypeMirror typeMirror = property.getElement().asType();

		TypeName typeName = typeName(typeMirror);
		return lookup(typeName);
	}
592869
public final void setFilterTree(Object[][] mxProperties)
    {
        if (this.getMessageReceiver() != null)
            this.getMessageReceiver().setNewFilterProperties(this, mxProperties, null);   // Update any remote copy of this.
        else
        	this.setNameValueTree(mxProperties);	// Rarely called (typically during initialization - before the receiver is set up)
    }
544876
private SelectorBuilderImpl singleValuePredicate(String field, String propertyValue,
      PredicateOperator operator) {
    Predicate predicate = new Predicate();
    predicate.setField(field);
    predicate.setOperator(operator);

    String[] values = new String[1];
    values[0] = propertyValue;
    predicate.setValues(values);

    this.predicates.add(predicate);

    return this;
  }
61526
static <S extends Storable> Filter<S> build(ChainedProperty<S> property,
                                                Filter<?> subFilter,
                                                boolean not)
    {
        if (property == null) {
            throw new IllegalArgumentException();
        }

        StorableProperty<?> joinProperty = property.getLastProperty();

        if (subFilter == null) {
            subFilter = Filter.getOpenFilter(joinProperty.getJoinedType());
        } else if (joinProperty.getJoinedType() != subFilter.getStorableType()) {
            throw new IllegalArgumentException
                ("Filter not compatible with join property type: " +
                 property + " joins to a " + joinProperty.getJoinedType().getName() +
                 ", but filter is for a " + subFilter.getStorableType().getName());
        }

        if (subFilter.isClosed()) {
            // Exists filter reduces to a closed (or open) filter.
            Filter<S> f = Filter.getClosedFilter(property.getPrimeProperty().getEnclosingType());
            return not ? f.not() : f;
        } else if (joinProperty.isQuery() || subFilter.isOpen()) {
            return getCanonical(property, subFilter, not);
        } else {
            // Convert to normal join filter.
            return subFilter.asJoinedFrom(property);
        }
    }
504416
public static <E> List<E> filter(final Iterable<E> iterable, final Predicate<E> pred) {
        final List<E> filtered = newArrayList();
        for (E element : iterable) {
            if (pred.test(element)) {
                filtered.add(element);
            }
        }
        return filtered;
    }
1162810
@SuppressWarnings("unchecked")
    public Set<QueryableEntry> query(Predicate predicate) {
        stats.incrementQueryCount();

        if (!haveAtLeastOneIndex() || !(predicate instanceof IndexAwarePredicate)) {
            return null;
        }

        IndexAwarePredicate indexAwarePredicate = (IndexAwarePredicate) predicate;
        QueryContext queryContext = queryContextProvider.obtainContextFor(this);
        if (!indexAwarePredicate.isIndexed(queryContext)) {
            return null;
        }

        Set<QueryableEntry> result = indexAwarePredicate.filter(queryContext);
        if (result != null) {
            stats.incrementIndexedQueryCount();
            queryContext.applyPerQueryStats();
        }

        return result;
    }
544705
function () {
				var oBinding = this.byId("tree").getBinding("items");
				if (this._sFilter) {
					oBinding.filter(new Filter({
						path: "name",
						operator: FilterOperator.Contains,
						value1: this._sFilter
					}));
					return true;
				} else {
					oBinding.filter();
					return false;
				}
			}