|
JUtil | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
AbstractHeap provides a skeletal implementation of
the Heap interface, to minimize the effort required
to implement this interface.AbstractMapEntry takes care of most of the grunge
work involved in subclassing Map.Entry.MultiMap
interface, to minimize the effort requires to implement this interface.this contains an association from
key to value.
k and inserts it into this.
this contains an association from
key to value.
PersistentSet identical to
this one, except it contains element.
UnsupportedOperationException.
UnsupportedOperationException.
key to each value in values.
key to each value in values.
UnsupportedOperationException.
UnsupportedOperationException.
IntervalTree.Interval i and adds
i to this.
AggregateMapFactory uses a single HashMap
as backing store for the many smaller Maps created
by this MapFactory.AggregateMapFactory.
AggregateSetFactory uses a single HashMap
as backing store for the many smaller Sets created
by this SetFactory.AggregateSetFactory.
Iterator over IntervalTree.Intervals that
yields every interval in this that overlaps i.
ListFactory that generates
ArrayLists.
Map view of the disjoint
set, where every element is mapped to its canonical representative.
Collections view of the mapping.
Collections view of the set.
BinaryHeap is an implementation of a binary heap.BinaryHeap, which will
use the keys' natural order.
BinaryHeap with the
specified comparator.
Map.Entrys
and a key comparator.
BinaryTree is a Tree where each node has
at most two children.c to determine
element ordering.
BinaryTree.Node is an element of this tree.BinomialHeap allows
O(lg n) time bounds for insert, minimum, extract-min, union,
decrease-key, and delete operations.BinomialHeap, sorted according
to the keys' natural order.
BinomialHeap, sorted according
to the given comparator.
Heap.
Map.Entrys and a key comparator.
BitSetFactory is a SetFactory that,
given a complete universe of possible values, produces low space
overhead representations of Sets.BitSetFactory, given a
universe of values and an Indexer
for the elements of universe.
BitSetFactory, given a
universe of values.
BitString implements a vector of bits
BitString(int) -
Constructor for class net.cscott.jutil.BitString
Heap.
UnsupportedOperationException.
CollectionFactory is a Collection
generator.CollectionFactory.
CollectionWrapper is a class that acts as a wrapper
around another Collection, using it as its backing store.CollectionWrapper.
CombineIterator combines several different
Iterators into one.CombineIterator from an array of Iterators.
CombineIterator from a pair of
Iterators.
CombineIterator from three
Iterators.
CombineIterator from an
Iterator over Iterators.
Heap,
or null if the keys' natural ordering is used.
Comparator for objects that implement
Comparable (checked dynamically at run-time).
Comparator for objects that implement
Comparable (checked dynamically at run-time).
Heap,
or null if it uses its elements' natural ordering.
List view of
the list made from connecting lists together in
order.
k is present in this.
o.
a has a mapping to b
in this.
a has a mapping to b
in this.
true if this map contains a mapping for the
specified key.
true if this map contains a mapping for the
specified key.
key.
Default contains one-off or 'standard, no-frills'
implementations of simple Iterators,
Collections, and Comparators.List.z out from this.
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.DisjointSet.
Map.Entrys
in this Heap.
Set
views of Maps and MultiMaps.
Map.Entrys.
Set returned by this method is actually an
instance of MultiMapSet.
Set returned by this method is really a
MapSet.
Set view that allows you to recapture
the MultiMap view.
Set view that allows you to recapture
the MultiMap view.
MapFactory that generates EnumMaps.
SetFactory that generates EnumSets.
Environment is a Map with scoping:
you can save marks into the environment and undo all changes
since a mark.Factories consists exclusively of static methods that
operate on or return CollectionFactorys.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.FibonacciHeap, sorted according
to its keys' natural order.
FibonacciHeap, sorted according
to the given Comparator.
Heap.
Map.Entrys and a key comparator.
FilterIterator filters and maps a source
Iterator to generate a new one.FilterIterator.
Map.Entry in the heap with key equal to
the specified key.
o.
where in the
bit string which is set, or -1 if there is no such index.
GenericInvertibleMap is a default implementation of
InvertibleMap.mf and an inverted map constructed by
mmf.
GenericInvertibleMultiMap is a default implementation of
InvertibleMultiMap.GenericMultiMap is a default implementation of a
MultiMap.MultiMap using a HashMap for
the map and HashSets for the value collections.
MultiMap using a HashMap for
the map and the specified CollectionFactory to
create the value collections.
MultiMap using the specified
MapFactory to create the map and the specified
CollectionFactory to create the value collections.
GenericMultiMapFactory implements MultiMapFactory
using instances of GenericMultiMap.GenericMultiMapFactory, specifying
the MapFactory and CollectionFactory
to be used by the underlying GenericMultiMap.
GenericMultiMapFactory, using a
HashMap factory for the map and an
AggregateSetFactory for the value collections.
key maps to.
getID.
o in this.
key.
key.
BitString.
HashEnvironment is an Environment using
a HashMap as the backing store.HashEnvironment.
HashEnvironment with all the mappings in
the given map.
MapFactory that generates HashMaps.
SetFactory that generates HashSets.
true if the iteration has more elements.
true if the list iterator has more elements
in the forward direction.
true if the list iterator has more elements
in the reverse direction.
Heaps support create, insert, minimum, extract-min,
union, decrease-key, and delete operations.Indexer implements
the getByID() method.
Indexer is an object for extracting unique indices
for a set of objects.equals method.
index, and testing for equality using the
equals method.
Map.Entry,
which is not currently in the Heap, into the
Heap.
Heap.
index.
this.
IntervalTree is a mutable collection
of IntervalTree.Intervals.IntervalTree.
low,high] holding an object
obj.this.
this.
this.
this.
InvertibleMap is an extension of the
Map interface to allow users to do reverse lookups on
the mappings maintained.InvertibleMultiMap is an extension of the
MultiMap interface to allow users to do reverse lookups on
the mappings maintained.true if the specified element should be
included in the filtered enumeration.
true if this map contains no key-value mappings.
true if this Heap has no more
entries.
true if this map contains no key-value mappings.
PersistentMap has any mappings.
PersistentSet has any members.
IteratorEnumerator converts an Iterator
into an Enumeration.IteratorEnumerator.
Heap.
UnsupportedOperationException.
where in the
bit string which is set, or -1 if there is no such index.
BitString: the
index of the highest set bit in the BitString plus
one.
LinearMap is a simplistic light-weight
Map designed for use when the number of entries is
small.LinearMap.
LinearMap with specified capacity.
LinearSet is a simplistic light-weight
Set designed for use when the number of entries is
small.LinearSet.
LinearSet with given capacity.
LinearSet, filling it with the elements
of set.
LinearSet, filling it with the elements
of the given collection.
LinearSet, using a
List generated by lf as the backing
store.
LinearSet with a given capacity,
using a List generated by lf as the
backing store.
LinearSet, using a
List generated by lf as the backing
store, and fills it with the elements of set.
SetFactory that generates
LinearSets backed by ArrayLists.
MapFactory that generates LinkedHashMaps.
SetFactory that generates LinkedHashSets.
ListFactory that generates LinkedLists.
ListFactory is a List generator.ListFactory.
ListWrapper is an abstract class designed to make it easier
to write wrappers around Lists.ListWrapper.
Collection.
Collection, using
initialCapacity as a hint to use for the capacity
for the produced Collection.
Collection, using the
elements of c as a template for its initial
contents.
Set, using the elements
of the universe for this as its initial contents.
List.
List, using
initialCapacity as a hint to use for the capacity
for the produced List.
List, using the elements
of c as a template for its initial contents.
Map which is a
subset of the backing set of this
AggregateMapFactory.
Map.
Map, using the entries of
map as a template for its initial mappings.
Map which
is based on persistent randomized treaps.
GenericMultiMap.
MultiMap.
MultiMap initialized with all
of the Map.Entrys in map
MultiMap which
is based on persistent randomized treaps.
BinaryTree.Node n for this such that n.key == k.
IntervalTree.Interval.
RedBlackTree.RBNode.
Set which is a
subset of the backing set of this
AggregateSetFactory.
Set, using the elements
of c as a template for its initial contents.
Set which
is based on persistent randomized treaps.
Set.
Set, using
initialCapacity as a hint to use for the capacity
for the produced Set.
Set, using the elements
of c as a template for its initial contents.
MapFactory is a Map generator.MapFactory.
MapSet is a Set of
Map.Entrys which can also be accessed as a
Map.SetFactory that generates MapSet
views of maps generated by the given MapFactory.
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.this.
this.
MultiMap maps a key to a collection of values.MultiMapFactory is a MultiMap generator.MultiMapFactory.
MultiMapSet is a Set of
Map.Entrys which can also be accessed as a
MultiMap.SetFactory that generates
MultiMapSet views of MultiMaps
generated by the given MultiMapFactory.
UnmodifiableListIterator.next().
Iterator over the empty set.
Iterator over the empty set, parameterized to
play nicely with Java's type system.
PairMapEntry is the easiest implementation of a
Map.Entry ever: a pair!PairMapEntry.
WorkSet
(treating it as a Stack) without removing it
from the set/stack.
PersistentEnvironment is an Environment
built on a PersistentMap.PersistentEnvironment with no mappings.
PersistentEnvironment with the same
mappings as the given Map.
PersistentMap implements a persistent map, based on a
persistent randomized treap.PersistentMap whose
key objects will all implement Comparable.
PersistentMap whose
key objects are ordered by the given Comparator.
PersistentMapFactory uses hash-consing to ensure that
the Maps created by it maximally reuse space.PersistentMapFactory.
PersistentMultiMapFactory uses hash-consing to ensure that
the MultiMaps created by it maximally reuse space.PersistentMultiMapFactory.
PersistentSet implements a persistent set, based on a
persistent randomized treap.PersistentSet whose member objects
will all implement Comparable.
PersistentSet whose member objects
are ordered by the given Comparator.
PersistentSetFactory uses hash-consing to ensure that
the Sets created by it maximally reuse space.PersistentSetFactory.
WorkSet
(treating it as a Stack) and returns that object
as the value of this function.
UnmodifiableListIterator.previous().
UnmodifiableIterator from the given (potentailly
modifiable) Iterator.
MultiMap
backed by mmap.
WorkSet (treating
it as a Stack), if it is not already there.
PersistentMap identical to
this one, except it contains a mapping from key to
value.
- put(K, V) -
Method in class net.cscott.jutil.UnmodifiableMap
- Throws
UnsupportedOperationException.
- putAll(Map<? extends K, ? extends V>) -
Method in class net.cscott.jutil.AbstractMultiMap
- Copies the mappings from the specified map to this
map.
- putAll(Map<? extends K, ? extends V>) -
Method in class net.cscott.jutil.GenericInvertibleMap
-
- putAll(Map<? extends K, ? extends V>) -
Method in class net.cscott.jutil.GenericInvertibleMultiMap
-
- putAll(Map<? extends K, ? extends V>) -
Method in class net.cscott.jutil.MapWrapper
-
- putAll(Map<? extends K, ? extends V>) -
Method in interface net.cscott.jutil.MultiMap
- Copies the mappings from the specified map to this
map, after removing all old values associated with the key.
- putAll(PersistentMap<K, V>) -
Method in class net.cscott.jutil.PersistentMap
- Put all the mappings in the given map into this map, throwing
out conflicting mappings from this set as necessary.
- putAll(Map<? extends K, ? extends V>) -
Method in class net.cscott.jutil.UnmodifiableMap
- Throws
UnsupportedOperationException.
RedBlackTree is a BinaryTree that uses
red-black properties to maintain a balanced form.RedBlackTree.RBNode is an element of this tree.ReferenceUnique is a property indicating that, for
all instances of a class, (a==b)==(a.equals(b)).PersistentMap identical to this one,
except that it does not contain a mapping for key.
PersistentSet identical to this one,
except that it does not contain element.
UnsupportedOperationException.
UnsupportedOperationException.
UnsupportedOperationException.
UnsupportedOperationException.
key to any value in values.
key to any value in values.
UnsupportedOperationException.
key to any value not in values.
key to any value not in values.
UnsupportedOperationException.
ReverseIterator iterates through an Iterator
in reverse order.ReverseIterator of Iterator
it.
ReverseListIterator takes a List and gives
you an Iterator that traverses the list in reverse
order.ReverseListIterator.
IntervalTree.Interval in this which
overlaps the bounds defined by the argument interval
i, or null if no such interval
exists.
UnsupportedOperationException.
index of this vector
to be the specified object.
SetFactory is a Set generator.SetFactory.
Map.Entry to the given newkey.
SetWrapper is analogous to
CollectionWrapper, specialized for Sets.Collections.singletonList instead.
Iterator over a singleton set.
BitString to represent bit values.
Heap.
PersistentMap.
PersistentSet.
SnapshotIterator takes a "snapshot" of an iterator,
and iterates over that snapshot.SnapshotIterator from Iterator
it.
a and b
within this.
CollectionFactory that generates
synchronized (thread-safe) Collections.
ListFactory that generates synchronized
(thread-safe) Lists.
MapFactory that generates synchronized
(thread-safe) Maps.
SetFactory that generates synchronized
(thread-safe) Sets.
Heap.
SetFactory that generates TreeSets.
o1 and
o2, say S1 and S2, into a new set that is the
union of these two sets.
Heap
into this Heap.
UniqueStack class represents a last-in-first-out
stack of unique objects.UniqueStack.
UniqueStack containing the elements of
the specified Collection, in the order they are returned
by the collection's iterator in LIFO order.
Collection, in the order they are returned by the
collection's iterator.
unmodifiableCollection() class that
helps w/ covariant subtyping.
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 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.Maps implements Map.entrySet()
so that it returns an UnmodifiableMapSet.UnmodifiableMapSet prevents mutation of a wrapped
MapSet.UnmodifiableMultiMap is an abstract superclass to
save developers the trouble of implementing the various mutator
methds of the MultiMap interface.UnmodifiableMultiMapSet prevents mutation of a wrapped
MultiMapSet.Version object contains fields naming the current version
of the jutil library (1.4).LinkedHashSet instead.WorkSet with a default capacity
and load factor.
WorkSet with the specified
initial capacity and default load factor.
WorkSet with the specified
initial capacity and the specified load factor.
WorkSet with the contents of the
specified Collection.
SetFactory that generates WorkSets.
Collection here.
List here.
Set here.
MapSet here.
MultiMapSet here.
|
JUtil | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||