net.cscott.jutil (JUtil 1.1 documentation)

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>	`Heap`s 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 `java.util.Set` of `Map.Entry`s which can also be accessed as a `java.util.Map`.
MultiMap<K,V>	`MultiMap` maps a key to a collection of values.
MultiMapSet<K,V>	A `MultiMapSet` is a `java.util.Set` of `Map.Entry`s 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))`.

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 java.util.Set of Map.Entrys which can also be accessed as a java.util.Map.

MultiMap<K,V>

MultiMap maps a key to a collection of values.

MultiMapSet<K,V>

A MultiMapSet is a java.util.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 `java.util.Map.Entry`.
AggregateMapFactory<K,V>	`AggregateMapFactory` uses a single `HashMap` as backing store for the many smaller `Map`s created by this `MapFactory`.
AggregateSetFactory<V>	`AggregateSetFactory` uses a single `HashMap` as backing store for the many smaller `Set`s 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.
BinaryTree.Node	A `Node` is an element of this tree.
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 `Set`s.
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 `Iterator`s into one.
Default	`Default` contains one-off or 'standard, no-frills' implementations of simple `Iterator`s, `Collection`s, and `Comparator`s.
Default.PairList<A,B>
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 `CollectionFactory`s.
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`.
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 `Interval`s.
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`
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 `PersistentMap`s 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 `PersistentSet`s created by it maximally reuse space.
RedBlackTree	A `RedBlackTree` is a `BinaryTree` that uses red-black properties to maintain a balanced form.
RedBlackTree.RBNode	A `RBNode` is an element of this tree.
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 `Set`s.
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 `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 `remove()`, `add()` and `set()` methods over and over again for those list iterators which don't implement them.
UnmodifiableMultiMap<K,V>	`UnmodifiableMultiMap` is an abstract superclass to save developers the trouble of implementing the various mutator methds of the `MultiMap` interface.
Util	Miscellaneous static utility functions.
Version	The `Version` object contains fields naming the current version (1.1) of the JUtil library.
WorkSet<E>	A `WorkSet` is a `Set` offering constant-time access to the first/last element inserted, and an iterator whose speed is not dependent on the total capacity of the underlying hashtable.

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 java.util.Map.Entry.

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.

BinaryTree.Node

A Node is an element of this tree.

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>

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.

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 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

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 PersistentMaps 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 PersistentSets created by it maximally reuse space.

RedBlackTree

A RedBlackTree is a BinaryTree that uses red-black properties to maintain a balanced form.

RedBlackTree.RBNode

A RBNode is an element of this tree.

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 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 remove(), add() and set() methods over and over again for those list iterators which don't implement them.

UnmodifiableMultiMap<K,V>

UnmodifiableMultiMap is an abstract superclass to save developers the trouble of implementing the various mutator methds of the MultiMap interface.

Util

Miscellaneous static utility functions.

Version

The Version object contains fields naming the current version (1.1) of the JUtil library.

WorkSet<E>

A WorkSet is a Set offering constant-time access to the first/last element inserted, and an iterator whose speed is not dependent on the total capacity of the underlying hashtable.