All Classes and Interfaces
Class
Description
Decorates another
Bag to provide additional behaviour.Provides a base decorator that enables additional functionality to be added
to a BidiMap via decoration.
A basic implementation of
Map.Entry.Decorates another
Collection to provide additional behaviour.Abstract
BidiMap implemented using two maps.Inner class MapIterator.
Inner class EntrySet.
Inner class EntrySetIterator.
Inner class KeySet.
Inner class KeySetIterator.
Inner class MapEntry.
Inner class Values.
Inner class ValuesIterator.
Inner class View.
Provides an implementation of an empty iterator.
Provides an implementation of an empty map iterator.
An abstract implementation of a hash-based map which provides numerous points for
subclasses to override.
EntrySet implementation.
EntrySet iterator.
HashEntry used to store the data.
Base Iterator
MapIterator implementation.
KeySet implementation.
KeySet iterator.
Values implementation.
Values iterator.
An abstract base class that simplifies the task of creating map decorators.
Provide a basic
IterableMap implementation.Provides basic behaviour for decorating an iterator with extra functionality.
Abstract pair class to assist with creating
KeyValue
and Map.Entry implementations.An abstract implementation of a linked list which provides numerous points for
subclasses to override.
A list iterator over the linked list.
The sublist implementation for AbstractLinkedList.
A list iterator over the linked sub list.
A node within the linked list.
An abstract implementation of a hash-based map that links entries to create an
ordered map and which provides numerous points for subclasses to override.
EntrySet iterator.
KeySet iterator.
LinkEntry that stores the data.
Base Iterator that iterates in link order.
MapIterator implementation.
Values iterator.
Decorates another
List to provide additional behaviour.Provides basic behaviour for decorating a list iterator with extra functionality.
Abstract implementation of the
ListValuedMap interface to simplify
the creation of subclass implementations.Abstract implementation of the
Bag interface to simplify the creation
of subclass implementations.Inner class iterator for the Bag.
Mutable integer class for storing the data.
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
Abstract Pair class to assist with creating correct
Map.Entry implementations.Provides a base decorator that allows additional functionality to be
added to a
Map.Entry.Provides basic behaviour for decorating a map iterator with extra functionality.
Abstract implementation of the
MultiSet interface to simplify the
creation of subclass implementations.Inner class EntrySetIterator.
Inner class iterator for the MultiSet.
Inner class MultiSetEntry.
Mutable integer class for storing the data.
Inner class UniqueSetIterator.
Abstract implementation of the
MultiSet interface to simplify the
creation of subclass implementations.Inner class AbstractEntry.
Inner class EntrySet.
Inner class iterator for the MultiSet.
Inner class UniqueSet.
Decorates another
MultSet to provide additional behaviour.Abstract implementation of the
MultiValuedMap interface to simplify
the creation of subclass implementations.Decorates another
MultiValuedMap to provide additional behaviour.Decorates another
NavigableSet to provide additional behaviour.Provides a base decorator that enables additional functionality to be added
to an OrderedBidiMap via decoration.
Provides a base decorator that enables additional functionality to be added
to an OrderedMap via decoration.
Provides basic behaviour for decorating an ordered map iterator with extra functionality.
This class implements the base PATRICIA algorithm and everything that
is related to the
Map interface.A
AbstractPatriciaTrie.Reference allows us to return something through a Method's
argument list.A
Trie is a set of AbstractPatriciaTrie.TrieEntry nodes.Abstract base class for quantification predicates, e.g.
Decorates another
Queue to provide additional behaviour.An abstract implementation of a hash-based map that allows the entries to
be removed by the garbage collector.
Base iterator class.
A MapEntry implementation for the map.
EntrySet implementation.
The EntrySet iterator.
KeySet implementation.
The keySet iterator.
The MapIterator implementation.
Reference type enum.
Values implementation.
The values iterator.
A soft reference holder.
A weak reference holder.
Serializable subclass of AbstractListDecorator.
Serializable subclass of AbstractSetDecorator.
Decorates another
Set to provide additional behaviour.Abstract implementation of the
SetValuedMap interface to simplify the
creation of subclass implementations.Decorates another
SortedBag to provide additional behaviour.Provides a base decorator that enables additional functionality to be added
to a SortedBidiMap via decoration.
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
OrderedMapIterator implementation.
Decorates another
SortedSet to provide additional behaviour.Provides basic behaviour for decorating an iterator with extra functionality
without committing the generic type of the Iterator implementation.
Predicate implementation that returns true if all the
predicates return true.
Predicate implementation that returns true if both the predicates return true.
Predicate implementation that returns true if any of the
predicates return true.
Implements an
Iterator over any array.Implements a
ListIterator over an array.Deprecated.
Operations on arrays, primitive arrays (like
int[]) and primitive wrapper arrays (like Integer[]).Defines a collection that counts the number of times an object appears in
the collection.
Defines a map that allows bidirectional lookup between key and values.
A
Comparator for Boolean objects that can sort either
true or false first.Defines a collection that is bounded in size.
Decorates another iterator to return elements in a specific range.
Defines a map that is bounded in size.
A case-insensitive
Map.Closure that catches any checked exception and re-throws it as a
FunctorException runtime exception.Closure implementation that chains the specified closures together.
Transformer implementation that chains the specified transformers together.
CircularFifoQueue is a first-in first-out queue with a fixed size that
replaces its oldest element if full.
Transformer implementation that returns a clone of the input object.
Defines a functor interface implemented by classes that do something.
Transformer implementation that calls a Closure using the input object
and then returns the input.
ClosureUtils provides reference implementations and utilities
for the Closure functor interface.Provides an ordered iteration over the elements contained in a collection of
ordered Iterators.
Decorates another
Bag to comply with the Collection contract.Decorates another
SortedBag to comply with the Collection contract.Provides utility methods and decorators for
Collection instances.Helper class to easily access cardinality properties of two collections.
Wraps another object and uses the provided Equator to implement
CollectionUtils.EquatorWrapper.equals(Object) and CollectionUtils.EquatorWrapper.hashCode().Helper class for set-related operations, e.g.
This interface should be implemented by user object to walk
through
EditScript objects.A
Comparator that compares Comparable
objects.A ComparatorChain is a Comparator that wraps one or more Comparators in
sequence.
Predicate that compares the input object with the one stored in the predicate using a comparator.
Provides convenient static utility methods for
Comparator
objects.Decorates a collection of other collections to provide a single unified view.
Pluggable strategy to handle changes to the composite.
Decorates a map of other maps to provide a single unified view.
This interface allows definition for all of the indeterminate
mutators in a CompositeMap, as well as providing a hook for
callbacks on key collisions.
Decorates a set of other sets to provide a single unified view.
Define callbacks for mutation operations.
Factory implementation that returns the same constant each time.
Transformer implementation that returns the same constant each time.
A
List implementation with a ListIterator that
allows concurrent modifications to the underlying list.An extended
ListIterator that allows concurrent changes to
the underlying list.A cursor for the sublist based on LinkedSubListIterator.
Decorates another
Map returning a default value if the map
does not contain the requested key.Default
Equator implementation.A mutable
KeyValue pair that does not implement
Map.Entry.Command representing the deletion of one object of the first sequence.
Implementation of
BidiMap that uses two LinkedHashMap instances.Inner class MapIterator.
Internal sorted map view.
Abstract base class for all commands used to transform an objects sequence
into another one.
This class gathers all the
commands needed to transform
one objects sequence into another objects sequence.Provides an implementation of an empty iterator.
Provides an implementation of an empty list iterator.
Provides an implementation of an empty map iterator.
Provides an implementation of an empty ordered iterator.
Provides an implementation of an empty ordered map iterator.
Implements a
MapIterator using a Map entrySet.Adapts a Map entrySet to the MapIterator interface.
Adapter to make
Enumeration instances appear
to be Iterator instances.Provides utility methods for
Enumeration instances.Predicate implementation that returns true if the input is the same object
as the one stored in this predicate by equals.
An equation function, which determines equality between objects of type T.
Closure implementation that always throws an exception.
Factory implementation that always throws an exception.
Predicate implementation that always throws an exception.
Transformer implementation that always throws an exception.
Defines a functor interface implemented by classes that create objects.
Transformer implementation that calls a Factory and returns the result.
FactoryUtils provides reference implementations and utilities
for the Factory functor interface.Predicate implementation that always returns false.
Decorates another
Iterator using a predicate to filter elements.Decorates another
ListIterator using a predicate to filter elements.A Comparator which imposes a specific order on a specific set of Objects.
Unknown object behavior enum.
Decorates another
List to fix the size preventing add/remove.Decorates another
Map to fix the size, preventing add/remove.Decorates another
SortedMap to fix the size blocking add/remove.A
Map implementation that stores data in simple fields until
the size is greater than 3.EntrySet
EntrySetIterator and MapEntry
FlatMapIterator
KeySet
KeySetIterator
Values
ValuesIterator
A FluentIterable provides a powerful yet simple API for manipulating
Iterable instances in a fluent manner.
Closure implementation that calls another closure n times, like a for loop.
Runtime exception thrown from functors.
Internal utilities for functors.
The "read" subset of the
Map interface.Decorates another
List to make it seamlessly grow when
indices larger than the list size are used on add and set,
avoiding most IndexOutOfBoundsExceptions.Implements
Bag, using a HashMap to provide the
data storage.A
Map implementation that is a general purpose alternative
to HashMap.Implements
MultiSet, using a HashMap to provide the
data storage.Predicate implementation that returns true if the input is the same object
as the one stored in this predicate.
Closure implementation acts as an if statement calling one or other closure
based on a predicate.
Transformer implementation that will call one of two closures based on whether a predicate evaluates
as true or false.
An IndexedCollection is a Map-like view onto a Collection.
Command representing the insertion of one object of the second sequence.
Predicate implementation that returns true if the input is an instanceof
the type stored in this predicate.
Factory implementation that creates a new object instance by reflection.
Transformer implementation that creates a new object instance by reflection.
Transformer implementation that creates a new object instance by reflection.
The "read" subset of the
Map interface.Defines a map that can be iterated directly without needing to create an entry set.
Provides utility methods and decorators for
Iterable instances.Inner class to distinguish unmodifiable instances.
An IteratorChain is an Iterator that wraps a number of Iterators.
Adapter to make an
Iterator instance appear to be an
Enumeration instance.Provides static utility methods and decorators for
Iterator
instances.Command representing the keeping of one object present in both sequences.
Defines the interface to analyze
Trie keys on a bit level.Defines a simple key value pair.
An LazyIteratorChain is an Iterator that wraps a number of Iterators in a lazy manner.
Decorates another
List to create objects in the list on demand.Decorates another
Map to create objects in the map on demand.Decorates another
SortedMap to create objects in the map on demand.A
Map implementation that maintains the order of the entries.List view of map.
Converts an
Iterator into a ResettableListIterator.Decorates a
Map to ensure that the order of addition is retained
using a List to maintain order.Decorates another
Set to ensure that the order of addition is
retained and used by the iterator.Internal iterator handle remove.
Provides utility methods and decorators for
List instances.A simple wrapper to use a CharSequence as List.
A helper class used to construct the longest common subsequence.
Provides a partition view on a
List.Defines a map that holds a list of values against each key.
An Iterator that restarts when it reaches the end.
A ListIterator that restarts when it reaches the end or when it
reaches the beginning.
A
Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.Decorates a
Map to obtain Set behaviour.Defines an iterator that operates over a
Map.Transformer implementation that returns the value held in a specified map
using the input parameter as a key.
A
MultiKey allows multiple map keys to be merged together.A
Map implementation that uses multiple keys to map the value.Deprecated.
since 4.1, use
MultiValuedMap insteadProvides utility methods and decorators for
MultiValuedMap instances.Defines a collection that counts the number of times an object appears in
the collection.
An unmodifiable entry for an element and its occurrence as contained in a MultiSet.
Provides utility methods and decorators for
MultiSet instances.Defines a map that holds a collection of values against each key.
Deprecated.
since 4.1, use
MultiValuedMap insteadInner class that provides a simple reflection factory.
A
List implementation that stores a cache of internal Node objects
in an effort to reduce wasteful object creation.Predicate implementation that returns true if none of the
predicates return true.
Closure implementation that does nothing.
Transformer implementation that does nothing.
Predicate implementation that returns true if the input is not null.
Predicate implementation that returns the opposite of the decorated predicate.
A Comparator that will compare nulls to be either lower or higher than
other objects.
Predicate implementation that throws an exception if the input is null.
Predicate implementation that returns false if the input is null.
Predicate implementation that returns true if the input is null.
Predicate implementation that returns true if the input is null.
An
Iterator over an array of objects.Implements a
ListIterator over an array of objects.An Iterator that can traverse multiple iterators down an object graph.
Predicate implementation that returns true if only one of the
predicates return true.
Defines a map that allows bidirectional lookup between key and values
and retains and provides access to an ordering.
Defines an iterator that operates over an ordered container.
Defines a map that maintains order and allows both forward and backward
iteration through that order.
Defines an iterator that operates over an ordered
Map.Predicate implementation that returns true if either of the predicates return true.
Decorates a
Map to evict expired entries once their expiration
time has been reached.A
ExpirationPolicy
that returns a expiration time that is a
constant about of time in the future from the current time.A policy to determine the expiration time for key-value entries.
Implementation of a PATRICIA Trie (Practical Algorithm to Retrieve Information
Coded in Alphanumeric).
Decorates an iterator to support one-element lookahead while iterating.
This iterator creates permutations of an input collection, using the
Steinhaus-Johnson-Trotter algorithm (also called plain changes).
Defines a functor interface implemented by classes that perform a predicate
test on an object.
Decorates another
Bag to validate that additions
match a specified predicate.Decorates another
Collection to validate that additions
match a specified predicate.Builder for creating predicated collections.
Defines a predicate that decorates one or more other predicates.
Decorates another
List to validate that all additions
match a specified predicate.Decorates another
Map to validate that additions
match a specified predicate.Decorates another
MultiSet to validate that additions
match a specified predicate.Decorates another
NavigableSet to validate that all additions
match a specified predicate.Decorates another
Queue to validate that additions
match a specified predicate.Decorates another
Set to validate that all additions
match a specified predicate.Decorates another
SortedBag to validate that additions
match a specified predicate.Decorates another
SortedMap to validate that additions
match a specified predicate.Decorates another
SortedSet to validate that all additions
match a specified predicate.Transformer implementation that calls a Predicate using the input object
and then returns the result.
PredicateUtils provides reference implementations and utilities
for the Predicate functor interface.Creates and loads
Properties.Factory implementation that creates a new instance each time based on a prototype.
PrototypeCloneFactory creates objects by copying a prototype using the clone method.
PrototypeSerializationFactory creates objects by cloning a prototype using serialization.
Decorates an iterator to support pushback of elements.
The "write" subset of the
Map interface.Provides utility methods and decorators for
Queue instances.A
Map implementation that allows mappings to be
removed by the garbage collector and matches keys and values based
on == not equals().A
Map implementation that allows mappings to be
removed by the garbage collector.This class handles sequences of replacements resulting from a comparison.
This interface is devoted to handle synchronized replacement sequences.
Defines an iterator that can be reset back to an initial state.
Defines a list iterator that can be reset back to an initial state.
Reverses the order of another comparator by reversing the arguments
to its
compare method.Iterates backwards through a List, starting with the last element
and continuing to the first.
This class allows to compare two objects sequences.
This class is a simple placeholder to hold the end part of a path
under construction in a
SequencesComparator.Decorates a
List to ensure that no duplicates are present much
like a Set.Inner class iterator.
Inner class iterator.
An unmodifiable view of a set that may be backed by other sets.
Defines a map that holds a set of values against each key.
SingletonIterator is an Iterator over a single
object instance.SingletonIterator is an ListIterator over a single
object instance.A
Map implementation that holds a single item and is fixed size.SingletonMapIterator.
Values implementation for the SingletonMap.
Decorates another iterator to skip the first N elements.
Defines a type of
Bag that maintains a sorted order among
its unique representative members.Defines a map that allows bidirectional lookup between key and values
and retains both keys and values in sorted order.
A drop-in replacement for
Properties for sorting keys.Creates and loads
SortedProperties.A StaticBucketMap is an efficient, thread-safe implementation of
java.util.Map that performs well in in a highly
thread-contentious environment.The lock object, which also includes a count of the nodes in this lock.
The Map.Entry for the StaticBucketMap.
An
KeyAnalyzer for Strings.Transformer implementation that returns the result of calling
String.valueOf on the input object.Closure implementation calls the closure whose predicate returns true,
like a switch statement.
Transformer implementation calls the transformer whose predicate returns true,
like a switch statement.
Decorates another
Bag to synchronize its behaviour
for a multi-threaded environment.Decorates another
Collection to synchronize its behaviour
for a multi-threaded environment.Decorates another
MultiSet to synchronize its behaviour
for a multi-threaded environment.Synchronized Set for the MultiSet class.
Decorates another
Queue to synchronize its behaviour for a multi-threaded environment.Decorates another
SortedBag to synchronize its behaviour
for a multi-threaded environment.A
Map.Entry tied to a map underneath.Decorates another
Bag to transform objects that are added.Decorates another
Collection to transform objects that are added.Decorates another
List to transform objects that are added.Decorates another
Map to transform objects that are added.Decorates another
MultiValuedMap to transform objects that are added.Decorates another
NavigableSet to transform objects that are added.Predicate implementation that transforms the given object before invoking
another
Predicate.Decorates another
Queue to transform objects that are added.Decorates another
Set to transform objects that are added.Decorates another
SortedBag to transform objects that are added.Decorates another
SortedMap to transform objects that are added.Decorates another
SortedSet to transform objects that are added.Decorates another
Map to transform objects that are added.Defines a functor interface implemented by classes that transform one
object into another.
Closure implementation that calls a Transformer using the input object
and ignore the result.
Predicate implementation that returns the result of a transformer.
TransformerUtils provides reference implementations and
utilities for the Transformer functor interface.Decorates another Comparator with transformation behavior.
Decorates an iterator such that each element returned is transformed.
Red-Black tree-based implementation of BidiMap where all objects added
implement the
Comparable interface.A node used to store the data.
A
List implementation that is optimised for fast insertions and
removals at any index in the list.Implements an AVLNode which keeps the offset updated.
A list iterator over the linked list.
Defines the interface for a prefix tree, an ordered tree data structure.
A collection of
Trie utilities.Predicate implementation that always returns true.
A FilterIterator which only returns "unique" Objects.
Predicate implementation that returns true the first time an object is
passed into the predicate.
Marker interface for collections, maps and iterators that are unmodifiable.
Decorates another
Bag to ensure it can't be altered.Decorates another
BidiMap to ensure it can't be altered.UnmodifiableBoundedCollection decorates another
BoundedCollection to ensure it can't be altered.Decorates another
Collection to ensure it can't be altered.Decorates a map entry
Set to ensure it can't be altered.Decorates an iterator such that it cannot be modified.
Decorates another
List to ensure it can't be altered.Decorates a list iterator such that it cannot be modified.
Decorates another
Map to ensure it can't be altered.A
Map.Entry that throws
UnsupportedOperationException when setValue is called.Decorates a map iterator such that it cannot be modified.
Decorates another
MultiSet to ensure it can't be altered.Decorates another
MultiValuedMap to ensure it can't be altered.Decorates another
NavigableSet to ensure it can't be altered.Decorates another
OrderedBidiMap to ensure it can't be altered.Decorates another
OrderedMap to ensure it can't be altered.Decorates an ordered map iterator such that it cannot be modified.
Decorates another
Queue to ensure it can't be altered.Decorates another
Set to ensure it can't be altered.Decorates another
SortedBag to ensure it can't be altered.Decorates another
SortedBidiMap to ensure it can't be altered.Decorates another
SortedMap to ensure it can't be altered.Decorates another
SortedSet to ensure it can't be altered.An unmodifiable
Trie.Closure implementation that executes a closure repeatedly until a condition is met,
like a do-while or while loop.
Provides an interleaved iteration over the elements contained in a
collection of Iterators.
ArrayDequeinstead (available from Java 1.6)