|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Bag to provide additional behaviour.Trie functionality and
utility methods for actual bitwise Trie implementations.Trie using the given KeyAnalyzer.
Collection to provide additional behaviour.BidiMap implemented using two maps.createMap.
createBidiMap implementation.
IterableGet that uses a MapGetIterableMap implementation.KeyValue
and Map.Entry implementations.List to provide additional behaviour.Bag interface to simplify the creation
of subclass implementations.Map.Entry implementations.Map.Entry.Queue to provide additional behaviour.Set to provide additional behaviour.SortedBag to provide additional behaviour.SortedSet to provide additional behaviour.nCopies copies of the specified object to the Bag.
UnsupportedOperationException when this method is invoked.
UnsupportedOperationException
unless the underlying Iterator is a ListIterator.
UnsupportedOperationException when this method is invoked.
UnsupportedOperationException.
AbstractMapBag.add(Object) for each element in the given collection.
Iterable to the given collection.
Iterator to the iterators being collated.
value and inserts it after node.
value and inserts it before node.
Iterator over any array.ListIterator over an array.ArrayDeque instead (available from Java 1.6)ArrayStack.
ArrayStack with an initial size.
Iterable that wraps an iterator.
Runnable executes.
Bag and SortedBag instances.Comparator for Boolean objects that can sort either
true or false first.BooleanComparator that sorts
false values before true values.
BooleanComparator that sorts
trueFirst values before
!trueFirst values.
trueFirst values before
!trueFirst values.
Map.Closure that catches any checked exception and re-throws it as a
FunctorException runtime exception.Comparators, applied
in sequence until one returns not equal or the array is exhausted.
Comparators,
applied in (default iterator) sequence until one returns not equal or the
collection is exhausted.
Iterators
one after another.
Iterators
one after another.
Iterators
one after another.
setValue.
setValue.
setValue.
clear() on all composited Maps.
Map.clear() behavior with the addition of clearing all
expiration entries as well.
ClosureUtils provides reference implementations and utilities
for the Closure functor interface.Iterators.
Iterators.
Iterators.
CollatingIterator.
CollatingIterator that will used the
specified comparator for ordering.
CollatingIterator that will used the
specified comparator for ordering and have the specified initial
capacity.
CollatingIterator that will use the
specified comparator to provide ordered iteration over the two given
iterators.
CollatingIterator that will use the
specified comparator to provide ordered iteration over the array of
iterators.
CollatingIterator that will use the
specified comparator to provide ordered iteration over the collection of
iterators.
Collection instances.EditScript objects.Comparator that compares Comparable
objects.Comparator
objects.null Boolean objects
according to the value of BooleanComparator.sortsTrueFirst().
Comparable arguments.
Bag to comply with the Collection contract.set composited.
true if the bag contains all elements in
the given collection, respecting cardinality.
true iff all elements of coll2 are also contained
in coll1.
true iff at least one element is in both collections.
AbstractHashedMap to convert keys to
lower case.
Set with the same type as the provided set
and populate it with all elements of list.
AbstractLinkedList.LinkedListIterator.next() or AbstractLinkedList.LinkedListIterator.previous().
CursorableLinkedList.Cursor for iterating through the elements of this list.
CursorableLinkedList.Cursor for iterating through the elements of this list
starting from a specified index.
List implementation with a ListIterator that
allows concurrent modifications to the underlying list.ListIterator that allows concurrent changes to
the underlying list.Map returning a default value if the map
does not contain the requested key.DefaultedMap that decorates
a HashMap.
DefaultedMap that decorates a HashMap.
Equator implementation.null,
the value of defaultList.
KeyValue pair that does not implement
Map.Entry.KeyValue.
Map.Entry.
Map.Entry that prevents
the Map.Entry contract from being broken.KeyValue.
Map.Entry.
Collection containing the exclusive disjunction
(symmetric difference) of the given Iterables.
put() to work in the superclass.
put() to work in deserialization.
BidiMap that uses two HashMap instances.HashBidiMap.
HashBidiMap and copies the mappings from
specified Map.
HashBidiMap that decorates the specified maps.
BidiMap that uses two LinkedHashMap instances.HashBidiMap.
LinkedHashBidiMap and copies the mappings from
specified Map.
LinkedHashBidiMap that decorates the specified maps.
BidiMap that uses two TreeMap instances.DualTreeBidiMap
DualTreeBidiMap and copies the mappings from
specified Map.
DualTreeBidiMap using the specified Comparator.
DualTreeBidiMap that decorates the specified maps.
commands needed to transform
one objects sequence into another objects sequence.true if this stack is currently empty.
Bag.
null,
or the argument itself otherwise.
null,
or the argument itself otherwise.
null,
or the argument itself otherwise.
null,
or the argument itself otherwise.
Queue.
SortedBag.
after field from a LinkEntry.
before field from a LinkEntry.
hashCode field from a HashEntry.
key field from a HashEntry.
next field from a HashEntry.
MapIterator using a Map entrySet.value field from a HashEntry.
Enumeration instances appear
to be Iterator instances.EnumerationIterator that will not
function until EnumerationIterator.setEnumeration(Enumeration) is called.
EnumerationIterator that provides
an iterator view of the given enumeration.
EnumerationIterator that will remove
elements from the specified collection.
Enumeration instances.KeyAnalyzer.bitIndex(Object, int, int, Object, int, int) if key and found key are equal.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
true iff that Object is is a Comparator
whose ordering is known to be equivalent to mine.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
Map.Entry with another Map.Entry.
Map.Entry with another Map.Entry.
Map.Entry with another Map.Entry.
Object.equals(Object).
count times.
FactoryUtils provides reference implementations and utilities
for the Factory functor interface.Iterator using a predicate to filter elements.FilterIterator that will not function
until setIterator is invoked.
FilterIterator that will not function
until setPredicate is invoked.
FilterIterator that will use the
given iterator and predicate.
ListIterator using a predicate to filter elements.FilterListIterator that will not function
until setListIterator
and setPredicate are invoked.
FilterListIterator that will not
function until setPredicate is invoked.
FilterListIterator.
FilterListIterator that will not function
until setListIterator is invoked.
List to fix the size preventing add/remove.Map to fix the size, preventing add/remove.SortedMap to fix the size blocking add/remove.Map implementation that stores data in simple fields until
the size is greater than 3.count times.
FunctorException without specified
detail message.
FunctorException with specified
detail message.
FunctorException with specified
nested Throwable root cause.
FunctorException with specified
detail message and nested Throwable root cause.
index-th value in Iterator, throwing
IndexOutOfBoundsException if there is no such element.
index-th value in the iterable's Iterator, throwing
IndexOutOfBoundsException if there is no such element.
index-th value in object, throwing
IndexOutOfBoundsException if there is no such element or
IllegalArgumentException if object is not an
instance of one of the supported types.
index-th Map.Entry in the map's entrySet,
throwing IndexOutOfBoundsException if there is no such element.
Map interface.Map mapping each unique element in the given
Collection to an Integer representing the number
of occurrences of that element in the Collection.
Comparator by which collatation occurs.
false values before true values.
next().
next().
next().
next().
next().
KeyAnalyzer that constructed the Trie.
EditScript object.
true values before false values.
next().
next().
next().
next().
next().
List to make it seamlessly grow when
indices larger than the list size are used on add and set,
avoiding most IndexOutOfBoundsExceptions.Bag, using a HashMap to provide the
data storage.HashBag.
equals.
equals.
equals.
equals.
NullComparator.equals(Object).
equals.
equals.
null objects.
List.hashCode().
Set.hashCode().
Map implementation that is a general purpose alternative
to HashMap.true if any child iterator has remaining elements.
IndexedCollection.
readObject.
readObject.
StringKeyAnalyzer.
Collection containing the intersection of the given
Iterables.
Collections contain
exactly the same elements with exactly the same cardinalities.
Collections contain
exactly the same elements with exactly the same cardinalities.
List.equals(java.lang.Object).
equals() contract
in Set.equals(java.lang.Object).
Map interface.Map as an IterableMap.
SortedMap + OrderedMap.SortedMap as an IterableSortedMap.
Iterator over the entire set of members,
including copies due to cardinality.
MultiValueMap.
IteratorChain over the two given iterators.
IteratorChain over the array of iterators.
IteratorChain over the collection of
iterators.
Iterator instance appear to be an
Enumeration instance.IteratorEnumeration that will not function
until setIterator is invoked.
IteratorEnumeration that will use the given
iterator.
Iterator instance appear to be an
Iterable instance.IteratorIterable that will use the given
iterator.
IteratorIterable that will use the given
iterator.
Iterator
instances.Trie keys on a bit level.List to create objects in the list on demand.Map to create objects in the map on demand.SortedMap to create objects in the map on demand.Character.
Map implementation that maintains the order of the entries.Iterator into a ResettableListIterator.ListIteratorWrapper that will wrap
the given iterator.
Map to ensure that the order of addition is retained
using a List to maintain order.ListOrderedMap that decorates
a HashMap.
Set to ensure that the order of addition is
retained and used by the iterator.ListOrderedSet using a
HashSet and an ArrayList internally.
List instances.CharSequence objects.
Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.Map to obtain Set behaviour.MapIterator over the map.
MapIterator over the map.
MapIterator over the map.
MapIterator over the map.
A map iterator is an efficient way of iterating over maps. There is no need to access the entry set or use Map Entry objects.