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.
Decorates another
Buffer to provide additional behaviour.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.
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.
Implementation of an entry set that checks additions via setValue.
Implementation of an entry set iterator that checks additions via setValue.
Implementation of a map entry that checks additions via setValue.
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
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.
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.
An abstract implementation of a hash-based map that allows the entries to
be removed by the garbage collector.
A MapEntry implementation for the map.
EntrySet implementation.
The EntrySet iterator.
KeySet implementation.
The keySet iterator.
The MapIterator implementation.
Values implementation.
The values iterator.
A soft reference holder.
A weak reference holder.
Serializable subclass of AbstractCollectionDecorator.
Serializable subclass of AbstractListDecorator.
Serializable subclass of AbstractSetDecorator.
Decorates another
Set to provide additional behaviour.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.
Decorates another
SortedSet to provide additional behaviour.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.An implementation of the
Stack API that is based on an
ArrayList instead of a Vector, so it is not
synchronized to protect against multi-threaded access.Defines a collection that counts the number of times an object appears in
the collection.
Deprecated.
Identical class now available in commons-beanutils (full jar version).
Map entry used by
BeanMap.Defines a map that allows bidirectional lookup between key and values.
Deprecated.
Replaced by PriorityBuffer in buffer subpackage.
Decorates another
Buffer to make BlockingBuffer.get() and
BlockingBuffer.remove() block when the Buffer is empty.A
Comparator for Boolean objects that can sort either
true or false first.Decorates another
Buffer to ensure a fixed maximum size.Defines a collection that is bounded in size.
Deprecated.
Moved to buffer subpackage.
The BoundedFifoBuffer is a very efficient implementation of
Buffer that is of a fixed size.Defines a map that is bounded in size.
Defines a collection that allows objects to be removed in some well-defined order.
The BufferOverflowException is used when the buffer's capacity has been
exceeded.
The BufferUnderflowException is used when the buffer is already empty.
Provides utility methods and decorators for
Buffer instances.A case-insensitive
Map.Closure implementation that chains the specified closures together.
Transformer implementation that chains the specified transformers together.
CircularFifoBuffer is a first in first out buffer 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.
Provides utility methods and decorators for
Collection instances.A
Comparator that compares
Comparable objects.A ComparatorChain is a Comparator that wraps one or
more Comparators in sequence.
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.
Deprecated.
Use new version in list subpackage, which has been rewritten
and now returns the cursor from the listIterator method.
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.
Deprecated.
Use new version in list subpackage, which has been rewritten
and now returns the cursor from the listIterator method.
Decorates another
Map returning a default value if the map
does not contain the requested key.A mutable
KeyValue pair that does not implement
Map.Entry.Deprecated.
Moved to bag subpackage as AbstractMapBag.
Deprecated.
Use the version in the keyvalue subpackage.
A restricted implementation of
Map.Entry that prevents
the Map.Entry contract from being broken.Deprecated.
Replaced by TreeBidiMap in bidimap subpackage.
Implementation of
BidiMap that uses two HashMap instances.Implementation of
BidiMap that uses two TreeMap instances.Inner class MapIterator.
Internal sorted map view.
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.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.
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.
This class extends normal Java properties by adding the possibility
to use the same key many times concatenating the value strings
instead of overwriting them.
This class is used to read properties lines.
This class divides into tokens a property value.
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.
A customized implementation of
java.util.ArrayList designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes.A customized implementation of
java.util.HashMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes.A customized implementation of
java.util.TreeMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes.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.
Decorates another
List to fix the size preventing add/remove.List iterator that only permits changes via set()
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
Closure implementation that calls another closure n times, like a for loop.
Runtime exception thrown from functors.
Internal utilities for functors.
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.Deprecated.
Moved to bag subpackage and rewritten internally.
A
Map implementation that is a general purpose alternative
to HashMap.A
Map implementation that matches keys and values based
on == not equals().HashEntry
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.
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.
Defines a map that can be iterated directly without needing to create an entry set.
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.Defines a simple key value pair.
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 list iterator by caching the returned entries.
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.An Iterator that restarts when it reaches the end.
A ListIterator that restarts when it reaches the end or when it
reaches the beginning.
Deprecated.
Moved to map subpackage.
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.
Deprecated.
Class now available as MultiValueMap in map subpackage.
A
MultiKey allows multiple map keys to be merged together.A
Map implementation that uses multiple keys to map the value.Defines a map that holds a collection of values against each key.
A MultiValueMap decorates another map, allowing it to have
more than one value for a key.
Inner 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 collection.
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.
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
Buffer to validate that additions
match a specified predicate.Decorates another
Collection to validate that additions
match a specified predicate.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
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 input.
PredicateUtils provides reference implementations and utilities
for the Predicate functor interface.Binary heap implementation of
Buffer that provides for
removal based on Comparator ordering.Deprecated.
Replaced by the Buffer interface and implementations in buffer subpackage.
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.
Deprecated.
Use AbstractIteratorDecorator.
Deprecated.
Use AbstractListIteratorDecorator.
Deprecated.
Moved to map subpackage as AbstractMapDecorator.
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.Deprecated.
Moved to map subpackage.
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.
Deprecated.
Replaced by LinkedMap and ListOrderedMap in map subpackage.
Map.Entry that doubles as a node in the linked list
of sequenced mappings.Decorates a
List to ensure that no duplicates are present
much like a Set.Inner class iterator.
Inner class iterator.
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.
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 StaticBucketMap is an efficient, thread-safe implementation of
java.util.Map that performs well in in a highly
thread-contentious environment.Deprecated.
Moved to map subpackage.
The lock object, which also includes a count of the nodes in this lock.
The Map.Entry for the StaticBucketMap.
The Map.Entry for the StaticBucketMap.
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
Buffer to synchronize its behaviour
for a multi-threaded environment.Decorates another
Collection to synchronize its behaviour
for a multi-threaded environment.Decorates another
List to synchronize its behaviour
for a multi-threaded environment.Deprecated.
PriorityQueue is replaced by the Buffer interface, see buffer subpackage.
Decorates another
Set to synchronize its behaviour for a
multi-threaded environment.Decorates another
SortedBag to synchronize its behaviour
for a multi-threaded environment.Decorates another
SortedSet 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
Buffer 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.Predicate implementation that transforms the given object before invoking
another
Predicate.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.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.
Implements
SortedBag, using a TreeMap to provide
the data storage.Deprecated.
Moved to bag subpackage and rewritten internally.
Red-Black tree-based implementation of BidiMap where all objects added
implement the
Comparable interface.A view of this map.
A node used to store the data.
A node used to store the data.
A view of this map.
An iterator over the map.
An iterator over the map.
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.
Predicate implementation that always returns true.
Decorates another
Bag to validate that elements added
are of a specific type.Decorates another
Buffer to validate that elements added
are of a specific type.Decorates a
Collection to validate that elements added are of a specific type.Decorates another
List to validate that elements
added are of a specific type.Decorates another
Map to validate that elements added
are of a specific type.Decorates another
Set to validate that elements
added are of a specific type.Decorates another
SortedBag to validate that elements added
are of a specific type.Decorates another
SortedMap to validate that elements added
are of a specific type.Decorates another
SortedSet to validate that elements
added are of a specific type.UnboundedFifoBuffer is a very efficient implementation of
Buffer that can grow to any size.Deprecated.
Moved to buffer subpackage.
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
Buffer 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.Implementation of a map entry that is unmodifiable.
Implementation of an entry set iterator.
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
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
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.Closure implementation that executes a closure repeatedly until a condition is met,
like a do-while or while loop.