Uses of Interface
edu.rice.cs.plt.object.Composite

Packages that use Composite

edu.rice.cs.plt.collect	Contains general-purpose extensions to and variations on the java.util collections framework.
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.

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

Classes in edu.rice.cs.plt.collect that implement Composite

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	ComposedMap<K,X,V> The transitive composition of two maps, lazily constructed and dynamically-updated.
class	ConsList<T> A Lisp- or Scheme-style immutable list.
static class	ConsList.Empty<T> The empty variant of a ConsList.
static class	ConsList.Nonempty<T> The nonempty variant of a ConsList.
class	DelegatingCollection<T> A collection that delegates all operations to a wrapped collection.
class	DelegatingList<E> An implementation of List that delegates all operations to a wrapped list.
class	DelegatingMap<K,V> A map that delegates all operations to a wrapped map.
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	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	ImmutableCollection<T> Wraps a collection in an immutable interface.
class	ImmutableMap<K,V> Wraps a map in an immutable interface.
class	ImmutableMapEntry<K,V> An implementation of Map.Entry that does not support the ImmutableMapEntry.setValue(V) operation; all other methods are delegated to a wrapped Entry.
class	ImmutableRelation<T1,T2> Wraps a relation in an immutable interface.
class	ImmutableSet<T> Wraps a set in an immutable interface.
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	IterableCollection<E> A Collection wrapping an Iterable.
class	IterableSet<E> A Set wrapping an Iterable.
class	ListenerSet<T> A mutable set of listeners.
class	MappedMap<K,X,V> A map whose value set is translated by a mapping lambda.
class	SnapshotSynchronizedList<E> A synchronized list like Collections.synchronizedList(java.util.List), but one that returns a snapshot of the list contents on invocations of iterator().
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	UnionMap<K,V> A lazily-constructed and dynamically-updated union of two maps.
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.

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

Classes in edu.rice.cs.plt.debug that implement Composite

class

SplitLogSink A log sink that sends messages to all the sinks it contains.

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

Classes in edu.rice.cs.plt.io that implement Composite

class	OutputStreamSplitter An output stream that allows sending the same data to an arbitrary number of streams.
class	WrappedDirectInputStream An implementation of DirectInputStream that inherits that class's default implementations and delegates all other operations to the wrapped InputStream.
class	WrappedDirectOutputStream An implementation of DirectOutputStream that inherits that class's default implementations and delegates all other operations to the wrapped OutputStream.
class	WrappedDirectReader An implementation of DirectReader that inherits that class's default implementations and delegates all other operations to the wrapped Reader.
class	WrappedDirectWriter An implementation of DirectWriter that inherits that class's default implementations and delegates all other operations to the wrapped Writer.
class	WriterSplitter A writer that allows sending the same data to an arbitrary number of writers.

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

Classes in edu.rice.cs.plt.iter that implement Composite

class	BinaryMappedIterable<T1,T2,R> An Iterable containing the results of some binary operation on two input lists (assumed to always have the same size).
class	BinaryMappedIterator<T1,T2,R> An Iterator that applies a provided mapping lambda to each corresponding member of two source iterators.
class	CartesianIterable<T1,T2,R> Enumerates the elements of a cartesian (or cross) product.
class	CartesianIterator<T1,T2,R> Enumerates the elements of a cartesian (or cross) product.
class	CollapsedIterable<T> Collapses a list of lists into a single list.
class	CollapsedIterator<T> An iterator over an arbitrary number of iterators.
class	ComposedIterable<T> Defines an iterable by composing two other iterables (or a value with an iterable).
class	ComposedIterator<T> Defines an iterator by composing two other iterators.
class	DiagonalCartesianIterable<T1,T2,R> Enumerates the elements of a cartesian (or cross) product in diagonal order.
class	DiagonalCartesianIterator<T1,T2,R> Enumerates the elements of a cartesian (or cross) product in diagonal order.
class	FilteredIterable<T> An Iterable containing all the values in the provided Iterable for which the provided Predicate holds.
class	FilteredIterator<T> An Iterator that only returns the values in another Iterator (i) for which some predicate (p) holds.
class	FiniteSequenceIterable<T> An iterable representing a finite sequence.
class	ImmutableIterable<T> Wraps an iterable in an immutable interface, thus allowing internal data structures to be treated by clients as iterables without allowing access (via casting) to their mutating methods.
class	ImmutableIterator<T> Wraps an iterator in an immutable interface, preventing modifications to underlying data structures via ReadOnlyIterator.remove().
class	MappedIterable<S,T> An Iterable containing all the values in the provided Iterable after applying some specified transformation.
class	MappedIterator<S,T> An Iterator that applies a provided mapping lambda to each member of a source iterator.
class	NoDuplicatesIterator<T> An Iterator that returns each value only once.
class	PermutationIterable<T> An enumeration of all permutations of the given list.
class	RemoveNotificationIterator<T> An iterator that notifies a callback whenever an element is removed.
class	SkipFirstIterable<T> Contains all but the first element of a wrapped iterable.
class	SkipLastIterable<T> Contains all but the last element of a wrapped iterable.
class	SkipLastIterator<T> An iterator that skips the last element of a nested iterator.
class	TruncatedIterable<T> Contains, for some value size, the first size elements of a nested iterable.
class	TruncatedIterator<T> Truncates a given iterator to have at most size elements.