Package net.cscott.jutil

package net.cscott.jutil

Class	Description
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<K>	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	Deprecated. Use BitSet, which grows as needed: firstSet(where) is nextSetBit(where+1), and lastSet(where) is previousSetBit(where-1); setUpTo(bit) is set(0, bit+1), and clearUpTo(bit) is clear(0, bit+1); setAll() is set(0, n) for a size n; clearAll() is clear(); intersectionEmpty(o) is !intersects(o); isZero() is isEmpty(); copyBits(o) is clear() then or(o); numberOfOnes() is cardinality(), and numberOfOnes(where) is get(0, where+1).cardinality(); or_upTo(o, bit) is or(o.get(0, bit+1)).
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>	Deprecated. Use Pair, an immutable record whose Pair.left() and Pair.right() replace the methods of the same name.
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.
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 mark into an environment.
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: it returns map.apply(o) for each element o of the source for which filter.test(o) is true.
FilterIterator.Filter<A,B>	Deprecated. Use a Predicate and a Function, which can be lambdas, with FilterIterator(Iterator,Predicate,Function), FilterIterator.filter(Iterator,Predicate) or FilterIterator.map(Iterator,Function).
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.
Heap<K,V>	Heaps support create, insert, minimum, extract-min, union, decrease-key, and delete operations.
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.
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.
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.
MapSet<K,V>	A MapSet is a Set of Map.Entrys which can also be accessed as a Map.
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.
MultiMap<K,V>	MultiMap maps a key to a collection of values.
MultiMapFactory<K,V>	MultiMapFactory is a MultiMap generator.
MultiMapSet<K,V>	A MultiMapSet is a Set of Map.Entrys which can also be accessed as a MultiMap.
Pair<A,B>	An immutable pair of values, either of which may be null.
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<K>	A RedBlackTree is a BinaryTree that uses red-black properties to maintain a balanced form.
ReferenceUnique	ReferenceUnique is a property indicating that, for all instances of a class, (a==b)==(a.equals(b)).
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>	Deprecated. Implement Iterator instead: its default remove() method throws UnsupportedOperationException.
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 (2.0).
WorkSet<E>	Deprecated. Use LinkedHashSet instead.