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 |
FastHashMap |
A customized implementation of |
FastTreeMap |
A customized implementation of |
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 |
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 |
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. |