Package harpoon.Util.Collections

Provides the classes for working with and generating Collections of Objects.

See:
          Description

Interface Summary
Environment 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 Heaps support create, insert, minimum, extract-min, union, decrease-key, and delete operations.
InvertibleMap An InvertibleMap is an extension of the Map interface to allow users to do reverse lookups on the mappings maintained.
InvertibleMultiMap An InvertibleMultiMap is an extension of the MultiMap interface to allow users to do reverse lookups on the mappings maintained.
MapSet A MapSet is a java.util.Set of Map.Entrys which can also be accessed as a java.util.Map.
MultiMap MultiMap maps a key to a collection of values.
MultiMapSet A MultiMapSet is a java.util.Set of Map.Entrys which can also be accessed as a MultiMap.
 

Class Summary
AbstractHeap AbstractHeap provides a skeletal implementation of the Heap interface, to minimize the effort required to implement this interface.
AbstractMapEntry An AbstractMapEntry takes care of most of the grunge work involved in subclassing java.util.Map.Entry.
AggregateMapFactory AggregateMapFactory uses a single HashMap as backing store for the many smaller Maps created by this MapFactory.
AggregateSetFactory AggregateSetFactory uses a single HashSet as backing store for the many smaller Sets created by this SetFactory.
BinaryHeap BinaryHeap is an implementation of a binary heap.
BinaryTree A BinaryTree is a Tree where each node has at most two children.
BinomialHeap A BinomialHeap allows O(lg n) time bounds for insert, minimum, extract-min, union, decrease-key, and delete operations.
BitSetFactory BitSetFactory is a SetFactory that, given a complete universe of possible values, produces low space overhead representations of Sets.
CollectionFactory CollectionFactory is a Collection generator.
CollectionWrapper CollectionWrapper is a class that acts as a wrapper around another Collection, using it as its backing store.
DisjointSet 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 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.
GenericInvertibleMap GenericInvertibleMap is a default implementation of InvertibleMap.
GenericInvertibleMultiMap GenericInvertibleMultiMap is a default implementation of InvertibleMultiMap.
GenericMultiMap GenericMultiMap is a default implementation of a MultiMap.
HashEnvironment A HashEnvironment is an Environment using a HashMap as the backing store.
IntervalTree An IntervalTree is a mutable collection of Intervals.
IntervalTree.Interval Immutable record representing a closed interval [low,high] holding an object obj.
LinearMap LinearMap is a simplistic light-weight Map designed for use when the number of entries is small.
LinearSet LinearSet is a simplistic light-weight Set designed for use when the number of entries is small.
ListFactory ListFactory is a List generator.
ListWrapper ListWrapper
MapFactory MapFactory is a Map generator.
MapWrapper 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.Factory MultiMap.Factory is a MultiMap generator.
PairMapEntry PairMapEntry is the easiest implementation of a Map.Entry ever: a pair! Basically saves coders the drugery of writing an inner class at the expense of an import statement.
PersistentEnvironment PersistentEnvironment is an Environment built on a PersistentMap.
PersistentMap PersistentMap implements a persistent map, based on a binary search tree.
PersistentSet PersistentSet implements a persistent set, based on a binary search tree.
RedBlackTree A RedBlackTree is a BinaryTree that uses red-black properties to maintain a balanced form.
SetFactory SetFactory is a Set generator.
SetWrapper SetWrapper is analogous to CollectionWrapper, specialized for Sets.
UniqueStack The UniqueStack class represents a last-in-first-out stack of unique objects.
UniqueVector A unique vector refuses to addElement duplicates.
UnmodifiableMultiMap UnmodifiableMultiMap is an abstract superclass to save developers the trouble of implementing the various mutator methds of the MultiMap interface.
WorkSet 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.
 

Package harpoon.Util.Collections Description

Provides the classes for working with and generating Collections of Objects. The purpose of the harpoon.Util.Collections package is to collect together all of our Collections-related classes. One key portion of the Collections package are the various Collection factories, which are designed to allow code to parameterize which type of Collection it will use internally.

Collection-related classes in harpoon.Util will eventually be migrated into this package so that all Collections-related code is kept together.

Related Documentation

For further information, see:

Author:
Felix Klock (pnkfelix@mit.edu)