All Classes Interface Summary Class Summary Exception Summary
| Class |
Description |
| AbstractBagDecorator |
Decorates another Bag to provide additional behaviour.
|
| AbstractBidiMapDecorator |
Provides a base decorator that enables additional functionality to be added
to a BidiMap via decoration.
|
| AbstractBufferDecorator |
Decorates another Buffer to provide additional behaviour.
|
| AbstractCollectionDecorator |
Decorates another Collection to provide additional behaviour.
|
| AbstractDualBidiMap |
Abstract BidiMap implemented using two maps.
|
| AbstractDualBidiMap.BidiMapIterator |
Inner class MapIterator.
|
| AbstractDualBidiMap.EntrySet |
Inner class EntrySet.
|
| AbstractDualBidiMap.EntrySetIterator |
Inner class EntrySetIterator.
|
| AbstractDualBidiMap.KeySet |
Inner class KeySet.
|
| AbstractDualBidiMap.KeySetIterator |
Inner class KeySetIterator.
|
| AbstractDualBidiMap.MapEntry |
Inner class MapEntry.
|
| AbstractDualBidiMap.Values |
Inner class Values.
|
| AbstractDualBidiMap.ValuesIterator |
Inner class ValuesIterator.
|
| AbstractDualBidiMap.View |
Inner class View.
|
| AbstractHashedMap |
An abstract implementation of a hash-based map which provides numerous points for
subclasses to override.
|
| AbstractHashedMap.EntrySet |
EntrySet implementation.
|
| AbstractHashedMap.EntrySetIterator |
EntrySet iterator.
|
| AbstractHashedMap.HashEntry |
HashEntry used to store the data.
|
| AbstractHashedMap.HashIterator |
Base Iterator
|
| AbstractHashedMap.HashMapIterator |
MapIterator implementation.
|
| AbstractHashedMap.KeySet |
KeySet implementation.
|
| AbstractHashedMap.KeySetIterator |
KeySet iterator.
|
| AbstractHashedMap.Values |
Values implementation.
|
| AbstractHashedMap.ValuesIterator |
Values iterator.
|
| AbstractIteratorDecorator |
Provides basic behaviour for decorating an iterator with extra functionality.
|
| AbstractKeyValue |
Abstract pair class to assist with creating KeyValue
and Map.Entry implementations.
|
| AbstractLinkedList |
An abstract implementation of a linked list which provides numerous points for
subclasses to override.
|
| AbstractLinkedList.LinkedListIterator |
A list iterator over the linked list.
|
| AbstractLinkedList.LinkedSubList |
The sublist implementation for AbstractLinkedList.
|
| AbstractLinkedList.LinkedSubListIterator |
A list iterator over the linked sub list.
|
| AbstractLinkedList.Node |
A node within the linked list.
|
| AbstractLinkedMap |
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.
|
| AbstractLinkedMap.EntrySetIterator |
EntrySet iterator.
|
| AbstractLinkedMap.KeySetIterator |
KeySet iterator.
|
| AbstractLinkedMap.LinkEntry |
LinkEntry that stores the data.
|
| AbstractLinkedMap.LinkIterator |
Base Iterator that iterates in link order.
|
| AbstractLinkedMap.LinkMapIterator |
MapIterator implementation.
|
| AbstractLinkedMap.ValuesIterator |
Values iterator.
|
| AbstractListDecorator |
Decorates another List to provide additional behaviour.
|
| AbstractListIteratorDecorator |
Provides basic behaviour for decorating a list iterator with extra functionality.
|
| AbstractMapBag |
Abstract implementation of the Bag interface to simplify the creation
of subclass implementations. |
| AbstractMapBag.MutableInteger |
Mutable integer class for storing the data.
|
| AbstractMapDecorator |
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
|
| AbstractMapEntry |
Abstract Pair class to assist with creating correct
Map.Entry implementations.
|
| AbstractMapEntryDecorator |
Provides a base decorator that allows additional functionality to be
added to a Map.Entry.
|
| AbstractMapIteratorDecorator |
Provides basic behaviour for decorating a map iterator with extra functionality.
|
| AbstractOrderedBidiMapDecorator |
Provides a base decorator that enables additional functionality to be added
to an OrderedBidiMap via decoration.
|
| AbstractOrderedMapDecorator |
Provides a base decorator that enables additional functionality to be added
to an OrderedMap via decoration.
|
| AbstractOrderedMapIteratorDecorator |
Provides basic behaviour for decorating an ordered map iterator with extra functionality.
|
| AbstractReferenceMap |
An abstract implementation of a hash-based map that allows the entries to
be removed by the garbage collector.
|
| AbstractReferenceMap.ReferenceEntry |
A MapEntry implementation for the map.
|
| AbstractSerializableCollectionDecorator |
Serializable subclass of AbstractCollectionDecorator.
|
| AbstractSerializableListDecorator |
Serializable subclass of AbstractListDecorator.
|
| AbstractSerializableSetDecorator |
Serializable subclass of AbstractSetDecorator.
|
| AbstractSetDecorator |
Decorates another Set to provide additional behaviour.
|
| AbstractSortedBagDecorator |
Decorates another SortedBag to provide additional behaviour.
|
| AbstractSortedBidiMapDecorator |
Provides a base decorator that enables additional functionality to be added
to a SortedBidiMap via decoration.
|
| AbstractSortedMapDecorator |
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
|
| AbstractSortedSetDecorator |
Decorates another SortedSet to provide additional behaviour.
|
| AllPredicate |
Predicate implementation that returns true if all the
predicates return true.
|
| AndPredicate |
Predicate implementation that returns true if both the predicates return true.
|
| AnyPredicate |
Predicate implementation that returns true if any of the
predicates return true.
|
| ArrayIterator |
Implements an Iterator over any array.
|
| ArrayListIterator |
Implements a ListIterator over an array.
|
| ArrayStack |
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.
|
| Bag |
Defines a collection that counts the number of times an object appears in
the collection.
|
| BagUtils |
Provides utility methods and decorators for
Bag and SortedBag instances. |
| BeanMap |
Deprecated.
|
| BeanMap.MyMapEntry |
|
| BidiMap |
Defines a map that allows bidirectional lookup between key and values.
|
| BinaryHeap |
Deprecated.
|
| BlockingBuffer |
|
| BooleanComparator |
A Comparator for Boolean objects that can sort either
true or false first.
|
| BoundedBuffer |
Decorates another Buffer to ensure a fixed maximum size.
|
| BoundedCollection |
Defines a collection that is bounded in size.
|
| BoundedFifoBuffer |
Deprecated.
|
| BoundedFifoBuffer |
The BoundedFifoBuffer is a very efficient implementation of
Buffer that is of a fixed size.
|
| BoundedMap |
Defines a map that is bounded in size.
|
| Buffer |
Defines a collection that allows objects to be removed in some well-defined order.
|
| BufferOverflowException |
The BufferOverflowException is used when the buffer's capacity has been
exceeded.
|
| BufferUnderflowException |
The BufferUnderflowException is used when the buffer is already empty.
|
| BufferUtils |
Provides utility methods and decorators for Buffer instances. |
| CaseInsensitiveMap |
A case-insensitive Map.
|
| ChainedClosure |
Closure implementation that chains the specified closures together.
|
| ChainedTransformer |
Transformer implementation that chains the specified transformers together.
|
| CircularFifoBuffer |
CircularFifoBuffer is a first in first out buffer with a fixed size that
replaces its oldest element if full.
|
| CloneTransformer |
Transformer implementation that returns a clone of the input object.
|
| Closure |
Defines a functor interface implemented by classes that do something.
|
| ClosureTransformer |
Transformer implementation that calls a Closure using the input object
and then returns the input.
|
| ClosureUtils |
ClosureUtils provides reference implementations and utilities
for the Closure functor interface.
|
| CollatingIterator |
Provides an ordered iteration over the elements contained in
a collection of ordered Iterators.
|
| CollectionUtils |
Provides utility methods and decorators for Collection instances.
|
| ComparableComparator |
A Comparator that compares
Comparable objects.
|
| ComparatorChain |
A ComparatorChain is a Comparator that wraps one or
more Comparators in sequence.
|
| ComparatorUtils |
Provides convenient static utility methods for Comparator
objects.
|
| CompositeCollection |
Decorates a collection of other collections to provide a single unified view.
|
| CompositeCollection.CollectionMutator |
Pluggable strategy to handle changes to the composite.
|
| CompositeMap |
Decorates a map of other maps to provide a single unified view.
|
| CompositeMap.MapMutator |
This interface allows definition for all of the indeterminate
mutators in a CompositeMap, as well as providing a hook for
callbacks on key collisions.
|
| CompositeSet |
Decorates a set of other sets to provide a single unified view.
|
| CompositeSet.SetMutator |
Define callbacks for mutation operations.
|
| ConstantFactory |
Factory implementation that returns the same constant each time.
|
| ConstantTransformer |
Transformer implementation that returns the same constant each time.
|
| CursorableLinkedList |
Deprecated.
|
| CursorableLinkedList |
A List implementation with a ListIterator that
allows concurrent modifications to the underlying list.
|
| CursorableLinkedList.Cursor |
An extended ListIterator that allows concurrent changes to
the underlying list.
|
| CursorableLinkedList.SubCursor |
A cursor for the sublist based on LinkedSubListIterator.
|
| DefaultedMap |
Decorates another Map returning a default value if the map
does not contain the requested key.
|
| DefaultKeyValue |
A mutable KeyValue pair that does not implement
Map.Entry.
|
| DefaultMapBag |
Deprecated.
|
| DefaultMapEntry |
Deprecated.
|
| DefaultMapEntry |
A restricted implementation of Map.Entry that prevents
the Map.Entry contract from being broken.
|
| DoubleOrderedMap |
Deprecated.
|
| DualHashBidiMap |
Implementation of BidiMap that uses two HashMap instances.
|
| DualTreeBidiMap |
Implementation of BidiMap that uses two TreeMap instances.
|
| DualTreeBidiMap.BidiOrderedMapIterator |
Inner class MapIterator.
|
| DualTreeBidiMap.ViewMap |
Internal sorted map view.
|
| EmptyIterator |
Provides an implementation of an empty iterator.
|
| EmptyListIterator |
Provides an implementation of an empty list iterator.
|
| EmptyMapIterator |
Provides an implementation of an empty map iterator.
|
| EmptyOrderedIterator |
Provides an implementation of an empty ordered iterator.
|
| EmptyOrderedMapIterator |
Provides an implementation of an empty ordered map iterator.
|
| EntrySetMapIterator |
Implements a MapIterator using a Map entrySet.
|
| EnumerationIterator |
Adapter to make Enumeration instances appear
to be Iterator instances.
|
| EnumerationUtils |
Provides utility methods for Enumeration instances.
|
| EqualPredicate |
Predicate implementation that returns true if the input is the same object
as the one stored in this predicate by equals.
|
| ExceptionClosure |
Closure implementation that always throws an exception.
|
| ExceptionFactory |
Factory implementation that always throws an exception.
|
| ExceptionPredicate |
Predicate implementation that always throws an exception.
|
| ExceptionTransformer |
Transformer implementation that always throws an exception.
|
| ExtendedProperties |
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.
|
| Factory |
Defines a functor interface implemented by classes that create objects.
|
| FactoryTransformer |
Transformer implementation that calls a Factory and returns the result.
|
| FactoryUtils |
FactoryUtils provides reference implementations and utilities
for the Factory functor interface.
|
| FalsePredicate |
Predicate implementation that always returns false.
|
| FastArrayList |
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.
|
| FastHashMap |
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.
|
| FastTreeMap |
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.
|
| FilterIterator |
Decorates another Iterator using a predicate to filter elements.
|
| FilterListIterator |
Decorates another ListIterator using a predicate to filter elements.
|
| FixedOrderComparator |
A Comparator which imposes a specific order on a specific set of Objects.
|
| FixedSizeList |
Decorates another List to fix the size preventing add/remove.
|
| FixedSizeMap |
Decorates another Map to fix the size, preventing add/remove.
|
| FixedSizeSortedMap |
Decorates another SortedMap to fix the size blocking add/remove.
|
| Flat3Map |
A Map implementation that stores data in simple fields until
the size is greater than 3.
|
| ForClosure |
Closure implementation that calls another closure n times, like a for loop.
|
| FunctorException |
Runtime exception thrown from functors.
|
| GrowthList |
Decorates another List to make it seamlessly grow when
indices larger than the list size are used on add and set,
avoiding most IndexOutOfBoundsExceptions.
|
| HashBag |
Implements Bag, using a HashMap to provide the
data storage.
|
| HashBag |
Deprecated.
|
| HashedMap |
A Map implementation that is a general purpose alternative
to HashMap.
|
| IdentityMap |
A Map implementation that matches keys and values based
on == not equals().
|
| IdentityMap.IdentityEntry |
HashEntry
|
| IdentityPredicate |
Predicate implementation that returns true if the input is the same object
as the one stored in this predicate.
|
| IfClosure |
Closure implementation acts as an if statement calling one or other closure
based on a predicate.
|
| InstanceofPredicate |
Predicate implementation that returns true if the input is an instanceof
the type stored in this predicate.
|
| InstantiateFactory |
Factory implementation that creates a new object instance by reflection.
|
| InstantiateTransformer |
Transformer implementation that creates a new object instance by reflection.
|
| InvokerTransformer |
Transformer implementation that creates a new object instance by reflection.
|
| IterableMap |
Defines a map that can be iterated directly without needing to create an entry set.
|
| IteratorChain |
An IteratorChain is an Iterator that wraps a number of Iterators.
|
| IteratorEnumeration |
Adapter to make an Iterator instance appear to be
an Enumeration instance.
|
| IteratorUtils |
Provides static utility methods and decorators for Iterator
instances.
|
| KeyValue |
Defines a simple key value pair.
|
| LazyList |
Decorates another List to create objects in the list on demand.
|
| LazyMap |
Decorates another Map to create objects in the map on demand.
|
| LazySortedMap |
Decorates another SortedMap to create objects in the map on demand.
|
| LinkedMap |
A Map implementation that maintains the order of the entries.
|
| ListIteratorWrapper |
Converts an iterator into a list iterator by caching the returned entries.
|
| ListOrderedMap |
Decorates a Map to ensure that the order of addition is retained
using a List to maintain order.
|
| ListOrderedSet |
Decorates another Set to ensure that the order of addition
is retained and used by the iterator.
|
| ListUtils |
Provides utility methods and decorators for List instances.
|
| LoopingIterator |
An Iterator that restarts when it reaches the end.
|
| LoopingListIterator |
A ListIterator that restarts when it reaches the end or when it
reaches the beginning.
|
| LRUMap |
Deprecated.
|
| LRUMap |
A Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.
|
| MapBackedSet |
Decorates a Map to obtain Set behaviour.
|
| MapIterator |
Defines an iterator that operates over a Map.
|
| MapTransformer |
Transformer implementation that returns the value held in a specified map
using the input parameter as a key.
|
| MapUtils |
Provides utility methods and decorators for
Map and SortedMap instances.
|
| MultiHashMap |
Deprecated.
|
| MultiKey |
A MultiKey allows multiple map keys to be merged together.
|
| MultiKeyMap |
A Map implementation that uses multiple keys to map the value.
|
| MultiMap |
Defines a map that holds a collection of values against each key.
|
| MultiValueMap |
A MultiValueMap decorates another map, allowing it to have
more than one value for a key.
|
| NodeCachingLinkedList |
A List implementation that stores a cache of internal Node objects
in an effort to reduce wasteful object creation.
|
| NonePredicate |
Predicate implementation that returns true if none of the
predicates return true.
|
| NOPClosure |
Closure implementation that does nothing.
|
| NOPTransformer |
Transformer implementation that does nothing.
|
| NotNullPredicate |
Predicate implementation that returns true if the input is not null.
|
| NotPredicate |
Predicate implementation that returns the opposite of the decorated predicate.
|
| NullComparator |
A Comparator that will compare nulls to be either lower or higher than
other objects.
|
| NullIsExceptionPredicate |
Predicate implementation that throws an exception if the input is null.
|
| NullIsFalsePredicate |
Predicate implementation that returns false if the input is null.
|
| NullIsTruePredicate |
Predicate implementation that returns true if the input is null.
|
| NullPredicate |
Predicate implementation that returns true if the input is null.
|
| ObjectArrayIterator |
An Iterator over an array of objects.
|
| ObjectArrayListIterator |
Implements a ListIterator over an array of objects.
|
| ObjectGraphIterator |
An Iterator that can traverse multiple iterators down an object graph.
|
| OnePredicate |
Predicate implementation that returns true if only one of the
predicates return true.
|
| OrderedBidiMap |
Defines a map that allows bidirectional lookup between key and values
and retains and provides access to an ordering.
|
| OrderedIterator |
Defines an iterator that operates over an ordered collection.
|
| OrderedMap |
Defines a map that maintains order and allows both forward and backward
iteration through that order.
|
| OrderedMapIterator |
Defines an iterator that operates over an ordered Map.
|
| OrPredicate |
Predicate implementation that returns true if either of the predicates return true.
|
| Predicate |
Defines a functor interface implemented by classes that perform a predicate
test on an object.
|
| PredicatedBag |
Decorates another Bag to validate that additions
match a specified predicate.
|
| PredicatedBuffer |
Decorates another Buffer to validate that additions
match a specified predicate.
|
| PredicatedCollection |
Decorates another Collection to validate that additions
match a specified predicate.
|
| PredicateDecorator |
Defines a predicate that decorates one or more other predicates.
|
| PredicatedList |
Decorates another List to validate that all additions
match a specified predicate.
|
| PredicatedMap |
Decorates another Map to validate that additions
match a specified predicate.
|
| PredicatedSet |
Decorates another Set to validate that all additions
match a specified predicate.
|
| PredicatedSortedBag |
Decorates another SortedBag to validate that additions
match a specified predicate.
|
| PredicatedSortedMap |
Decorates another SortedMap to validate that additions
match a specified predicate.
|
| PredicatedSortedSet |
Decorates another SortedSet to validate that all additions
match a specified predicate.
|
| PredicateTransformer |
Transformer implementation that calls a Predicate using the input object
and then returns the input.
|
| PredicateUtils |
PredicateUtils provides reference implementations and utilities
for the Predicate functor interface.
|
| PriorityBuffer |
Binary heap implementation of Buffer that provides for
removal based on Comparator ordering.
|
| PriorityQueue |
Deprecated.
|
| PrototypeFactory |
Factory implementation that creates a new instance each time based on a prototype.
|
| ProxyIterator |
Deprecated.
|
| ProxyListIterator |
Deprecated.
|
| ProxyMap |
Deprecated.
|
| ReferenceIdentityMap |
A Map implementation that allows mappings to be
removed by the garbage collector and matches keys and values based
on == not equals().
|
| ReferenceMap |
A Map implementation that allows mappings to be
removed by the garbage collector.
|
| ReferenceMap |
Deprecated.
|
| ResettableIterator |
Defines an iterator that can be reset back to an initial state.
|
| ResettableListIterator |
Defines a list iterator that can be reset back to an initial state.
|
| ReverseComparator |
Reverses the order of another comparator by reversing the arguments
to its compare method. |
| ReverseListIterator |
Iterates backwards through a List, starting with the last element
and continuing to the first.
|
| SequencedHashMap |
Deprecated.
|
| SetUniqueList |
Decorates a List to ensure that no duplicates are present
much like a Set.
|
| SetUtils |
Provides utility methods and decorators for
Set and SortedSet instances.
|
| SingletonIterator |
SingletonIterator is an Iterator over a single
object instance.
|
| SingletonListIterator |
SingletonIterator is an ListIterator over a single
object instance.
|
| SingletonMap |
A Map implementation that holds a single item and is fixed size.
|
| SortedBag |
Defines a type of Bag that maintains a sorted order among
its unique representative members.
|
| SortedBidiMap |
Defines a map that allows bidirectional lookup between key and values
and retains both keys and values in sorted order.
|
| StaticBucketMap |
A StaticBucketMap is an efficient, thread-safe implementation of
java.util.Map that performs well in in a highly
thread-contentious environment.
|
| StaticBucketMap |
Deprecated.
|
| StringValueTransformer |
Transformer implementation that returns the result of calling
String.valueOf on the input object.
|
| SwitchClosure |
Closure implementation calls the closure whose predicate returns true,
like a switch statement.
|
| SwitchTransformer |
Transformer implementation calls the transformer whose predicate returns true,
like a switch statement.
|
| SynchronizedBag |
Decorates another Bag to synchronize its behaviour
for a multi-threaded environment.
|
| SynchronizedBuffer |
Decorates another Buffer to synchronize its behaviour
for a multi-threaded environment.
|
| SynchronizedCollection |
Decorates another Collection to synchronize its behaviour
for a multi-threaded environment.
|
| SynchronizedList |
Decorates another List to synchronize its behaviour
for a multi-threaded environment.
|
| SynchronizedPriorityQueue |
Deprecated.
|
| SynchronizedSet |
Decorates another Set to synchronize its behaviour for a
multi-threaded environment.
|
| SynchronizedSortedBag |
Decorates another SortedBag to synchronize its behaviour
for a multi-threaded environment.
|
| SynchronizedSortedSet |
Decorates another SortedSet to synchronize its behaviour
for a multi-threaded environment.
|
| TiedMapEntry |
A Map.Entry tied to a map underneath.
|
| TransformedBag |
Decorates another Bag to transform objects that are added.
|
| TransformedBuffer |
Decorates another Buffer to transform objects that are added.
|
| TransformedCollection |
Decorates another Collection to transform objects that are added.
|
| TransformedList |
Decorates another List to transform objects that are added.
|
| TransformedMap |
Decorates another Map to transform objects that are added.
|
| TransformedPredicate |
Predicate implementation that transforms the given object before invoking
another Predicate.
|
| TransformedSet |
Decorates another Set to transform objects that are added.
|
| TransformedSortedBag |
Decorates another SortedBag to transform objects that are added.
|
| TransformedSortedMap |
Decorates another SortedMap to transform objects that are added.
|
| TransformedSortedSet |
Decorates another SortedSet to transform objects that are added.
|
| Transformer |
Defines a functor interface implemented by classes that transform one
object into another.
|
| TransformerClosure |
Closure implementation that calls a Transformer using the input object
and ignore the result.
|
| TransformerPredicate |
Predicate implementation that returns the result of a transformer.
|
| TransformerUtils |
TransformerUtils provides reference implementations and
utilities for the Transformer functor interface.
|
| TransformingComparator |
Decorates another Comparator with transformation behavior.
|
| TransformIterator |
Decorates an iterator such that each element returned is transformed.
|
| TreeBag |
Implements SortedBag, using a TreeMap to provide
the data storage.
|
| TreeBag |
Deprecated.
|
| TreeBidiMap |
Red-Black tree-based implementation of BidiMap where all objects added
implement the Comparable interface.
|
| TreeList |
A List implementation that is optimised for fast insertions and
removals at any index in the list.
|
| TruePredicate |
Predicate implementation that always returns true.
|
| TypedBag |
Decorates another Bag to validate that elements added
are of a specific type.
|
| TypedBuffer |
Decorates another Buffer to validate that elements added
are of a specific type.
|
| TypedCollection |
Decorates a Collection to validate that elements added are of a specific type.
|
| TypedList |
Decorates another List to validate that elements
added are of a specific type.
|
| TypedMap |
Decorates another Map to validate that elements added
are of a specific type.
|
| TypedSet |
Decorates another Set to validate that elements
added are of a specific type.
|
| TypedSortedBag |
Decorates another SortedBag to validate that elements added
are of a specific type.
|
| TypedSortedMap |
Decorates another SortedMap to validate that elements added
are of a specific type.
|
| TypedSortedSet |
Decorates another SortedSet to validate that elements
added are of a specific type.
|
| UnboundedFifoBuffer |
UnboundedFifoBuffer is a very efficient implementation of
Buffer that can grow to any size.
|
| UnboundedFifoBuffer |
Deprecated.
|
| UniqueFilterIterator |
A FilterIterator which only returns "unique" Objects.
|
| UniquePredicate |
Predicate implementation that returns true the first time an object is
passed into the predicate.
|
| Unmodifiable |
Marker interface for collections, maps and iterators that are unmodifiable.
|
| UnmodifiableBag |
Decorates another Bag to ensure it can't be altered.
|
| UnmodifiableBidiMap |
Decorates another BidiMap to ensure it can't be altered.
|
| UnmodifiableBoundedCollection |
UnmodifiableBoundedCollection decorates another
BoundedCollection to ensure it can't be altered.
|
| UnmodifiableBuffer |
Decorates another Buffer to ensure it can't be altered.
|
| UnmodifiableCollection |
Decorates another Collection to ensure it can't be altered.
|
| UnmodifiableEntrySet |
Decorates a map entry Set to ensure it can't be altered.
|
| UnmodifiableIterator |
Decorates an iterator such that it cannot be modified.
|
| UnmodifiableList |
Decorates another List to ensure it can't be altered.
|
| UnmodifiableListIterator |
Decorates a list iterator such that it cannot be modified.
|
| UnmodifiableMap |
Decorates another Map to ensure it can't be altered.
|
| UnmodifiableMapEntry |
A Map.Entry that throws
UnsupportedOperationException when setValue is called.
|
| UnmodifiableMapIterator |
Decorates a map iterator such that it cannot be modified.
|
| UnmodifiableOrderedBidiMap |
Decorates another OrderedBidiMap to ensure it can't be altered.
|
| UnmodifiableOrderedMap |
Decorates another OrderedMap to ensure it can't be altered.
|
| UnmodifiableOrderedMapIterator |
Decorates an ordered map iterator such that it cannot be modified.
|
| UnmodifiableSet |
Decorates another Set to ensure it can't be altered.
|
| UnmodifiableSortedBag |
Decorates another SortedBag to ensure it can't be altered.
|
| UnmodifiableSortedBidiMap |
Decorates another SortedBidiMap to ensure it can't be altered.
|
| UnmodifiableSortedMap |
Decorates another SortedMap to ensure it can't be altered.
|
| UnmodifiableSortedSet |
Decorates another SortedSet to ensure it can't be altered.
|
| WhileClosure |
Closure implementation that executes a closure repeatedly until a condition is met,
like a do-while or while loop.
|