Uses of Interface
edu.rice.cs.plt.lambda.Predicate

Packages that use Predicate
edu.rice.cs.plt.collect Contains general-purpose extensions to and variations on the java.util collections framework. 
edu.rice.cs.plt.concurrent Contains tools to support safe multi-threaded programs. 
edu.rice.cs.plt.debug Defines a variety of logging classes, along with other facilities for code-embedded debugging. 
edu.rice.cs.plt.io Provides extensions to the java.io package, which provides character- and byte- based streams and buffers, files, file filters, and serialization. 
edu.rice.cs.plt.iter A collection of implementations of Iterable and Iterator
edu.rice.cs.plt.lambda A collection of interfaces facilitating first-class functions in Java. 
edu.rice.cs.plt.swing   
 

Uses of Predicate in edu.rice.cs.plt.collect
 

Subinterfaces of Predicate in edu.rice.cs.plt.collect
 interface FunctionalRelation<T1,T2>
          A functional relation: each first (of type T1) corresponds to at most one second (of type T2).
 interface InjectiveRelation<T1,T2>
          An injective relation: each second (of type T2) corresponds to at most one first (of type T1).
 interface OneToOneRelation<T1,T2>
          A injective functional relation: each first (of type T1) corresponds to at most one second (of type T2), and vice versa.
 interface PredicateSet<T>
          A Set that can be treated as a Predicate and as a SizedIterable.
 interface Relation<T1,T2>
          A set of pairs representing a binary relation.
 interface Relation3<T1,T2,T3>
          A set of triples representing a ternary relation.
 interface Relation4<T1,T2,T3,T4>
          A set of quads representing a quaternary relation.
 

Classes in edu.rice.cs.plt.collect that implement Predicate
 class AbstractFunctionalRelation<T1,T2>
          An abstract parent class for implementations of FunctionalRelation.
protected  class AbstractFunctionalRelation.InverseFunctionalRelation
          An inverse of the enclosing relation.
 class AbstractInjectiveRelation<T1,T2>
          An abstract parent class for implementations of InjectiveRelation.
protected  class AbstractInjectiveRelation.InverseInjectiveRelation
          An inverse of the enclosing relation.
protected  class AbstractKeyBasedMap.EntrySet
          An entry set defined in terms of the enclosing map's other methods.
 class AbstractOneToOneRelation<T1,T2>
          An abstract parent class for implementations of OneToOneRelation.
protected  class AbstractOneToOneRelation.InverseOneToOneRelation
          An inverse of the enclosing relation.
 class AbstractPredicateSet<T>
          An extension of AbstractSet that implements the PredicateSet interface.
 class AbstractRelation<T1,T2>
          An abstract parent class for implementations of Relation.
protected  class AbstractRelation.InverseRelation
          An inverse of the enclosing relation, defined in terms of Pair.inverse().
 class CartesianRelation<T1,T2>
          A Relation representing the cartesian (or cross) product of two sets.
 class ComplementRelation<T1,T2>
          The complement of a relation excluded in a domain domain (alternatively, domain - excluded), constructed lazily and updated dynamically.
 class ComplementSet<E>
          The complement of a set excluded in a domain domain (alternatively, domain - excluded), constructed lazily and updated dynamically.
 class ComposedRelation<T1,T2,T3>
          The transitive composition of two relations, lazily constructed and dynamically-updated.
 class DelegatingRelation<T1,T2>
          A relation that delegates all operations to a wrapped relation.
 class DelegatingSet<T>
          An implementation of PredicateSet that delegates all operations to a wrapped set.
 class EmptyRelation<T1,T2>
          An immutable, empty, one-to-one relation.
 class EmptySet<E>
          An immutable empty PredicateSet.
 class FilteredRelation<T1,T2>
          A relation that contains only those pairs contained by both the given relation and the given predicate.
 class FilteredSet<T>
          A set that contains only those elements contained by both the given set and the given predicate.
 class ImmutableRelation<T1,T2>
          Wraps a relation in an immutable interface.
 class ImmutableSet<T>
          Wraps a set in an immutable interface.
 class IndexedFunctionalRelation<T1,T2>
          An implementation of the FunctionalRelation interface based on indexing maps.
 class IndexedInjectiveRelation<T1,T2>
          A hash code-based implementation of the InjectiveRelation interface.
 class IndexedOneToOneRelation<T1,T2>
          A implementation of OneToOneRelation based on indexing maps.
 class IndexedRelation<T1,T2>
          An implementation of the Relation interface based on indexing maps.
 class IntersectionRelation<T1,T2>
          The intersection of two relations, lazily constructed and updated dynamically.
 class IntersectionSet<E>
          The intersection of two sets, lazily constructed and updated dynamically.
 class IterableSet<E>
          A Set wrapping an Iterable.
 class ListenerSet<T>
          A mutable set of listeners.
 class SingletonRelation<T1,T2>
          An immutable Relation containing a single pair.
 class SingletonSet<E>
          An immutable PredicateSet with a single element.
 class SnapshotSynchronizedSet<E>
          A synchronized set like Collections.synchronizedSet(java.util.Set), but one that returns a snapshot of the set contents on invocations of iterator().
 class UnindexedRelation<T1,T2>
          A mutable relation implemented by wrapping a set of pairs.
 class UnionRelation<T1,T2>
          The union of two relations, lazily constructed and updated dynamically.
 class UnionSet<E>
          The union of two sets, lazily constructed and updated dynamically.
 

Fields in edu.rice.cs.plt.collect declared as Predicate
protected  Predicate<? super T> FilteredSet._pred
           
 

Methods in edu.rice.cs.plt.collect with parameters of type Predicate
static
<T> ConsList<? extends T>
ConsList.filter(ConsList<? extends T> list, Predicate<? super T> pred)
          Filter the given list according to a predicate
static
<T> ConsVisitor<T,ConsList<T>>
ConsVisitor.filter(Predicate<? super T> pred)
          Filters a list to contain only those elements accepted by the given predicate
static
<T> PredicateSet<T>
CollectUtil.filter(Set<? extends T> set, Predicate<? super T> predicate)
          Lazily filter the given set.
 

Constructors in edu.rice.cs.plt.collect with parameters of type Predicate
FilteredSet(Set<? extends T> set, Predicate<? super T> predicate)
           
 

Uses of Predicate in edu.rice.cs.plt.concurrent
 

Methods in edu.rice.cs.plt.concurrent with parameters of type Predicate
 T StateMonitor.attemptEnsurePredicate(Predicate<? super T> predicate)
          Tries to ensure that predicate accepts the current state before continuing.
 T StateMonitor.attemptEnsurePredicate(Predicate<? super T> predicate, long timeout)
          Tries to ensure that predicate accepts the current state before continuing.
 T StateMonitor.attemptEnsurePredicate(Predicate<? super T> predicate, long timeout, TimeUnit unit)
          Tries to ensure that predicate accepts the current state before continuing.
 T StateMonitor.ensurePredicate(Predicate<? super T> predicate)
          Ensures that predicate accepts the current state before continuing.
 T StateMonitor.ensurePredicate(Predicate<? super T> predicate, long timeout)
          Ensures that predicate accepts the current state before continuing.
 T StateMonitor.ensurePredicate(Predicate<? super T> predicate, long timeout, TimeUnit unit)
          Ensures that predicate accepts the current state before continuing.
 

Uses of Predicate in edu.rice.cs.plt.debug
 

Methods in edu.rice.cs.plt.debug that return Predicate
static Predicate<LogSink.Message> FilteredLogSink.locationBlackListPredicate(String... prefixes)
          Produce a predicate that rejects any caller locations starting with the given prefixes.
static Predicate<LogSink.Message> FilteredLogSink.locationPredicate(Predicate<? super String> pred)
          Produce a predicate that accepts messages iff their caller location is accepted by pred.
static Predicate<LogSink.Message> FilteredLogSink.locationWhiteListPredicate(String... prefixes)
          Produce a predicate that accepts only caller locations starting with the given prefixes.
static Predicate<LogSink.Message> FilteredLogSink.stackDepthPredicate(int maxDepth)
          Produce a predicate that only accepts message with stack traces of at most the given depth.
static Predicate<LogSink.Message> FilteredLogSink.threadBlackListPredicate(String... nameParts)
          Produce a predicate that only accepts messages logged from threads matching the given names.
static Predicate<LogSink.Message> FilteredLogSink.threadBlackListPredicate(Thread... threads)
          Produce a predicate that only accepts messages logged from the given thread.
static Predicate<LogSink.Message> FilteredLogSink.threadPredicate(Predicate<? super ThreadSnapshot> pred)
          Produce a predicate that accepts messages iff their associated ThreadSnapshot is accepted by pred.
static Predicate<LogSink.Message> FilteredLogSink.threadWhiteListPredicate(String... nameParts)
          Produce a predicate that only accepts messages logged from threads matching the given names.
static Predicate<LogSink.Message> FilteredLogSink.threadWhiteListPredicate(Thread... threads)
          Produce a predicate that only accepts messages logged from the given thread.
 

Methods in edu.rice.cs.plt.debug with parameters of type Predicate
static FilteredLogSink FilteredLogSink.byLocation(LogSink delegate, Predicate<? super String> pred)
          Create a LogSink filtered by a FilteredLogSink.locationPredicate(edu.rice.cs.plt.lambda.Predicate).
static FilteredLogSink FilteredLogSink.byThread(LogSink delegate, Predicate<? super ThreadSnapshot> pred)
          Create a LogSink filtered by a FilteredLogSink.threadPredicate(edu.rice.cs.plt.lambda.Predicate).
static Predicate<LogSink.Message> FilteredLogSink.locationPredicate(Predicate<? super String> pred)
          Produce a predicate that accepts messages iff their caller location is accepted by pred.
static Predicate<LogSink.Message> FilteredLogSink.threadPredicate(Predicate<? super ThreadSnapshot> pred)
          Produce a predicate that accepts messages iff their associated ThreadSnapshot is accepted by pred.
 

Constructors in edu.rice.cs.plt.debug with parameters of type Predicate
FilteredLogSink(LogSink delegate, Predicate<? super LogSink.Message> pred)
           
 

Uses of Predicate in edu.rice.cs.plt.io
 

Subinterfaces of Predicate in edu.rice.cs.plt.io
 interface FilePredicate
          An object that is both a FileFilter and a Predicate<File>, for convenient use with code that requires one or the other.
 

Methods in edu.rice.cs.plt.io with parameters of type Predicate
static FilePredicate IOUtil.asFilePredicate(Predicate<? super File> p)
          Define a FileFilter in terms of a Predicate.
static File[] IOUtil.attemptListFiles(File f, Predicate<? super File> filter)
          Make a best attempt at invoking File.listFiles(FileFilter).
static SizedIterable<File> IOUtil.attemptListFilesAsIterable(File f, Predicate<? super File> filter)
          Similar to IOUtil.attemptListFiles(File, FileFilter), but returns a non-null Iterable rather than an array.
static SizedIterable<File> IOUtil.listFilesRecursively(File f, Predicate<? super File> filter)
          Produce a list of the recursive contents of a file.
static SizedIterable<File> IOUtil.listFilesRecursively(File f, Predicate<? super File> filter, Predicate<? super File> recursionFilter)
          Produce a list of the recursive contents of a file.
static SizedIterable<File> IOUtil.listFilesRecursively(File f, Predicate<? super File> filter, Predicate<? super File> recursionFilter)
          Produce a list of the recursive contents of a file.
 

Uses of Predicate in edu.rice.cs.plt.iter
 

Methods in edu.rice.cs.plt.iter with parameters of type Predicate
static
<T> boolean
IterUtil.and(Iterable<? extends T> iter, Predicate<? super T> pred)
          Check whether the given predicate holds for all values in iter.
static
<T> FilteredIterable<T>
IterUtil.filter(Iterable<? extends T> iter, Predicate<? super T> pred)
          Produce an iterable that only contains values from the given iterable that satisfy a predicate.
static
<T> SnapshotIterable<T>
IterUtil.filterSnapshot(Iterable<? extends T> iter, Predicate<? super T> pred)
          Produce an iterable that only contains values from the given iterable that satisfy a predicate.
static
<T> FilteredIterable<T>
FilteredIterable.make(Iterable<? extends T> iterable, Predicate<? super T> predicate)
          Call the constructor (allows T to be inferred)
static
<T> FilteredIterator<T>
FilteredIterator.make(Iterator<? extends T> i, Predicate<? super T> p)
          Call the constructor (allows T to be inferred)
static
<T> SnapshotIterable<T>
FilteredIterable.makeSnapshot(Iterable<? extends T> iterable, Predicate<? super T> predicate)
          Create a FilteredIterable and wrap it in a SnapshotIterable, forcing immediate evaluation of the filter.
static
<T> boolean
IterUtil.or(Iterable<? extends T> iter, Predicate<? super T> pred)
          Check whether the given predicate holds for some value in iter.
 

Constructors in edu.rice.cs.plt.iter with parameters of type Predicate
FilteredIterable(Iterable<? extends T> iterable, Predicate<? super T> predicate)
           
FilteredIterator(Iterator<? extends T> i, Predicate<? super T> p)
           
 

Uses of Predicate in edu.rice.cs.plt.lambda
 

Subinterfaces of Predicate in edu.rice.cs.plt.lambda
static interface LambdaUtil.GeneralPredicate
          An object that functions as a predicate for all arities.
 

Fields in edu.rice.cs.plt.lambda declared as Predicate
static Predicate<Object> LambdaUtil.IS_NULL
          A predicate that returns true iff the argument is null.
static Predicate<Object> LambdaUtil.NOT_NULL
          A predicate that returns true iff the argument is not null.
 

Methods in edu.rice.cs.plt.lambda that return Predicate
static
<T> Predicate<T>
LambdaUtil.and(Iterable<? extends Predicate<? super T>> preds)
          Produce the conjunction (&&) of the given predicates.
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2)
          Produce the conjunction (&&) of p1 and p2.
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the conjunction (&&) of p1, p2, and p3.
static
<T> Predicate<T>
LambdaUtil.asPredicate(Lambda<? super T,? extends Boolean> lambda)
          Create a predicate based on an input that acts as a predicate but is not typed as one.
static
<T1,T2> Predicate<T2>
LambdaUtil.bindFirst(Predicate2<? super T1,? super T2> pred, T1 arg1)
          Bind a fixed argument to the given binary predicate, producing a unary prediate.
static
<T1,T2> Predicate<T1>
LambdaUtil.bindSecond(Predicate2<? super T1,? super T2> pred, T2 arg2)
          Bind a fixed argument to the given binary predicate, producing a unary predicate.
static
<T> Predicate<T>
LambdaUtil.negate(Predicate<? super T> pred)
          Produce the negation (!) of pred.
static
<T> Predicate<T>
LambdaUtil.or(Iterable<? extends Predicate<? super T>> preds)
          Produce the disjunction (||) of the given predicates.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2)
          Produce the disjunction (||) of p1 and p2.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the disjunction (||) of p1, p2, and p3.
static Predicate<Null<?>> LambdaUtil.unary(Condition cond)
          Treat a Condition as a unary predicate accepting a 0-tuple argument.
static
<T1,T2> Predicate<Pair<T1,T2>>
LambdaUtil.unary(Predicate2<? super T1,? super T2> pred)
          Treat a Predicate2 as a unary predicate accepting a Pair argument.
static
<T1,T2,T3> Predicate<Triple<T1,T2,T3>>
LambdaUtil.unary(Predicate3<? super T1,? super T2,? super T3> pred)
          Treat a Predicate3 as a unary predicate accepting a Triple argument.
static
<T1,T2,T3,T4>
Predicate<Quad<T1,T2,T3,T4>>
LambdaUtil.unary(Predicate4<? super T1,? super T2,? super T3,? super T4> pred)
          Treat a Predicate4 as a unary predicate accepting a Quad argument.
 

Methods in edu.rice.cs.plt.lambda with parameters of type Predicate
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2)
          Produce the conjunction (&&) of p1 and p2.
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2)
          Produce the conjunction (&&) of p1 and p2.
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the conjunction (&&) of p1, p2, and p3.
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the conjunction (&&) of p1, p2, and p3.
static
<T> Predicate<T>
LambdaUtil.and(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the conjunction (&&) of p1, p2, and p3.
static
<T> Lambda<T,Boolean>
LambdaUtil.asLambda(Predicate<? super T> predicate)
          Create a Boolean lambda based on a predicate.
static
<T> Condition
LambdaUtil.bindFirst(Predicate<? super T> pred, T arg)
          Bind a fixed argument to the given predicate, producing a condition.
static
<T> Condition
LambdaUtil.flatten0(Predicate<? super Null<T>> pred)
          Treat a predicate accepting a 0-tuple argument as a Condition.
static
<T1,T2> Predicate2<T1,T2>
LambdaUtil.flatten2(Predicate<? super Pair<T1,T2>> pred)
          Treat a predicate accepting a Pair argument as a Predicate2.
static
<T1,T2,T3> Predicate3<T1,T2,T3>
LambdaUtil.flatten3(Predicate<? super Triple<T1,T2,T3>> pred)
          Treat a predicate accepting a Triple argument as a Predicate3.
static
<T1,T2,T3,T4>
Predicate4<T1,T2,T3,T4>
LambdaUtil.flatten4(Predicate<? super Quad<T1,T2,T3,T4>> pred)
          Treat a predicate accepting a Quad argument as a Predicate4.
static
<T> Predicate<T>
LambdaUtil.negate(Predicate<? super T> pred)
          Produce the negation (!) of pred.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2)
          Produce the disjunction (||) of p1 and p2.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2)
          Produce the disjunction (||) of p1 and p2.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the disjunction (||) of p1, p2, and p3.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the disjunction (||) of p1, p2, and p3.
static
<T> Predicate<T>
LambdaUtil.or(Predicate<? super T> p1, Predicate<? super T> p2, Predicate<? super T> p3)
          Produce the disjunction (||) of p1, p2, and p3.
static
<T> Predicate2<T,Object>
LambdaUtil.promote(Predicate<? super T> pred)
          Create a Predicate2 equivalent to pred with an additional, ignored argument.
static
<T,R> Lambda<T,Option<R>>
LambdaUtil.wrapPartial(Lambda<? super T,? extends R> lambda, boolean filterNull, Predicate<? super RuntimeException> filterException)
          Treat the given lambda as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".
static
<T1,T2,R> Lambda2<T1,T2,Option<R>>
LambdaUtil.wrapPartial(Lambda2<? super T1,? super T2,? extends R> lambda, boolean filterNull, Predicate<? super RuntimeException> filterException)
          Treat the given lambda as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".
static
<T1,T2,T3,R>
Lambda3<T1,T2,T3,Option<R>>
LambdaUtil.wrapPartial(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda, boolean filterNull, Predicate<? super RuntimeException> filterException)
          Treat the given lambda as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".
static
<T1,T2,T3,T4,R>
Lambda4<T1,T2,T3,T4,Option<R>>
LambdaUtil.wrapPartial(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, boolean filterNull, Predicate<? super RuntimeException> filterException)
          Treat the given lambda as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".
static
<R> Thunk<Option<R>>
LambdaUtil.wrapPartial(Thunk<? extends R> thunk, boolean filterNull, Predicate<? super RuntimeException> filterException)
          Treat the given thunk as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".
 

Method parameters in edu.rice.cs.plt.lambda with type arguments of type Predicate
static
<T> Predicate<T>
LambdaUtil.and(Iterable<? extends Predicate<? super T>> preds)
          Produce the conjunction (&&) of the given predicates.
static
<T> Predicate<T>
LambdaUtil.or(Iterable<? extends Predicate<? super T>> preds)
          Produce the disjunction (||) of the given predicates.
 

Uses of Predicate in edu.rice.cs.plt.swing
 

Methods in edu.rice.cs.plt.swing with parameters of type Predicate
static FileFilter SwingUtil.asSwingFileFilter(Predicate<? super File> p, String description)
          Define a Swing file filter (for use with JFileChoosers) in terms if a FileFilter.