All Classes

Class Summary
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 `java.util.Map.Entry 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 `java.util.Map.Entry Map.Entry` implementations.
AbstractMapEntryDecorator	Provides a base decorator that allows additional functionality to be added to a `java.util.Map.Entry 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 `java.util.Iterator Iterator` over any array.
ArrayListIterator	Implements a ListIterator over an array.
ArrayStack	An implementation of the java.util.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	An implementation of Map for JavaBeans which uses introspection to get and put properties in the bean.
BeanMap.MyMapEntry	Map entry used by BeanMap.
BidiMap	Defines a map that allows bidirectional lookup between key and values.
BinaryHeap	Binary heap implementation of `PriorityQueue`.
BlockingBuffer	Decorates another `Buffer` to make get and remove block when the `Buffer` is empty.
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	The BoundedFifoBuffer is a very efficient implementation of Buffer that does not alter the size of the buffer at runtime.
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 Comparator` that compares `Comparable 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	A doubly-linked list implementation of the List interface, supporting a ListIterator that allows concurrent modifications to the underlying list.
CursorableLinkedList	A `List` implementation with a `ListIterator` that allows concurrent modifications to the underlying list.
CursorableLinkedList.Cursor
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 `java.util.Map.Entry Map.Entry`.
DefaultMapBag	A skeletal implementation of the Bag interface to minimize the effort required for target implementations.
DefaultMapEntry	A default implementation of java.util.Map.Entry
DefaultMapEntry	A restricted implementation of java.util.Map.Entry that prevents the `Map.Entry` contract from being broken.
DoubleOrderedMap	Red-Black tree-based implementation of Map.
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 Enumeration` instances appear to be `Iterator 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	A Bag that is backed by a HashMap.
HashBag	Implements `Bag`, using a `HashMap` to provide the data storage.
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 Iterator` instance appear to be an `Enumeration 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	An implementation of a Map which has a maximum size and uses a Least Recently Used algorithm to remove items from the Map when the maximum size is reached and new items are added.
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	`MultiHashMap` is the default implementation of the `MultiMap` interface.
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.
NotNullPredicate	Predicate implementation that returns true if the input is not null.
NotPredicate	Predicate implementation that returns the opposite of the decorated predicate.
NOPClosure	Closure implementation that does nothing.
NOPTransformer	Transformer implementation that does nothing.
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.
PredicatedList	Decorates another `List` to validate that all additions match a specified predicate.
PredicatedList.PredicatedListIterator	Inner class Iterator for the PredicatedList
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.
PredicateDecorator	Defines a predicate that decorates one or more other predicates.
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	Defines a collection for priority queues, which can insert, peek and pop.
PrototypeFactory	Factory implementation that creates a new instance each time based on a prototype.
ProxyIterator	A Proxy `Iterator Iterator` which delegates its methods to a proxy instance.
ProxyListIterator	A proxy `ListIterator ListIterator` which delegates its methods to a proxy instance.
ProxyMap	This `Map` wraps another `Map` implementation, using the wrapped instance for its default implementation.
ReferenceIdentityMap	A `Map` implementation that allows mappings to be removed by the garbage collector and matches keys and values based on `==` not `equals()`.
ReferenceMap	Hash-based Map implementation that allows mappings to be removed by the garbage collector. When you construct a `ReferenceMap`, you can specify what kind of references are used to store the map's keys and values.
ReferenceMap	A `Map` implementation that allows mappings to be removed by the garbage collector.
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	A map of objects whose mapping entries are sequenced based on the order in which they were added.
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	A StaticBucketMap is an efficient, thread-safe implementation of `java.util.Map` that performs well in in a highly thread-contentious environment.
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	A thread safe version of the PriorityQueue.
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 `java.util.Map.Entry 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.
TransformedList.TransformedListIterator	Inner class Iterator for the TransformedList
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	A Bag that is backed by a TreeMap.
TreeBag	Implements `SortedBag`, using a `TreeMap` to provide the data storage.
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 buffer implementation.
UnboundedFifoBuffer	UnboundedFifoBuffer is a very efficient implementation of `Buffer` that can grow to any size.
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 `java.util.Map.Entry 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.