Uses of Package
edu.rice.cs.plt.collect

Packages that use edu.rice.cs.plt.collect

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.tuple	Classes for the type-parameterized representation of tuples.

Classes in edu.rice.cs.plt.collect used by edu.rice.cs.plt.collect

AbstractFunctionalRelation
An abstract parent class for implementations of FunctionalRelation.

AbstractFunctionalRelation.InverseFunctionalRelation
An inverse of the enclosing relation.

AbstractInjectiveRelation
An abstract parent class for implementations of InjectiveRelation.

AbstractKeyBasedMap
An abstract parent class for Map implementations that defines its operations in terms of the key-based methods get() and keySet().

AbstractOneToOneRelation
An abstract parent class for implementations of OneToOneRelation.

AbstractPredicateSet
An extension of AbstractSet that implements the PredicateSet interface.

AbstractRelation
An abstract parent class for implementations of Relation.

AbstractRelation.InverseRelation
An inverse of the enclosing relation, defined in terms of Pair.inverse().

ConsList
A Lisp- or Scheme-style immutable list.

ConsList.Empty
The empty variant of a ConsList.

ConsList.Nonempty
The nonempty variant of a ConsList.

ConsVisitor
A visitor for ConsLists.

DelegatingCollection
A collection that delegates all operations to a wrapped collection.

DelegatingList
An implementation of List that delegates all operations to a wrapped list.

DelegatingRelation
A relation that delegates all operations to a wrapped relation.

DelegatingSet
An implementation of PredicateSet that delegates all operations to a wrapped set.

EmptyCollection
Abstract parent class of immutable empty collections.

EmptyMap
An empty LambdaMap.

EmptyRelation
An immutable, empty, one-to-one relation.

EmptySet
An immutable empty PredicateSet.

ExternallySortedMultiMap
Maps from a key to a set of values; a key may be added multiple times with different values, and those values are collected in a set.

ExternallySortedSet
A container class that almost implements the SortedSet interface; the difference is that add() takes two parameters -- an element, along with a corresponding Comparable that will be used to sort the set.

FilteredRelation
A relation that contains only those pairs contained by both the given relation and the given predicate.

FilteredSet
A set that contains only those elements contained by both the given set and the given predicate.

FunctionalRelation
A functional relation: each first (of type T1) corresponds to at most one second (of type T2).

ImmutableCollection
Wraps a collection in an immutable interface.

ImmutableMap
Wraps a map in an immutable interface.

ImmutableMapEntry
An implementation of Map.Entry that does not support the ImmutableMapEntry.setValue(V) operation; all other methods are delegated to a wrapped Entry.

ImmutableRelation
Wraps a relation in an immutable interface.

ImmutableSet
Wraps a set in an immutable interface.

IndexedFunctionalRelation
An implementation of the FunctionalRelation interface based on indexing maps.

IndexedInjectiveRelation
A hash code-based implementation of the InjectiveRelation interface.

IndexedOneToOneRelation
A implementation of OneToOneRelation based on indexing maps.

IndexedRelation
An implementation of the Relation interface based on indexing maps.

InjectiveRelation
An injective relation: each second (of type T2) corresponds to at most one first (of type T1).

LambdaMap
A Map that can be treated as a Lambda.

ListenerSet
A mutable set of listeners.

ListenerSet.Sink
A write-only view of the set.

Multiset
A set-like collection that allows multiple instances of a value to be represented in the collection.

OneToOneRelation
A injective functional relation: each first (of type T1) corresponds to at most one second (of type T2), and vice versa.

Order
A reflexive, transitive relation, represented as a predicate.

PredicateSet
A Set that can be treated as a Predicate and as a SizedIterable.

Relation
A set of pairs representing a binary relation.

Relation3
A set of triples representing a ternary relation.

RelationIndex
Maintains an index mapping values of one type to sets of another.

SingletonMap
An immutable LambdaMap containing a single entry.

SingletonRelation
An immutable Relation containing a single pair.

SingletonSet
An immutable PredicateSet with a single element.

SnapshotSynchronizedList
A synchronized list like Collections.synchronizedList(java.util.List), but one that returns a snapshot of the list contents on invocations of iterator().

SnapshotSynchronizedSet
A synchronized set like Collections.synchronizedSet(java.util.Set), but one that returns a snapshot of the set contents on invocations of iterator().

TotalMap
A map that is defined for all values in the domain K.

TotalOrder
A Comparator that implements Order.

UnindexedRelation
A mutable relation implemented by wrapping a set of pairs.

Classes in edu.rice.cs.plt.collect used by edu.rice.cs.plt.concurrent

ListenerSet.Sink
A write-only view of the set.

Classes in edu.rice.cs.plt.collect used by edu.rice.cs.plt.tuple

TotalOrder
A Comparator that implements Order.