Package net.cscott.jutil

Interface Summary

Environment<K,V>	An Environment is a Map with scoping: you can save marks into the environment and undo all changes since a mark.
Environment.Mark	A abstract property for marks into an environment.
Heap<K,V>	Heaps support create, insert, minimum, extract-min, union, decrease-key, and delete operations.
InvertibleMap<K,V>	An InvertibleMap is an extension of the Map interface to allow users to do reverse lookups on the mappings maintained.
InvertibleMultiMap<K,V>	An InvertibleMultiMap is an extension of the MultiMap interface to allow users to do reverse lookups on the mappings maintained.
MapSet<K,V>	A MapSet is a Set of Map.Entrys which can also be accessed as a Map.
MultiMap<K,V>	MultiMap maps a key to a collection of values.
MultiMapSet<K,V>	A MultiMapSet is a Set of Map.Entrys which can also be accessed as a MultiMap.
ReferenceUnique	ReferenceUnique is a property indicating that, for all instances of a class, (a==b)==(a.equals(b)).

Class Summary

AbstractHeap<K,V>	AbstractHeap provides a skeletal implementation of the Heap interface, to minimize the effort required to implement this interface.
AbstractMapEntry<K,V>	An AbstractMapEntry takes care of most of the grunge work involved in subclassing Map.Entry.
AbstractMultiMap<K,V>	This class provides a skeletal implementation of the MultiMap interface, to minimize the effort requires to implement this interface.
AggregateMapFactory<K,V>	AggregateMapFactory uses a single HashMap as backing store for the many smaller Maps created by this MapFactory.
AggregateSetFactory<V>	AggregateSetFactory uses a single HashMap as backing store for the many smaller Sets created by this SetFactory.
BinaryHeap<K,V>	BinaryHeap is an implementation of a binary heap.
BinaryTree	A BinaryTree is a Tree where each node has at most two children.
BinomialHeap<K,V>	A BinomialHeap allows O(lg n) time bounds for insert, minimum, extract-min, union, decrease-key, and delete operations.
BitSetFactory<V>	BitSetFactory is a SetFactory that, given a complete universe of possible values, produces low space overhead representations of Sets.
BitString	BitString implements a vector of bits
CollectionFactory<V>	CollectionFactory is a Collection generator.
CollectionWrapper<E>	CollectionWrapper is a class that acts as a wrapper around another Collection, using it as its backing store.
CombineIterator<E>	A CombineIterator combines several different Iterators into one.
Default	Default contains one-off or 'standard, no-frills' implementations of simple Iterators, Collections, and Comparators.
Default.PairList<A,B>	Pairs, implemented as a List.
DisjointSet<E>	DisjointSet is an implementation of disjoint-set forests using the path compression and union-by-rank heuristics to achieve O(m * alpha(m, n)) runtime, where 'm' is the total number of operations, 'n' is the total number of elements in the set, and 'alpha' denotes the *extremely* slowly-growing inverse Ackermann function.
Factories	Factories consists exclusively of static methods that operate on or return CollectionFactorys.
FibonacciHeap<K,V>	A FibonacciHeap allows amortized O(1) time bounds for create, insert, minimum, union, and decrease-key operations, and amortized O(lg n) run times for extract-min and delete.
FilterIterator<A,B>	A FilterIterator filters and maps a source Iterator to generate a new one.
FilterIterator.Filter<A,B>
GenericInvertibleMap<K,V>	GenericInvertibleMap is a default implementation of InvertibleMap.
GenericInvertibleMultiMap<K,V>	GenericInvertibleMultiMap is a default implementation of InvertibleMultiMap.
GenericMultiMap<K,V>	GenericMultiMap is a default implementation of a MultiMap.
GenericMultiMapFactory<K,V>	GenericMultiMapFactory implements MultiMapFactory using instances of GenericMultiMap.
HashEnvironment<K,V>	A HashEnvironment is an Environment using a HashMap as the backing store.
Indexer<T>	Indexer is an object for extracting unique indices for a set of objects.
IntervalTree	An IntervalTree is a mutable collection of IntervalTree.Intervals.
IntervalTree.Interval	Immutable record representing a closed interval [low,high] holding an object obj.
IteratorEnumerator<E>	An IteratorEnumerator converts an Iterator into an Enumeration.
LinearMap<K,V>	LinearMap is a simplistic light-weight Map designed for use when the number of entries is small.
LinearSet<E>	LinearSet is a simplistic light-weight Set designed for use when the number of entries is small.
ListFactory<V>	ListFactory is a List generator.
ListWrapper<E>	ListWrapper is an abstract class designed to make it easier to write wrappers around Lists.
MapFactory<K,V>	MapFactory is a Map generator.
MapWrapper<K,V>	MapWrapper is a class that acts as a proxy for another backing map, to allow for easy extension of Map functionality while not restricting developers to one particular Map implementation.
MultiMapFactory<K,V>	MultiMapFactory is a MultiMap generator.
PairMapEntry<K,V>	PairMapEntry is the easiest implementation of a Map.Entry ever: a pair!
PersistentEnvironment<K,V>	PersistentEnvironment is an Environment built on a PersistentMap.
PersistentMap<K,V>	PersistentMap implements a persistent map, based on a persistent randomized treap.
PersistentMapFactory<K,V>	A PersistentMapFactory uses hash-consing to ensure that the Maps created by it maximally reuse space.
PersistentMultiMapFactory<K,V>	A PersistentMultiMapFactory uses hash-consing to ensure that the MultiMaps created by it maximally reuse space.
PersistentSet<T>	PersistentSet implements a persistent set, based on a persistent randomized treap.
PersistentSetFactory<T>	A PersistentSetFactory uses hash-consing to ensure that the Sets created by it maximally reuse space.
RedBlackTree	A RedBlackTree is a BinaryTree that uses red-black properties to maintain a balanced form.
ReverseIterator<E>	A ReverseIterator iterates through an Iterator in reverse order.
ReverseListIterator<E>	ReverseListIterator takes a List and gives you an Iterator that traverses the list in reverse order.
SetFactory<V>	SetFactory is a Set generator.
SetWrapper<E>	SetWrapper is analogous to CollectionWrapper, specialized for Sets.
SnapshotIterator<E>	A SnapshotIterator takes a "snapshot" of an iterator, and iterates over that snapshot.
UniqueStack<E>	The UniqueStack class represents a last-in-first-out stack of unique objects.
UniqueVector<E>	A unique vector refuses to addElement duplicates.
UnmodifiableIterator<E>	UnmodifiableIterator is an abstract superclass to save you the trouble of implementing the UnmodifiableIterator.remove() method over and over again for those iterators which don't implement it.
UnmodifiableListIterator<E>	UnmodifiableListIterator is an abstract superclass to save you the trouble of implementing the UnmodifiableListIterator.remove(), UnmodifiableListIterator.add(Object) and UnmodifiableListIterator.set(Object) methods over and over again for those list iterators which don't implement them.
UnmodifiableMap<K,V>	This wrapper for Maps implements Map.entrySet() so that it returns an UnmodifiableMapSet.
UnmodifiableMapSet<K,V>	UnmodifiableMapSet prevents mutation of a wrapped MapSet.
UnmodifiableMultiMap<K,V>	UnmodifiableMultiMap is an abstract superclass to save developers the trouble of implementing the various mutator methds of the MultiMap interface.
UnmodifiableMultiMapSet<K,V>	UnmodifiableMultiMapSet prevents mutation of a wrapped MultiMapSet.
Util	Miscellaneous static utility functions.
Version	The Version object contains fields naming the current version of the jutil library (1.4).
WorkSet<E>	Deprecated. Use LinkedHashSet instead.