Decorates another Bag
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Provides a base decorator that enables additional functionality to be added
to a BidiMap via decoration.
Constructor that wraps (not copies).
Decorates another Buffer
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Decorates another Collection
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Abstract BidiMap
implemented using two maps.
Creates an empty map, initialised by createMap
.
Creates an empty map using the two maps specified as storage.
Constructs a map that decorates the specified maps,
used by the subclass createBidiMap
implementation.
An abstract implementation of a hash-based map which provides numerous points for
subclasses to override.
Constructor only used in deserialization, do not use otherwise.
Constructs a new, empty map with the specified initial capacity and
default load factor.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor which performs no validation on the passed in parameters.
Constructor copying elements from another map.
Provides basic behaviour for decorating an iterator with extra functionality.
Constructor that decorates the specified iterator.
Abstract pair class to assist with creating KeyValue and MapEntry implementations.
Constructs a new pair with the specified key and given value.
An abstract implementation of a linked list which provides numerous points for
subclasses to override.
Constructor that does nothing intended for deserialization.
Constructs a list copying data from the specified collection.
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.
Constructor only used in deserialization, do not use otherwise.
Constructs a new, empty map with the specified initial capacity.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor which performs no validation on the passed in parameters.
Constructor copying elements from another map.
Decorates another List
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Provides basic behaviour for decorating a list iterator with extra functionality.
Constructor that decorates the specified iterator.
Abstract implementation of the
Bag
interface to simplify the creation
of subclass implementations.
Constructor needed for subclass serialisation.
Constructor that assigns the specified Map as the backing store.
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Abstract Pair class to assist with creating correct Map Entry implementations.
Constructs a new entry with the given key and given value.
Provides a base decorator that allows additional functionality to be added
to a Map Entry.
Constructor that wraps (not copies).
Provides basic behaviour for decorating a map iterator with extra functionality.
Constructor that decorates the specified iterator.
Provides a base decorator that enables additional functionality to be added
to an OrderedBidiMap via decoration.
Constructor that wraps (not copies).
Provides a base decorator that enables additional functionality to be added
to an OrderedMap via decoration.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Provides basic behaviour for decorating an ordered map iterator with extra functionality.
Constructor that decorates the specified iterator.
An abstract implementation of a hash-based map that allows the entries to
be removed by the garbage collector.
Constructor used during deserialization.
Constructs a new empty map with the specified reference types,
load factor and initial capacity.
Serializable subclass of AbstractCollectionDecorator.
Serializable subclass of AbstractListDecorator.
Serializable subclass of AbstractSetDecorator.
Decorates another Set
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Decorates another SortedBag
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Provides a base decorator that enables additional functionality to be added
to a SortedBidiMap via decoration.
Constructor that wraps (not copies).
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Decorates another SortedSet
to provide additional behaviour.
Constructor only used in deserialization, do not use otherwise.
Constructor that wraps (not copies).
Inserts the specified element at the specified position in this list.
Insert the specified element at the specified position in this list,
and shift all remaining elements up one position.
Adds an element to a specific index in the list if it is not already present.
Adds a new element to the list.
Adds a new element to the bag, incrementing its count in the underlying map.
This iterator does not support modification of its backing collection, and so will
always throw an UnsupportedOperationException
when this method is invoked.
(Violation)
Adds one copy the specified object to the Bag.
Adds an object to this heap.
Adds the given element to this buffer.
Adds the given element to this buffer.
If the buffer is full, the least recently added element is discarded so
that a new element can be inserted.
Adds an object to the collection, throwing UnsupportedOperationException
unless a CollectionMutator strategy is specified.
Appends the specified element to the end of this list.
Adds an object to the list.
Adds a new element to the bag by incrementing its count in the
underlying map.
Appends the specified element to the end of this list.
Adds an item, which compares as after all items known to the Comparator.
Throws UnsupportedOperationException
.
This iterator does not support modification of its backing array's size, and so will
always throw an UnsupportedOperationException
when this method is invoked.
Override to validate the object being added to ensure it matches
the predicate.
Adds an element to the buffer.
Invokes the underlying ListIterator.add(Object)
method.
Adds an element to the list if it is not already present.
Add always throws UnsupportedOperationException
.
Adds the given element to this buffer.
Adds the given element to this buffer.
Adds a new element to the bag, incrementing its count in the map.
Adds nCopies
copies of the specified object to the Bag.
Adds a new element to the bag by incrementing its count in the map.
Adds nCopies
copies of the specified object to the Bag.
Adds nCopies
copies of the specified object to the Bag.
Called when an object is to be added to the composite.
Invokes
add(Object)
for each element in the given collection.
Adds a collection of elements to this collection, throwing
UnsupportedOperationException unless a CollectionMutator strategy is specified.
Appends all of the elements in the specified collection to the end of
this list, in the order that they are returned by the specified
Collection
's Iterator
.
Invokes
add(Object)
for each element in the given collection.
Append all of the elements in the specified Collection to the end
of this list, in the order that they are returned by the specified
Collection's Iterator.
Override to validate the objects being added to ensure they match
the predicate.
Adds an element to the end of the list if it is not already present.
Adds all elements in the enumeration to the given collection.
Adds all elements in the iteration to the given collection.
Adds all elements in the array to the given collection.
Inserts all of the elements in the specified collection into this
list at the specified position.
Insert all of the elements in the specified Collection at the specified
position in this list, and shift any previous elements upwards as
needed.
Adds a collection of objects to the end of the list avoiding duplicates.
Called when a collection is to be added to the composite.
Adds a new item, which compares as equal to the given existing item.
Add a Comparator to the end of the chain using the
forward sort order
Add a Comparator to the end of the chain using the
given sort order
Add an additional collection to this composite.
Add a Set to this composite
Add two additional collections to this composite.
Add two sets to this composite
Add these Collections to the list of collections in this composite
Add an array of sets to this composite
Add an additional Map to the composite.
Adds an entry into this map.
Adds an entry into this map, maintaining insertion order.
Inserts the specified element at the beginning of this list.
Adds the given Iterator
to the iterators being collated.
Add an Iterator to the end of the chain
Inserts the specified element at the end of this list.
Adds a new key-value mapping into this map.
Adds a new key-value mapping into this map.
Inserts a new node into the list.
Inserts a new node into the list.
Creates a new node with the specified object as its
value
and inserts it after node
.
Creates a new node with the specified object as its
value
and inserts it before node
.
Adds a node to the cache, if the cache isn't full.
Add a property to the configuration.
The entry after this one in the order
Collections in the composite
Predicate implementation that returns true if all the predicates return true.
Create a new Predicate that returns true only if all of the specified
predicates are true.
Constructor that performs no validation.
Create a new Predicate that returns true only if all of the specified
predicates are true.
Predicate implementation that returns true if both the predicates return true.
Constructor that performs no validation.
Create a new Predicate that returns true only if both of the specified
predicates are true.
Predicate implementation that returns true if any of the predicates return true.
Create a new Predicate that returns true if any of the specified
predicates are true.
Constructor that performs no validation.
Create a new Predicate that returns true if any of the specified
predicates are true.
The array to iterate over
Implements an Iterator
over any array.
Constructor for use with setArray
.
Constructs an ArrayIterator that will iterate over the values in the
specified array.
Gets an iterator over an object or primitive array.
Constructs an ArrayIterator that will iterate over the values in the
specified array from a specific start index.
Gets an iterator over the end part of an object or primitive array.
Construct an ArrayIterator that will iterate over a range of values
in the specified array.
Gets an iterator over part of an object or primitive array.
Gets an iterator over an object array.
Gets an iterator over the end part of an object array.
Gets an iterator over part of an object array.
Implements a ListIterator
over an array.
Constructor for use with setArray
.
Constructs an ArrayListIterator that will iterate over the values in the
specified array.
Gets a list iterator over an object or primitive array.
Constructs an ArrayListIterator that will iterate over the values in the
specified array from a specific start index.
Gets a list iterator over the end part of an object or primitive array.
Construct an ArrayListIterator that will iterate over a range of values
in the specified array.
Gets a list iterator over part of an object or primitive array.
Gets a list iterator over an object array.
Gets a list iterator over the end part of an object array.
Gets a list iterator over part of an object array.
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.
Constructs a new empty ArrayStack
.
Constructs a new empty ArrayStack
with an initial size.
If true, the first element as determined by the sort order will
be returned.
Creates a Closure that calls a Transformer each time it is called.
Gets an enumeration that wraps an iterator.
Gets an iterator that provides an iterator view of the given enumeration.
Gets an iterator that provides an iterator view of the given enumeration
that will remove elements from the specified collection.
Gets an unmodifiable List view of the keys.
Gets an unmodifiable List view of the keys which changes as the map changes.
Gets an unmodifiable view of the order of the Set.
Create a new Predicate that wraps a Transformer.
Gets an unmodifiable view as a Set.
Creates a Transformer that calls a Closure each time the transformer is used.
Creates a Transformer that calls a Factory each time the transformer is used.
Creates a Transformer that calls a Predicate each time the transformer is used.
Prevents any operations from occurring on this map while the
given Runnable
executes.
Prevents any operations from occurring on this map while the
given Runnable
executes.
Actually walks the bag to make sure the count is correct and
resets the running total
Calculates the new capacity of the map.
Calculates the new threshold of the map, where it will be resized.
Whether remove is allowed at present
Whether remove is allowed at present
Whether remove is allowed at present
Whether remove is allowed at present
Returns the number of occurrences of obj in coll.
Constructs a new empty map with default size and load factor.
Constructs a new, empty map with the specified initial capacity.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor copying elements from another map.
Closure implementation that chains the specified closures together.
Create a new Closure that calls each closure in turn, passing the
result into the next closure.
Create a new Closure that calls two Closures, passing the result of
the first into the second.
Constructor that performs no validation.
Create a new Closure that calls each closure in turn, passing the
result into the next closure.
Gets a comparator that compares using a collection of Comparator
s,
applied in (default iterator) sequence until one returns not equal or the
collection is exhausted.
Gets a comparator that compares using two Comparator
s.
Gets a comparator that compares using an array of Comparator
s, applied
in sequence until one returns not equal or the array is exhausted.
Gets an iterator that iterates through a collections of Iterator
s
one after another.
Gets an iterator that iterates through two Iterator
s
one after another.
Gets an iterator that iterates through an array of Iterator
s
one after another.
Transformer implementation that chains the specified transformers together.
Create a new Transformer that calls each transformer in turn, passing the
result into the next transformer.
Create a new Transformer that calls two transformers, passing the result of
the first into the second.
Constructor that performs no validation.
Create a new Transformer that calls each transformer in turn, passing the
result into the next transformer.
Checks whether the index is valid or not.
Checks the capacity of the map and enlarges it if necessary.
Check to ensure that input keys are valid MultiKey objects.
Checks to see whether the comparator is now locked against further changes.
Checks the modification count of the list is the value that this
object expects.
Override superclass modCount check, and replace it with our valid flag.
Override to validate an object set into the map via setValue
.
Override to transform the value when using setValue
.
CircularFifoBuffer is a first in first out buffer with a fixed size that
replaces its oldest element if full.
Constructor that creates a buffer with the default size of 32.
Constructor that creates a buffer from the specified collection.
Constructor that creates a buffer with the specified size.
Clears the map, resetting the size to zero and nullifying references
to avoid garbage collection issues.
Clears the map, resetting the size to zero and nullifying references
to avoid garbage collection issues.
Clears the bag by clearing the underlying map.
This method reinitializes the bean map to have default values for the
bean's properties.
Clears all elements from queue.
Removes all of the elements from this collection .
Calls clear()
on all composited Maps.
Removes all of the elements from this list.
Clears the bag by clearing the underlying map.
Removes all mappings from this map
Remove all of the elements from this list.
Remove all mappings from this map.
Remove all mappings from this map.
Clears the map, resetting the size to zero and nullifying references
to avoid garbage collection issues.
Clears all elements from the buffer.
Clear all elements from queue.
Invokes the underlying Map.clear()
method.
Clears the map of all entries.
Clear all elements from queue.
Removes all mappings from this map.
Clears the list, removing all entries.
Clear a property in the configuration.
Clones the map without cloning the keys or values.
Clone this bean map using the following process:
- If there is no underlying bean, return a cloned BeanMap without a
bean.
Clones the map without cloning the keys or values.
Return a shallow copy of this FastArrayList
instance.
Return a shallow copy of this FastHashMap
instance.
Return a shallow copy of this FastTreeMap
instance.
Clones the map without cloning the keys or values.
Clones the map without cloning the keys or values.
Clones the map without cloning the keys or values.
Clones the map without cloning the keys or values.
clone() - method in class org.apache.commons.collections.map.
LRUMap Clones the map without cloning the keys or values.
Clones the map creating an independent copy.
Clones the map without cloning the keys or values.
Creates a shallow copy of this object, preserving the internal structure
by copying only references.
Clones the map without cloning the key or value.
Transformer implementation that returns a clone of the input object.
Gets a transformer that returns a clone of the input
object.
Mark this cursor as no longer being needed.
Mark this cursor as no longer being needed.
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.
Constructor that performs no validation.
ClosureUtils
provides reference implementations and utilities
for the Closure functor interface.
This class is not normally instantiated.
Gets an iterator that provides an ordered iteration over the elements
contained in a collection of Iterator
s.
Gets an iterator that provides an ordered iteration over the elements
contained in a collection of ordered Iterator
s.
Gets an iterator that provides an ordered iteration over the elements
contained in an array of Iterator
s.
Provides an ordered iteration over the elements contained in
a collection of ordered Iterators.
Constructs a new CollatingIterator
.
Constructs a new CollatingIterator
that will used the
specified comparator for ordering.
Constructs a new CollatingIterator
that will use the
specified comparator to provide ordered iteration over the collection
of iterators.
Constructs a new CollatingIterator
that will used the
specified comparator for ordering and have the specified initial
capacity.
Constructs a new CollatingIterator
that will use the
specified comparator to provide ordered iteration over the two
given iterators.
Constructs a new CollatingIterator
that will use the
specified comparator to provide ordered iteration over the array
of iterators.
Returns a new Collection consisting of the elements of inputCollection transformed
by the given transformer.
Transforms all elements from inputCollection with the given transformer
and adds them to the outputCollection.
Transforms all elements from the inputIterator with the given transformer
and adds them to the outputCollection.
Transforms all elements from the inputIterator with the given transformer
and adds them to the outputCollection.
The collection being decorated
The collection to decorate
Pluggable strategy to handle changes to the composite.
Provides utility methods and decorators for Collection
instances.
CollectionUtils
should not normally be instantiated.
Combines an existing Hashtable with this Hashtable.
A Comparator
that compares
Comparable
objects.
Constructor whose use should be avoided.
The comparator used to order the elements
Return the comparator used to order this map, or null
if this map uses its keys' natural order.
Gets the comparator being used for this buffer, null is natural order.
Returns the comparator associated with this sorted set, or null
if it uses its elements' natural ordering.
Returns the comparator associated with this sorted set, or null
if it uses its elements' natural ordering.
The list of comparators in the chain.
A ComparatorChain is a Comparator that wraps one or
more Comparators in sequence.
Construct a ComparatorChain with no Comparators.
Construct a ComparatorChain with a single Comparator,
sorting in the forward order
Construct a Comparator chain with a single Comparator,
sorting in the given order
Construct a ComparatorChain from the Comparators in the
List.
Construct a ComparatorChain from the Comparators in the
given List.
Provides convenient static utility methods for Comparator
objects.
ComparatorUtils should not normally be instantiated.
Compares two non-
null
Boolean
objects
according to the value of
trueFirst
.
Compares two arbitrary Objects.
Compare the two Comparable
arguments.
Perform comparisons on the Objects as per
Comparator.compare(o1,o2).
Compares two objects according to the order of this Comparator.
Perform a comparison between two objects.
Compares two objects using the comparator if specified, or the
natural order otherwise.
Compares two objects in reverse order.
Returns the result of comparing the values from the transform operation.
Decorates a collection of other collections to provide a single unified view.
Create an empty CompositeCollection.
Create a Composite Collection with only coll composited.
Create a CompositeCollection with colls as the initial list of
composited collections.
Decorates a map of other maps to provide a single unified view.
Create a new, empty, CompositeMap.
Create a new CompositeMap with two composited Map instances.
Create a new CompositeMap with two composited Map instances.
Create a new CompositeMap which composites all of the Map instances in the
argument.
Create a new CompositeMap which composites all of the Map instances in the
argument.
Decorates a set of other sets to provide a single unified view.
Create an empty CompositeSet
Create a CompositeSet with just set
composited
Create a composite set with sets as the initial set of composited Sets
Factory implementation that returns the same constant each time.
Constructor that performs no validation.
Creates a Factory that will return the same object each time the factory
is used.
Transformer implementation that returns the same constant each time.
Constructor that performs no validation.
Creates a Transformer that will return the same object each time the
transformer is used.
Determines if the bag contains the given element by checking if the
underlying map contains the element as a key.
Checks whether this composite collection contains the object.
Returns true if this list contains the specified element.
Determines if the bag contains the given element by checking if the
underlying map contains the element as a key.
Return true
if this list contains the specified element.
Searches for the presence of an object in the list.
Determines if the bag contains the given elements.
(Violation)
Returns true
if the bag contains all elements in
the given collection, respecting cardinality.
Checks whether this composite contains all the elements in the specified collection.
Returns true if this list contains all of the elements of the
specified collection.
Determines if the bag contains the given elements.
Return true
if this list contains all of the elements
in the specified Collection.
Returns true
if the bag contains all elements in
the given collection, respecting cardinality.
Returns true
iff at least one element is in both collections.
Checks whether the map contains the specified key.
Checks whether the map contains the specified key.
Returns true if the bean defines a property with the given name.
Returns true if this map contains a mapping for the specified
key.
Returns true if this map contains a mapping for the specified
key.
Return true
if this map contains a mapping for the
specified key.
Return true
if this map contains a mapping for the
specified key.
Checks whether the map contains the specified key.
Invokes the underlying Map.containsKey(Object)
method.
Returns true
if this map contains the given key.
Implements Map.containsKey(Object)
.
Checks whether the map contains the specified key.
Implements Map.containsKey(Object)
.
Checks if the map contains the specified key.
Checks whether this map contains the a mapping for the specified key.
Checks whether the map contains the specified multi-key.
Checks whether the map contains the specified multi-key.
Checks whether the map contains the specified multi-key.
Checks whether the map contains the specified multi-key.
Checks whether the map contains the specified value.
Checks whether the map contains the specified value.
Checks whether the map contains the specified value.
Returns true if the bean defines a property whose current value is
the given object.
Returns true if this map maps one or more keys to the
specified value.
Returns true if this map maps one or more keys to the
specified value.
Return true
if this map contains one or more keys mapping
to the specified value.
Return true
if this map contains one or more keys mapping
to the specified value.
Checks whether the map contains the specified value.
Checks whether the map contains the value specified.
Checks whether the map contains the value specified.
Invokes the underlying Map.containsValue(Object)
method.
Implements Map.containsValue(Object)
.
Checks whether the map contains the specified value.
Implements Map.containsValue(Object)
.
Checks if the map contains the specified value.
Checks whether this map contains the a mapping for the specified value.
Checks whether the collection at the specified key contains the value.
Converts input keys to another object for storage in the map.
Convert a standard properties class into a configuration class.
Converts the given value to the given type.
Counts the number of elements in the input collection that match the predicate.
Always throws an exception.
Creates an object using the stored constructor.
Creates a new instance of the subclass.
Creates a new instance of this object.
Creates a new instance of this object.
Creates a new instance of the map value Collection container.
Create an instance of the map used for storage when in delegation mode.
Creates an entry to store the key-value data.
Creates an entry to store the data.
Creates a ReferenceEntry instead of a HashEntry.
Creates an entry to store the data.
Creates an entry set iterator.
Creates an entry set iterator.
Creates an entry set iterator.
Creates an entry set iterator.
Creates a new node with previous, next and element all set to null.
Creates a key set iterator.
Creates a key set iterator.
Creates an key set iterator.
Creates a key set iterator.
Creates a new instance of the map used by the subclass to store data.
Creates a new node with the specified properties.
Creates a new node, either by reusing one from the cache or creating
a new one.
Creates an iterator for the sublist.
Creates a list iterator for the sublist.
Creates a values iterator.
Creates a values iterator.
Creates an values iterator.
Creates a values iterator.
Creates an array of parameters to pass to the given mutator method.
The index of the current iterator
An extended ListIterator
that allows concurrent changes to
the underlying list.
Returns a ListIterator
for iterating through the
elements of this list.
Returns a ListIterator
for iterating through the
elements of this list, initialized such that
ListIterator.next
will return the element at
the specified index (if any) and ListIterator.previous
will return the element immediately preceding it (if any).
A doubly-linked list implementation of the List
interface,
supporting a ListIterator
that allows concurrent modifications
to the underlying list.
A List
implementation with a ListIterator
that
allows concurrent modifications to the underlying list.
Constructor that creates.
Constructor that copies the specified collection
A list of the cursor currently open on this list
Prints the given map with nice line breaks.
Factory method to create a synchronized collection.
Factory method to create an unmodifiable collection.
Factory method to create a typed collection.
Factory method to create a predicated (validating) collection.
Factory method to create a transforming collection.
Decorates the specified iterator such that it cannot be modified.
Factory method to create a fixed size list.
Factory method to create an ordered set using the supplied list to retain order.
Factory method to create a SetList using the supplied list to retain order.
Factory method to create a synchronized list.
Factory method to create an unmodifiable list.
Factory method to create a typed list.
Factory method to create a lazily instantiating list.
Factory method to create a predicated (validating) list.
Factory method to create a transforming list.
Decorates the specified iterator such that it cannot be modified.
Factory method to create a fixed size map.
Factory method to create an ordered map.
Factory method to create a set from a map.
Factory method to create an unmodifiable map.
Factory method to create a typed map.
Factory method to create a set from a map.
Factory method to create a lazily instantiated map.
Factory method to create a predicated (validating) map.
Factory method to create a lazily instantiated map.
Factory method to create a transforming map.
Factory method to create a synchronized bag.
Factory method to create an unmodifiable bag.
Factory method to create a typed bag.
Factory method to create a predicated (validating) bag.
Factory method to create a transforming bag.
Factory method to create an unmodifiable map.
Factory method to create an unmodifiable bounded collection.
Factory method to create a blocking buffer.
Factory method to create a synchronized buffer.
Factory method to create an unmodifiable buffer.
Factory method to create a typed list.
Factory method to create a predicated (validating) buffer.
Factory method to create a transforming buffer.
Decorates the specified map to add the MultiKeyMap API and fast query.
Decorates the specified iterator such that it cannot be modified.
Factory method to create an unmodifiable map.
Factory method to create an unmodifiable sorted map.
Decorates the specified iterator such that it cannot be modified.
Factory method to create a synchronized sorted bag.
Factory method to create an unmodifiable bag.
Factory method to create a typed sorted bag.
Factory method to create a predicated (validating) bag.
Factory method to create a transforming sorted bag.
Factory method to create an unmodifiable map.
Factory method to create an ordered set.
Factory method to create a synchronized set.
Factory method to create an unmodifiable set of Map Entry objects.
Factory method to create an unmodifiable set.
Factory method to create a typed set.
Factory method to create an ordered set specifying the list and set to use.
Factory method to create a predicated (validating) set.
Factory method to create a transforming set.
Factory method to create a fixed size sorted map.
Factory method to create an unmodifiable sorted map.
Factory method to create a typed sorted map.
Factory method to create a lazily instantiated sorted map.
Factory method to create a predicated (validating) sorted map.
Factory method to create a lazily instantiated sorted map.
Factory method to create a transforming sorted map.
Factory method to create a synchronized set.
Factory method to create an unmodifiable set.
Factory method to create a typed sorted set.
Factory method to create a predicated (validating) sorted set.
Factory method to create a transforming sorted set.
The decorated comparator.
Factory method to create an unmodifiable bounded collection.
The default capacity to use
The default load factor to use
The default threshold to use
A mutable KeyValue pair that does not implement MapEntry.
Constructs a new pair with a null key and null value.
Constructs a new pair from the specified MapEntry.
Constructs a new pair with the specified key and given value.
Constructs a new pair from the specified KeyValue.
A skeletal implementation of the
Bag
interface to minimize the effort required for target implementations.
Constructor that assigns the specified Map as the backing store.
A default implementation of java.util.Map.Entry
A restricted implementation of java.util.Map.Entry
that prevents
the MapEntry contract from being broken.
Constructs a new DefaultMapEntry
with a null key
and null value.
Constructs a new DefaultMapEntry
with the given
key and given value.
Constructs a new entry from the specified MapEntry.
Constructs a new DefaultMapEntry
with the given
key and given value.
Constructs a new entry with the specified key and given value.
Constructs a new entry from the specified KeyValue.
Maps primitive Class types to transformers.
Kills an entry ready for the garbage collector.
Returns a Collection
containing the exclusive disjunction
(symmetric difference) of the given Collection
s.
Display the configuration for debugging purposes to System.out.
Read the map in using a custom routine.
Reads the map data from the stream.
Deserializes the data held in this object to the stream specified.
Replaces the superclassm method to read the state of this class.
Reads the data necessary for put()
to work in the superclass.
Red-Black tree-based implementation of Map.
Construct a new DoubleOrderedMap
Constructs a new DoubleOrderedMap from an existing Map, with keys and
values sorted
Creates a Closure that will call the closure once and then repeatedly
until the predicate returns false.
Writes the map data to the stream.
Serializes the data held in this object to the stream specified.
Write the map out using a custom routine.
Replaces the superclass method to store the state of this class.
Writes the data necessary for put()
to work in deserialization.
Implementation of BidiMap
that uses two HashMap
instances.
Creates an empty HashBidiMap
.
Constructs a HashBidiMap
and copies the mappings from
specified Map
.
Constructs a HashBidiMap
that decorates the specified maps.
Implementation of BidiMap
that uses two TreeMap
instances.
Creates an empty DualTreeBidiMap
Constructs a DualTreeBidiMap
using the specified Comparator.
Constructs a DualTreeBidiMap
and copies the mappings from
specified Map
.
Constructs a DualTreeBidiMap
that decorates the specified maps.
Create a new Predicate that returns true if one, but not both, of the
specified predicates are true.
The elements in this buffer.
Return true
if this stack is currently empty.
An empty unmodifiable bag.
An empty unmodifiable buffer.
An empty unmodifiable collection.
An iterator over no elements.
An empty unmodifiable list.
A list iterator over no elements.
An empty unmodifiable map.
A map iterator over no elements.
An ordered iterator over no elements.
An ordered map iterator over no elements.
An empty unmodifiable set.
An empty unmodifiable sorted bag.
An empty unmodifiable sorted map.
An empty unmodifiable sorted set.
Provides an implementation of an empty iterator.
Provides an implementation of an empty list iterator.
Gets an empty list iterator.
Provides an implementation of an empty map iterator.
Gets an empty map iterator.
Provides an implementation of an empty ordered iterator.
Gets an empty ordered iterator.
Provides an implementation of an empty ordered map iterator.
Gets an empty ordered map iterator.
Changes the size of the data structure to the capacity proposed.
Increase the capacity of this ArrayList
instance, if
necessary, to ensure that it can hold at least the number of elements
specified by the minimum capacity argument.
The Map.Entry
to decorate
Gets the after
field from a LinkEntry
.
Gets the before
field from a LinkEntry
.
Gets the hashCode
field from a HashEntry
.
Convenience method for getting an iterator over the entries.
Gets the key
field from a HashEntry
.
Gets the next
field from a HashEntry
.
Gets an entrySet view of the map.
Gets the entrySet view of the map.
Returns a set view of this map's entries.
Gets a Set of MapEntry objects that are the mappings for this BeanMap.
Returns a set view of the mappings contained in this map.
Returns a set view of the mappings contained in this map.
Return a collection view of the mappings contained in this map.
Return a collection view of the mappings contained in this map.
Gets the entrySet view of the map.
Invokes the underlying Map.entrySet()
method.
Returns a set view of this map's entries.
Implements Map.entrySet()
.
Gets the entrySet view of the map.
Implements Map.entrySet()
.
Returns a set view of the entries contained in this map in key order.
Constructs a new view of the BidiMap.
Returns a set view of the mappings contained in this map.
Inner class EntrySetIterator.
Implements a MapIterator
using a Map entrySet.
Gets the value
field from a HashEntry
.
Adapter to make Enumeration
instances appear
to be Iterator
instances.
Constructs a new EnumerationIterator
that provides
an iterator view of the given enumeration.
Constructs a new EnumerationIterator
that will remove
elements from the specified collection.
Provides utility methods for Enumeration
instances.
EnumerationUtils is not normally instantiated.
Predicate implementation that returns true if the input is the same object
as the one stored in this predicate by equals.
Constructor that performs no validation.
Creates a Predicate that checks if the input object is equal to the
specified object using equals().
Compares this map with another.
Compares this Bag to another.
Compares this Map Entry with another Map Entry.
Compares this map entry to another.
Returns true
iff that Object is
is a Comparator
whose ordering is known to be
equivalent to mine.
Returns true
iff that Object is
is a Comparator
whose ordering is
known to be equivalent to mine.
Returns true
iff that Object is
is a Comparator
whose ordering is known to be
equivalent to mine.
Checks if this Map equals another as per the Map specification.
Compares the specified object with this list for equality.
Compares this Map Entry with another Map Entry.
Returns true if the given object is not null, has the precise type
of this bag, and contains the same number of occurrences of all the
same elements.
Compares this Map Entry with another Map Entry.
Compare the specified object with this list for equality.
Compare the specified object with this list for equality.
Compare the specified object with this list for equality.
Compares this map with another.
Compares this object to another.
Determines whether the specified object represents a comparator that is
equal to this comparator.
Invokes the underlying Map.equals(Object)
method.
Returns true
iff that Object is
is a Comparator
whose ordering is known to be
equivalent to mine.
Implements Map.equals(Object)
.
Compares this map with another.
Implements Map.equals(Object)
.
Compares this map to another, as per the Map specification.
Compares this Map Entry with another Map Entry.
Compares for equals as per the API.
Evaluates the predicate returning true if all predicates return true.
Evaluates the predicate returning true if both predicates return true.
Evaluates the predicate returning true if any predicate returns true.
Evaluates the predicate returning true if the input equals the stored value.
Evaluates the predicate always throwing an exception.
Evaluates the predicate returning false always.
Evaluates the predicate returning true if the input object is identical to
the stored object.
Evaluates the predicate returning true if the input object is of the correct type.
Evaluates the predicate returning false if any stored predicate returns false.
Evaluates the predicate returning true if the object does not equal null.
Evaluates the predicate returning the opposite to the stored predicate.
Evaluates the predicate returning the result of the decorated predicate
once a null check is performed.
Evaluates the predicate returning the result of the decorated predicate
once a null check is performed.
Evaluates the predicate returning the result of the decorated predicate
once a null check is performed.
Evaluates the predicate returning true if the input is null.
Evaluates the predicate returning true if only one decorated predicate
returns true.
Evaluates the predicate returning true if either predicate returns true.
Use the specified parameter to perform a test that returns true or false.
Evaluates the predicate returning the result of the decorated predicate
once the input has been transformed
Evaluates the predicate returning the result of the decorated transformer.
Evaluates the predicate returning true always.
Evaluates the predicate returning true if the input object hasn't been
received yet.
Closure implementation that always throws an exception.
Gets a Closure that always throws an exception.
Factory implementation that always throws an exception.
Gets a Factory that always throws an exception.
Predicate implementation that always throws an exception.
Gets a Predicate that always throws an exception.
Transformer implementation that always throws an exception.
Gets a transformer that always throws an exception.
Execute a list of closures.
Performs an action on the specified input object.
Always throw an exception.
Executes the closure count
times.
Executes the true or false closure accoring to the result of the predicate.
Executes the closure whose matching predicate returns true
Executes the closure by calling the decorated transformer.
Executes the closure until the predicate is false.
Answers true if a predicate is true for at least one element of a collection.
The modification count expected
The modification count that the list is expected to have.
The modification count expected
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.
Creates an empty extended properties object.
Creates and loads the extended properties from the specified file.
Creates and loads the extended properties from the specified file.
The factory to use to lazily instantiate the objects
The factory to use to construct elements
Defines a functor interface implemented by classes that create objects.
Transformer implementation that calls a Factory and returns the result.
Constructor that performs no validation.
FactoryUtils
provides reference implementations and utilities
for the Factory functor interface.
This class is not normally instantiated.
Predicate implementation that always returns false.
Gets a Predicate that always returns false.
Are we operating in "fast" mode?
Are we currently operating in "fast" mode?
Are we operating in "fast" mode?
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.
Construct a an empty list.
Construct a list containing the elements of the specified collection,
in the order they are returned by the collection's iterator.
Construct an empty list with the specified capacity.
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.
Construct an empty map with the specified capacity.
Construct an empty map with the specified capacity and load factor.
Construct a new map with the same mappings as the specified map.
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.
Construct a an empty map.
Construct an empty map with the specified comparator.
Construct a new map with the same mappings as the specified map,
sorted according to the keys's natural order
Construct a new map with the same mappings as the specified map,
sorted according to the same ordering
The file connected to this repository (holding comments and
such).
Filter the collection by applying a Predicate to each element.
Gets an iterator that filters another iterator.
Gets a list iterator that filters another list iterator.
Decorates an iterator such that only elements matching a predicate filter
are returned.
Constructs a new
FilterIterator
that will not function
until
setIterator
is invoked.
Constructs a new
FilterIterator
that will not function
until
setPredicate
is invoked.
Constructs a new FilterIterator
that will use the
given iterator and predicate.
A proxy
ListIterator
which
takes a
Predicate
instance to filter
out objects from an underlying
ListIterator
instance.
Constructs a new
FilterListIterator
that will not
function until
setPredicate
is invoked.
Constructs a new FilterListIterator
.
Constructs a new
FilterListIterator
that will not
function until
setListIterator
is invoked.
Finds the first element in the given collection which matches the given predicate.
Finds the next object in the iteration given any start object.
Finds the next object in the iteration given an iterator.
Returns the first (lowest) member.
Returns the first (lowest) member.
The first cached node, or null
if no nodes are cached.
Gets the first key in the map, which is the most recently inserted.
Return the first (lowest) key currently in this sorted map.
Gets the first key in this map by insert order.
Gets the first key currently in this map.
Gets the first (and only) key in the map.
Gets the first (lowest) key currently in this map.
A Comparator which imposes a specific order on a specific set of Objects.
Constructs an empty FixedOrderComparator.
Constructs a FixedOrderComparator which uses the order of the given list
to compare the objects.
Constructs a FixedOrderComparator which uses the order of the given array
to compare the objects.
Decorates another List
to fix the size preventing add/remove.
Constructor that wraps (not copies).
Returns a fixed-sized list backed by the given list.
Decorates another Map
to fix the size, preventing add/remove.
Constructor that wraps (not copies).
Returns a fixed-sized map backed by the given map.
Decorates another SortedMap
to fix the size blocking add/remove.
Constructor that wraps (not copies).
Returns a fixed-sized sorted map backed by the given sorted map.
A Map
implementation that stores data in simple fields until
the size is greater than 3.
Constructor copying elements from another map.
Executes the given closure on each element in the collection.
Closure implementation that calls another closure n times, like a for loop.
Creates a Closure that will call the closure count
times.
Constructor that performs no validation.
Runtime exception thrown from functors.
Constructs a new FunctorException
without specified
detail message.
Constructs a new FunctorException
with specified
detail message.
Constructs a new FunctorException
with specified
detail message and nested Throwable
root cause.
Constructs a new FunctorException
with specified
nested Throwable
root cause.
Returns the element on the top of the stack.
Returns the priority element.
Returns the least recently inserted element in this buffer.
Returns the least recently inserted element in this buffer.
get() - method in class org.apache.commons.collections.
Buffer Gets the next object from the buffer without removing it.
Gets the next object from the buffer without removing it.
Gets the next element to be removed without actually removing it (peek).
Gets the next object from the buffer without removing it.
Returns the next object in the buffer.
Returns the next object in the buffer.
Returns the element at the specified position in this list.
Return the element at the specified position in the list.
Decorate the get method to perform the lazy behaviour.
Gets the key at the specified index.
Gets the key at the specified index.
Gets the key at the specified index.
Gets the element at the specified index.
Gets the value mapped to the key specified.
Gets the value mapped to the key specified.
Returns the value of the bean's property with the given name.
Returns the value to which this map maps the specified key.
Returns the value to which this map maps the specified
key.
Return the value to which this map maps the specified key.
Return the value to which this map maps the specified key.
Gets the value mapped to the key specified.
Get the value for a key from the Map.
Gets the value mapped to the key specified.
Gets the collection of values associated with the specified key.
Invokes the underlying Map.get(Object)
method.
Returns the value associated with the given key, if any.
Implements Map.get(Object)
.
Gets the value mapped to the key specified.
Implements Map.get(Object)
.
Gets the value associated with the key.
Gets the value to which this map maps the specified key.
Returns the index
-th value in object
, throwing
IndexOutOfBoundsException
if there is no such element or
IllegalArgumentException
if object
is not an
instance of one of the supported types.
Gets the value mapped to the specified multi-key.
Gets the value mapped to the specified multi-key.
Gets the value mapped to the specified multi-key.
Gets the value mapped to the specified multi-key.
Gets the array that this iterator is iterating over.
Gets the array that this iterator is iterating over.
Gets the bag being decorated.
Gets the bag being decorated.
Returns the bean currently being operated on.
Gets the map being decorated.
Gets a Boolean from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a boolean, using the default value if the the conversion fails.
Get a boolean associated with the given configuration key.
Get a boolean associated with the given configuration key.
Returns a BooleanComparator instance that sorts
trueFirst
values before
!trueFirst
values.
Gets a boolean from a Map in a null-safe manner.
Gets a boolean from a Map in a null-safe manner,
using the default value if the the conversion fails.
Gets the buffer being decorated.
Gets the buffer being decorated.
Gets the buffer being decorated.
Gets the decorated buffer.
Gets a Byte from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a byte, using the default value if the the conversion fails.
Get a byte associated with the given configuration key.
Get a byte associated with the given configuration key.
Gets a byte from a Map in a null-safe manner.
Gets a byte from a Map in a null-safe manner,
using the default value if the the conversion fails.
Returns a Map
mapping each unique element in the given
Collection
to an Integer
representing the number
of occurrences of that element in the Collection
.
Gets the root cause of the exception.
Gets the root cause of the exception.
Gets the cause of this throwable.
Gets the closures, do not modify the array.
Gets the closures, do not modify the array.
Gets the collection being decorated.
Gets the collection mapped to the specified key.
Gets the collections being decorated.
Gets the Comparator
by which collatation occurs.
Returns the number of occurrence of the given element in this bag
by looking up its count in the underlying map.
Returns the number of occurrences (cardinality) of the given
object currently in the bag.
Returns the number of occurrence of the given element in this bag
by looking up its count in the underlying map.
Returns the number of occurrences (cardinality) of the given
object currently in the bag.
Returns the number of occurrences (cardinality) of the given
object currently in the bag.
Gets the default closure.
Gets the default transformer.
Gets a Double from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a double, using the default value if the the conversion fails.
Get a double associated with the given configuration key.
Get a double associated with the given configuration key.
Gets a double from a Map in a null-safe manner.
Gets a double from a Map in a null-safe manner,
using the default value if the the conversion fails.
Gets the end index to loop to.
Gets the key at the specified index.
Gets the entry mapped to the key specified.
Gets the entry mapped to the key specified.
Returns the underlying enumeration.
Gets the closure called when false.
Returns a BooleanComparator instance that sorts
false
values before true
values.
Returns true if this list is operating in fast mode.
Returns true if this map is operating in fast mode.
Returns true if this map is operating in fast mode.
Returns the element at the beginning of this list.
Return the entry for the "oldest" mapping.
Return the key for the "oldest" mapping.
Return the value for the "oldest" mapping.
Gets a Float from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a float, using the default value if the the conversion fails.
Get a float associated with the given configuration key.
Get a float associated with the given configuration key.
Gets a float from a Map in a null-safe manner.
Gets a float from a Map in a null-safe manner,
using the default value if the the conversion fails.
Gets the property value for including other properties files.
Factory returning the singleton instance.
Gets the singleton instance of a ComparableComparator.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory returning the singleton instance.
Factory to create the predicate.
Factory to create the identity predicate.
Factory method that performs validation.
Transformer method that performs validation.
Factory to create the predicate.
Factory to create the predicate.
Create a new Closure that calls each closure in turn, passing the
result into the next closure.
Create a new Transformer that calls each transformer in turn, passing the
result into the next transformer.
Factory to create the predicate.
Factory to create the predicate.
Factory method that performs validation.
Factory to create the transformer.
Create a new Closure that calls one of the closures depending
on the predicates.
Create a new Transformer that calls one of the transformers depending
on the predicates.
Factory method that performs validation.
Transformer method that performs validation.
Factory to create the identity predicate.
Factory to create the identity predicate.
Factory method that performs validation.
Factory method that performs validation.
Factory method that performs validation.
Factory method that performs validation and copies the parameter array.
Factory method that performs validation.
Factory to create the not predicate.
Factory to create the null exception predicate.
Factory to create the null false predicate.
Factory to create the null true predicate.
Factory method that performs validation.
Factory method that performs validation.
Factory method that performs validation.
Factory to create the predicate.
Factory to create the predicate.
Factory to create the predicate.
Factory to create the predicate.
Factory to create the predicate.
Factory to create the predicate.
Factory method that performs validation and copies the parameter arrays.
Factory method that performs validation and copies the parameter arrays.
Factory method that performs validation.
Factory to create the predicate.
Factory to create the predicate.
Factory method that performs validation.
Factory method that performs validation and copies the parameter array.
Gets an instance of this transformer calling a specific method with no arguments.
Gets an instance of this transformer calling a specific method with specific values.
The purpose of this method is to get the configuration resource
with the given name as an integer.
The purpose of this method is to get the configuration resource
with the given name as an integer, or a default value.
Gets a Integer from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
an integer, using the default value if the the conversion fails.
Get a int associated with the given configuration key.
Get a int associated with the given configuration key.
Get a int associated with the given configuration key.
Gets an int from a Map in a null-safe manner.
Gets an int from a Map in a null-safe manner,
using the default value if the the conversion fails.
Gets the iterator being decorated.
Gets the iterator this iterator is using.
Returns the underlying iterator.
Getter for property iterator.
Gets the iterator this iterator is using.
Gets a suitable Iterator for the given object.
Gets the list of Iterators (unmodifiable).
Get the list of Iterators (unmodifiable)
Gets the current key, which is the key returned by the last call
to next()
.
Gets the key from the pair.
Gets the key from the pair.
Gets the key from the pair.
Gets the current key, which is the key returned by the last call
to next()
.
Gets the current key, which is the key returned by the last call
to next()
.
Gets the key from the entry.
Gets the key from the Map Entry.
Gets the current key, which is the key returned by the last call
to next()
.
Gets the key from the pair.
Gets the current key, which is the key returned by the last call
to next()
.
Gets the key of this entry
Gets the current key, which is the key returned by the last call
to next()
.
Gets the key at the specified index.
Gets the key that is currently mapped to the specified value.
Gets the key that is currently mapped to the specified value.
Returns the key to which this map maps the specified value.
Returns the key to which this map maps the specified value.
Get the list of the keys contained in the configuration
repository.
Gets a clone of the array of keys.
Get the list of the keys contained in the configuration
repository that match the specified prefix.
Returns the element at the end of this list.
Return the entry for the "newest" mapping.
Return the key for the "newest" mapping.
Gets the last node returned.
Return the value for the "newest" mapping.
Gets the list being decorated.
Gets the list being decorated.
Returns the
org.apache.commons.collections.CursorableLinkedList.Listable
at the specified index.
Gets the iterator being decorated.
Gets the iterator this iterator is using.
Getter for property iterator.
Gets a Long from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a long, using the default value if the the conversion fails.
Get a long associated with the given configuration key.
Get a long associated with the given configuration key.
Gets a long from a Map in a null-safe manner.
Gets a long from a Map in a null-safe manner,
using the default value if the the conversion fails.
Utility method for implementations to access the map that backs
this bag.
Gets the map being decorated.
Utility method for implementations to access the map that backs
this bag.
Gets the map to lookup in.
Gets a Map from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a map, using the default value if the the conversion fails.
Gets the map being decorated.
Gets the iterator being decorated.
Gets the maximum size of the cache.
Getter for property maximumSize.
Gets the node at a particular index.
Gets a node from the cache.
Gets a Number from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a number, using the default value if the the conversion fails.
Gets from a Map in a null-safe manner.
Looks up the given key in the given map, converting null into the
given default value.
Gets the map being decorated.
Gets the map being decorated.
Gets the iterator being decorated.
Gets the predicate this iterator is using.
Gets the predicate this iterator is using.
Gets the predicate in use.
Gets the predicates, do not modify the array.
Gets the two predicates being decorated as an array.
Gets the predicates, do not modify the array.
Gets the predicates, do not modify the array.
Gets the predicate being decorated.
Gets the predicate being decorated.
Gets the predicate being decorated.
Gets the predicate being decorated.
Gets the predicates, do not modify the array.
Gets the two predicates being decorated as an array.
Gets the predicates being decorated as an array.
Gets the predicates, do not modify the array.
Gets the predicates, do not modify the array.
Gets the predicate being decorated.
Get a list of properties associated with the given
configuration key.
Get a list of properties associated with the given
configuration key.
Gets a property from the configuration.
Returns the accessor for the property with the given name.
Returns the accessor for the property with the given name.
Gets the set being decorated.
Gets the set being decorated.
Gets a Short from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a short, using the default value if the the conversion fails.
Get a short associated with the given configuration key.
Get a short associated with the given configuration key.
Gets a short from a Map in a null-safe manner.
Gets a short from a Map in a null-safe manner,
using the default value if the the conversion fails.
Gets the bag being decorated.
Gets the decorated sorted bag.
Gets the bag being decorated.
Gets the map being decorated.
Gets the map being decorated.
Gets the map being decorated.
Gets the map being decorated.
Gets the map being decorated.
Gets the map being decorated.
Gets the sorted set being decorated.
Gets the start index to loop from.
Gets a String from a Map in a null-safe manner.
Looks up the given key in the given map, converting the result into
a string, using the default value if the the conversion fails.
Get a string associated with the given configuration key.
Get a string associated with the given configuration key.
Get an array of strings associated with the given configuration
key.
Gets the transformer in use.
Gets the transformer this iterator is using.
Gets the transformers, do not modify the array.
Gets the transformers, do not modify the array.
Gets the closure called when true.
Returns a BooleanComparator instance that sorts
true
values before false
values.
Gets the type to compare to.
Returns the type of the property with the given name.
Returns a transformer for the given primitive type.
Gets the behavior for comparing unknown objects.
Gets the current value, which is the value associated with the last key
returned by next()
.
Gets the value from the pair.
Gets the value from the pair.
Gets the value of the node.
Gets the value from the pair.
Gets the current value, which is the value associated with the last key
returned by next()
.
Gets the current value, which is the value associated with the last key
returned by next()
.
Gets the value from the entry.
Gets the value from the Map Entry.
Gets the current value, which is the value associated with the last key
returned by next()
.
Gets the value from the pair.
Gets the current value, which is the value associated with the last key
returned by next()
.
Gets the value of this entry direct from the map.
Gets the current value, which is the value associated with the last key
returned by next()
.
Gets the value at the specified index.
Gets the value at the specified index.
Gets the value at the specified index.
Get a Vector of strings associated with the given configuration
key.
Get a Vector of strings associated with the given configuration
key.
Returns the mutator for the property with the given name.
Returns the mutator for the property with the given name.
Increases the size of the heap to support additional elements
Increases the size of the heap to support additional elements
Constant indicating that hard references should be used
Constant indicating that hard references should be used.
Gets the hash code for the key specified.
Gets the hash code for the key specified.
Gets the hash code for the key specified.
Gets the hash code for the specified multi-key.
Gets the hash code for the specified multi-key.
Gets the hash code for the specified multi-key.
Gets the hash code for the specified multi-key.
A
Bag
that is backed by a
HashMap
.
Implements Bag
, using a HashMap
to provide the
data storage.
Constructs an empty HashBag
.
Constructs an empty HashBag
.
Constructs a
Bag
containing all the members of the given
collection.
Constructs a bag containing all the members of the given collection.
Gets the standard Map hashCode.
Gets a hash code for the Bag compatible with the definition of equals.
Gets a hashCode compatible with the equals method.
Gets the hashcode of the entry using temporary hard references.
Implement a hash code for this comparator that is consistent with
equals
.
Implement a hash code for this comparator that is consistent with
equals
.
Implement a hash code for this comparator that is consistent with
equals
.
Gets a hash code for the Map as per the Map specification.
Returns the hash code value for this list.
Gets a hashCode compatible with the equals method.
Returns the hash code of the underlying map.
Gets a hashCode compatible with the equals method.
Return the hash code value for this list.
Return the hash code value for this map.
Return the hash code value for this map.
Gets the standard Map hashCode.
Gets the combined hash code that is computed from all the keys.
Implement a hash code for this comparator that is consistent with
equals(Object)
.
Invokes the underlying Map.hashCode()
method.
Implement a hash code for this comparator that is consistent with
equals
.
Implements Map.hashCode()
.
Gets the standard Map hashCode.
Implements Map.hashCode()
.
Gets the hash code, as per the Map specification.
Gets a hashCode compatible with the equals method.
Gets the hash code value for this map as per the API.
Generates a hash code using the algorithm specified in
java.util.List.hashCode()
.
Generates a hash code using the algorithm specified in
java.util.Set.hashCode()
.
A Map
implementation that is a general purpose alternative
to HashMap
.
Constructs a new empty map with default size and load factor.
Constructs a new, empty map with the specified initial capacity.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor copying elements from another map.
HashEntry used to store the data.
Gets the hash code for a MapEntry.
Gets the hash code for a MapEntry.
The current index into the array of buckets
Gets the index into the data storage for the hashCode specified.
MapIterator implementation.
Returns true if the underlying iterator has more elements.
Whether there is another element in the iteration
Checks to see if there are more entries still to be iterated.
Checks to see if there are more entries still to be iterated.
Checks to see if there are more entries still to be iterated.
Returns true if there are more elements to return from the array.
Returns true
if any child iterator has remaining elements.
Checks to see if there are more entries still to be iterated.
Returns true if the underlying enumeration has more elements.
Returns true if the underlying iterator contains an object that
matches the predicate.
Return true if any Iterator in the IteratorChain has a remaining element.
Returns true if there are more elements in the iterator.
Has the iterator any more elements.
Checks to see if there are more entries still to be iterated.
Returns true if there are more elements to return from the array.
Checks whether there are any more elements in the iteration to obtain.
Returns true if the underlying iterator has more elements.
Invokes the underlying ListIterator.hasNext()
method.
Is another object available from the iterator?
This returns true if the single object hasn't been returned yet.
Is another object available from the iterator?
This returns true if the single object hasn't been returned yet.
Checks to see if there are more entries still to be iterated.
Checks to see if there is a previous entry that can be iterated to.
Returns true if there are previous elements to return from the array.
Checks to see if there is a previous entry that can be iterated to.
Returns true if there are previous elements in the iterator.
Returns true if there are previous elements to return from the array.
Checks to see if there is a previous entry that can be iterated to.
Checks to see if there is a previous entry that can be iterated to.
Invokes the underlying ListIterator.hasPrevious()
method.
Is a previous object available from the iterator?
This returns true if the single object has been returned.
Checks to see if there is a previous entry that can be iterated to.
Header in the linked list
Return a view of the portion of this map whose keys are strictly
less than the specified key.
A Map
implementation that matches keys and values based
on ==
not equals()
.
Constructs a new empty map with default size and load factor.
Constructs a new, empty map with the specified initial capacity.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor copying elements from another map.
Predicate implementation that returns true if the input is the same object
as the one stored in this predicate.
Constructor that performs no validation.
Creates a Predicate that checks if the input object is equal to the
specified object by identity.
Closure implementation acts as an if statement calling one or other closure
based on a predicate.
Create a new Closure that calls one of two closures depending
on the specified predicate.
Constructor that performs no validation.
This is the name of the property that can point to other
properties file for including other properties files.
The current iterator index
The current iterator index
Given an Object, and an index, returns the nth value in the
object.
Given an Object, and a key (index), returns the value associated with
that key in the Object.
Returns the index in this list of the first occurrence of the specified
element, or -1 if this list does not contain this element.
Search for the first occurrence of the given argument, testing
for equality using the equals()
method, and return
the corresponding index, or -1 if the object is not found.
Gets the index of the specified key.
Gets the index of the specified key.
Gets the index of the specified key.
Searches for the index of an object in the list.
Initialise subclasses during construction, cloning or deserialization.
The equivalent of a default constructor, broken out so it can be called
by any constructor and by readObject
.
Initialise this subclass during construction.
Initialise this subclass during construction, cloning or deserialization.
The equivalent of a default constructor called
by any constructor and by readObject
.
Inserts an element into queue.
Insert an element into queue.
Insert an element into queue.
Inserts a new value into my
list, after the specified before element, and before the
specified after element
Internal list to hold the sequence of objects
Singleton predicate instance
Singleton instance of the iterator.
Singleton instance of the iterator.
Singleton instance of the iterator.
Singleton instance of the iterator.
Singleton instance of the iterator.
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Singleton predicate instance
Predicate implementation that returns true if the input is an instanceof
the type stored in this predicate.
Constructor that performs no validation.
Creates a Predicate that checks if the object passed in is of
a particular type, using instanceof.
Factory implementation that creates a new object instance by reflection.
Creates a Factory that can create objects of a specific type using
a no-args constructor.
Constructor that performs no validation.
Creates a Factory that can create objects of a specific type using
the arguments specified to this method.
Constructor that performs no validation.
Transformer implementation that creates a new object instance by reflection.
Gets a Transformer that expects an input Class object that it will instantiate.
Constructor that performs no validation.
Creates a Transformer that expects an input Class object that it will
instantiate.
Interpolate key names to handle ${key} stuff
Recursive handler for multiple levels of interpolation.
Returns a Collection
containing the intersection
of the given Collection
s.
Returns a new list containing all elements that are contained in
both given lists.
Informs all of my registered cursors that they are now
invalid.
Inverse view of this map.
Gets a view of this map where the keys and values are reversed.
Gets a view of this map where the keys and values are reversed.
Gets a view of this map where the keys and values are reversed.
Gets a view of this map where the keys and values are reversed.
Gets the inverse map for comparison.
Gets a view of this map where the keys and values are reversed.
Gets a view of this map where the keys and values are reversed.
Gets the inverse map for comparison.
Gets a view of this map where the keys and values are reversed.
Gets a view of this map where the keys and values are reversed.
Inverts the supplied map returning a new HashMap such that the keys of
the input are swapped with the values.
Creates a Closure that will invoke a specific method on the closure's
input object by reflection.
Creates a Closure that will invoke a specific method on the closure's
input object by reflection.
Creates a Predicate that invokes a method on the input object.
Creates a Predicate that invokes a method on the input object.
Transformer implementation that creates a new object instance by reflection.
Gets a Transformer that invokes a method on the input object.
Constructor that performs no validation.
Gets a Transformer that invokes a method on the input object.
Checks whether the heap is ascending or descending order.
Tests if the buffer is at capacity.
Checks whether the cache is full.
Is the loop a do-while loop.
Checks whether the map is currently empty.
Returns true if the underlying map is empty.
Checks whether the map is currently empty.
Returns true if this buffer is empty; false otherwise.
Returns true if this buffer is empty; false otherwise.
Checks whether this composite collection is empty.
Returns true if this map contains no key-value mappings.
Returns true if this list contains no elements.
Returns true if the underlying map is empty.
Test if this list has no elements.
Return true
if this map contains no mappings.
Return true
if this map contains no mappings.
Checks whether the map is currently empty.
Invokes the underlying Map.isEmpty()
method.
Returns true
if this map is empty.
Implements Map.isEmpty()
.
Checks whether the map is currently empty, which it never is.
Implements Map.isEmpty()
.
Checks if the size is currently zero.
Checks whether the map is empty or not.
Returns true if this buffer is empty; false otherwise.
Returns true if this buffer is empty; false otherwise.
Returns true iff the given Collection
s contain
exactly the same elements with exactly the same cardinalities.
Compares the specified key to the stored key.
Compares two keys, in internal converted form, to see if they are equal.
Compares two keys, in internal converted form, to see if they are equal.
Compares two keys for equals.
Compares two keys for equals.
Is the key equal to the combined key.
Is the key equal to the combined key.
Is the key equal to the combined key.
Is the key equal to the combined key.
Tests two lists for value-equality as per the equality contract in
java.util.List.equals(java.lang.Object)
.
Tests two sets for equality as per the equals()
contract
in java.util.Set.equals(java.lang.Object)
.
Compares the specified value to the stored value.
Compares two values, in external form, to see if they are equal.
Compares two values for equals.
Compares two values for equals.
Compares two values for equals.
Returns true if this collection is full and no new elements can be added.
Returns true if this collection is full and no new elements can be added.
Returns true if this collection is full and no new elements can be added.
Returns true if this map is full and no new elements can be added.
Returns true if this map is full and no new elements can be added.
Returns true if this map is full and no new mappings can be added.
Is the map currently full, always true.
Returns true if no more elements can be added to the Collection.
Has this configuration been intialized.
Indicate to client code whether property
resources have been initialized or not.
Whether the chain has been "locked".
ComparatorChain is "locked" after the first time
compare(Object,Object) is called
Determine if modifications can still be made to the
ComparatorChain.
Returns true if modifications cannot be made to the FixedOrderComparator.
Determine if modifications can still be made to the IteratorChain.
Returns true iff a is a proper sub-collection of b,
that is, iff the cardinality of e in a is less
than or equal to the cardinality of e in b,
for each element e in a, and there is at least one
element f such that the cardinality of f in b
is strictly greater than the cardinality of f in a.
Whether this LRUMap will scan until a removable entry is found when the
map is full.
Override to only return true when there is a value transformer.
Override to only return true when there is a value transformer.
Returns true iff a is a sub-collection of b,
that is, iff the cardinality of e in a is less
than or equal to the cardinality of e in b,
for each element e in a.
Defines a map that can be iterated directly without needing to create an entry set.
The iterator being wrapped
The iterator being decorated
The iterator being decorated
The iterator being decorated
The iterator being decorated
The iterator being decorated
Gets an iterator over the bag elements.
Returns an Iterator
over the entire set of members,
including copies due to cardinality.
Returns an iterator over this heap's elements.
Returns an iterator over this buffer's elements.
Returns an iterator over this buffer's elements.
Gets an iterator over all the collections in this composite.
Returns a fail-fast iterator.
Returns an iterator that does not support concurrent modification.
Return an iterator over the elements in this list in proper sequence.
Returns an iterator over this heap's elements.
Gets an iterator over the keys.
Iterators must be manually synchronized.
Gets an iterator over the list.
Returns an iterator over this buffer's elements.
Returns an iterator over this buffer's elements.
Gets an iterator for the collection mapped to the specified key.
An IteratorChain is an Iterator that wraps a number of Iterators.
Construct an IteratorChain with no Iterators.
Constructs a new IteratorChain
over the collection
of iterators.
Construct an IteratorChain with a single Iterator.
Constructs a new IteratorChain
over the two
given iterators.
Constructs a new IteratorChain
over the array
of iterators.
Adapter to make an Iterator
instance appear to be
an Enumeration
instance.
Constructs a new
IteratorEnumeration
that will not
function until
setIterator
is
invoked.
Constructs a new IteratorEnumeration
that will use
the given iterator.
Provides static utility methods and decorators for Iterator
instances.
IteratorUtils is not normally instantiated.
The current (last returned) entry
Returns the last (highest) member.
Returns the last (highest) member.
last() - method in class org.apache.commons.collections.bag.
TreeBag Returns the index in this list of the last occurrence of the specified
element, or -1 if this list does not contain this element.
Search for the last occurrence of the given argument, testing
for equality using the equals()
method, and return
the corresponding index, or -1 if the object is not found.
Gets the last index of the specified key.
Holds the index of the last item returned by a call to next()
or previous()
.
Holds the index of the last item returned by a call to next()
or previous()
.
Gets the last key in the map, which is the first inserted.
Return the last (highest) key currently in this sorted map.
Gets the last key in this map by insert order.
Gets the last key currently in this map.
Gets the last (and only) key in the map.
Gets the last (highest) key currently in this map.
The "last used" Iterator is the Iterator upon which
next() or hasNext() was most recently called
used for the remove() operation only
The last used iterator, needed for remove()
Decorates another List
to create objects in the list on demand.
Constructor that wraps (not copies).
Returns a "lazy" list whose elements will be created on demand.
Decorates another Map
to create objects in the map on demand.
Constructor that wraps (not copies).
Returns a "lazy" map whose values will be created on demand.
Constructor that wraps (not copies).
Returns a "lazy" map whose values will be created on demand.
Decorates another SortedMap
to create objects in the map on demand.
Constructor that wraps (not copies).
Returns a "lazy" sorted map whose values will be created on demand.
Constructor that wraps (not copies).
Returns a "lazy" sorted map whose values will be created on demand.
A list iterator over the linked list.
Create a ListIterator for a list.
A Map
implementation that maintains the order of the entries.
Constructs a new empty map with default size and load factor.
Constructs a new, empty map with the specified initial capacity.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor copying elements from another map.
The sublist implementation for AbstractLinkedList.
A list iterator over the linked sub list.
LinkEntry that stores the data.
Base Iterator that iterates in link order.
MapIterator implementation.
The underlying list we are managing.
Returns a fail-fast ListIterator.
Returns a cursor iterator that allows changes to the underlying list in parallel.
Return an iterator of the elements of this list, in proper sequence.
Iterators must be manually synchronized.
Gets a ListIterator over the list.
Returns a fail-fast ListIterator.
Returns a cursor iterator that allows changes to the underlying list in parallel.
Return an iterator of the elements of this list, in proper sequence,
starting at the specified position.
Iterators must be manually synchronized.
Gets a ListIterator over the list.
As the wrapped Iterator is traversed, ListIteratorWrapper
builds a LinkedList of its values, permitting all required
operations of ListIterator.
Constructs a new ListIteratorWrapper
that will wrap
the given iterator.
Decorates a Map
to ensure that the order of addition is retained
using a List
to maintain order.
Constructs a new empty ListOrderedMap
that decorates
a HashMap
.
Constructor that wraps (not copies).
Decorates another Set
to ensure that the order of addition
is retained and used by the iterator.
Constructs a new empty ListOrderedSet
using
a HashSet
and an ArrayList
internally.
Constructor that wraps (not copies).
Constructor that wraps (not copies) the Set and specifies the list to use.
Provides utility methods and decorators for List
instances.
ListUtils
should not normally be instantiated.
Load the properties from the given input stream.
Load the properties from the given input stream
and using the specified encoding.
Load factor, normally 0.75
The object to lock on, needed for List/SortedSet views
Logs the given exception to System.out
.
Logs the given exception to System.out
.
Logs the given exception to System.err
.
An Iterator that restarts when it reaches the end.
Gets an iterator that loops continuously over the supplied collection.
Constructor that wraps a collection.
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.
A Map
implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.
LRUMap() - constructor for class org.apache.commons.collections.
LRUMap Default constructor, primarily for the purpose of
de-externalization.
LRUMap() - constructor for class org.apache.commons.collections.map.
LRUMap Constructs a new empty map with a maximum size of 100.
Create a new LRUMap with a maximum capacity of i.
Constructs a new, empty map with the specified maximum size.
Constructs a new, empty map with the specified maximum size.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructs a new, empty map with the specified initial capacity and
load factor.
Constructor copying elements from another map.
Constructor copying elements from another map.
Comparator for natural sort order.
Gets a comparator that uses the natural order of the objects.
Create a new Predicate that returns true if neither of the specified
predicates are true.
The next entry in the hash chain
The node that will be returned by
next()
.
A pointer to the node after this node
Gets the next key from the Map
.
Gets the next key from the Map
.
Gets the next key from the Map
.
Gets the next entry in the bucket.
Returns the next element in the array.
Gets the next element from the array.
Returns the next ordered element from a child iterator.
Gets the next key from the Map
.
Returns the next object from the enumeration.
Returns the next object that matches the predicate.
Returns the next Object of the current Iterator
Returns the next element from the iterator.
Returns the next object in the collection.
Gets the next key from the Map
.
Returns the next element in the array.
Gets the next element from the array.
Gets the next element of the iteration.
Returns the next element from the underlying iterator.
Invokes the underlying ListIterator.next()
method.
Get the next object from the iterator.
Get the next object from the iterator.
Gets the next object from the iteration, transforming it using the
current transformer.
Gets the next key from the Map
.
Returns the next element from the underlying iterator.
Gets the next index to be retrieved.
Gets the index of the next element to be returned.
Returns in the index of the next element.
Gets the next index to be retrieved.
Invokes the underlying ListIterator.nextIndex()
method.
Returns the index of the element that would be returned by a subsequent
call to next.
Gets the next key in sequence.
Gets the next key to the one specified using insert order.
Gets the next key after the one specified.
Gets the next key after the key specified, always null.
Gets the next key after the one specified.
Singleton instance that uses the no arg constructor
A node within the linked list.
Constructs a new header node.
A List
implementation that stores a cache of internal Node objects
in an effort to reduce wasteful object creation.
Constructor that creates.
Constructor that copies the specified collection
Constructor that species the maximum cache size.
Handle event from the list when a node has changed.
Handle event from the list when a node has been added.
Handle event from the list when a node has been removed.
Predicate implementation that returns true if none of the predicates return true.
Create a new Predicate that returns true if none of the specified
predicates are true.
Constructor that performs no validation.
Create a new Predicate that returns true if none of the specified
predicates are true.
Closure implementation that does nothing.
Gets a Closure that will do nothing.
Transformer implementation that does nothing.
Gets a transformer that returns the input object.
Predicate implementation that returns true if the input is not null.
Gets a Predicate that checks if the input object passed in is not null.
Predicate implementation that returns the opposite of the decorated predicate.
Constructor that performs no validation.
Create a new Predicate that returns true if the specified predicate
returns false and vice versa.
An object for masking null
A Comparator that will compare nulls to be either lower or higher than
other objects.
Construct an instance that sorts null
higher than any
non-null
object it is compared with.
Construct an instance that sorts null
higher or lower than
any non-null
object it is compared with.
Construct an instance that sorts null
higher than any
non-null
object it is compared with.
Construct an instance that sorts null
higher or lower than
any non-null
object it is compared with.
Gets a Factory that will return null each time the factory is used.
Gets a Comparator that controls the comparison of null
values.
Predicate implementation that throws an exception if the input is null.
Constructor that performs no validation.
Gets a Predicate that throws an exception if the input object is null,
otherwise it calls the specified Predicate.
Predicate implementation that returns false if the input is null.
Constructor that performs no validation.
Gets a Predicate that returns false if the input object is null, otherwise
it calls the specified Predicate.
Predicate implementation that returns true if the input is null.
Constructor that performs no validation.
Gets a Predicate that returns true if the input object is null, otherwise
it calls the specified Predicate.
Gets a Comparator that controls the comparison of null
values.
Predicate implementation that returns true if the input is null.
Gets a Predicate that checks if the input object passed in is null.
Gets a transformer that always returns null.
Returns the top item off of this stack without removing it.
Returns the element on top of heap but don't remove it.
Return element on top of heap but don't remove it.
Return element on top of heap but don't remove it.
Returns the n'th item down (zero-relative) from the top of this
stack without removing it.
Percolates element down heap from the position given by the index.
Percolates element down heap from the position given by the index.
Percolates element down heap from the position given by the index.
Percolates element down heap from the position given by the index.
Percolates element up heap from from the position given by the index.
Percolates element up heap from from the position given by the index.
Percolates a new element up heap from the bottom.
Percolates a new element up heap from the bottom.
Percolates element up heap from the position given by the index.
Percolates element up heap from the position given by the index.
Percolates a new element up heap from the bottom.
Percolates a new element up heap from the bottom.
Pops the top item off of this stack and return it.
Returns the element on top of heap and remove it.
Return element on top of heap and remove it.
Return element on top of heap and remove it.
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.
Returns a predicated (validating) bag backed by the given bag.
Constructor that wraps (not copies).
Decorates another Buffer
to validate that additions
match a specified predicate.
Returns a predicated (validating) buffer backed by the given buffer.
Constructor that wraps (not copies).
Decorates another Collection
to validate that additions
match a specified predicate.
Returns a predicated (validating) collection backed by the given collection.
Constructor that wraps (not copies).
Defines a predicate that decorates one or more other predicates.
Decorates another List
to validate that all additions
match a specified predicate.
Returns a predicated (validating) list backed by the given list.
Constructor that wraps (not copies).
Inner class Iterator for the PredicatedList
Constructor that decorates the specified iterator.
Decorates another Map
to validate that additions
match a specified predicate.
Returns a predicated (validating) map backed by the given map.
Constructor that wraps (not copies).
Decorates another Set
to validate that all additions
match a specified predicate.
Constructor that wraps (not copies).
Returns a predicated (validating) set backed by the given set.
Decorates another SortedBag
to validate that additions
match a specified predicate.
Returns a predicated (validating) sorted bag backed by the given sorted bag.
Constructor that wraps (not copies).
Decorates another SortedMap
to validate that additions
match a specified predicate.
Returns a predicated (validating) sorted map backed by the given map.
Constructor that wraps (not copies).
Decorates another SortedSet
to validate that all additions
match a specified predicate.
Constructor that wraps (not copies).
Returns a predicated (validating) sorted set backed by the given sorted set.
Transformer implementation that calls a Predicate using the input object
and then returns the input.
Constructor that performs no validation.
PredicateUtils
provides reference implementations and utilities
for the Predicate functor interface.
This class is not normally instantiated.
A pointer to the node before this node
Gets the previous key from the Map
.
Gets the previous element from the array.
Gets the previous key from the Map
.
Returns the the previous element.
Gets the previous element from the array.
Gets the previous element from the collection.
Gets the previous key from the Map
.
Invokes the underlying ListIterator.previous()
method.
Get the previous object from the iterator.
Gets the previous key from the Map
.
Gets the index of the item to be retrieved if
previous()
is called.
Returns the index of the previous element.
Gets the index of the item to be retrieved if
previous()
is called.
Invokes the underlying ListIterator.previousIndex()
method.
Returns the index of the element that would be returned by a subsequent
call to previous.
Gets the previous key in sequence.
Gets the previous key to the one specified using insert order.
Gets the previous key before the one specified.
Gets the previous key before the key specified, always null.
Gets the previous key before the one specified.
Prints the stack trace of this exception to the standard error stream.
Prints the stack trace of this exception to the specified stream.
Prints the stack trace of this exception to the specified writer.
Binary heap implementation of Buffer
that provides for
removal based on Comparator
ordering.
Constructs a new empty buffer that sorts in ascending order by the
natural order of the objects added.
Constructs a new empty buffer specifying the sort order and using the
natural order of the objects added.
Constructs a new empty buffer specifying the sort order and comparator.
Constructs a new empty buffer that sorts in ascending order using the
specified comparator.
Constructs a new empty buffer that sorts in ascending order by the
natural order of the objects added, specifying an initial capacity.
Constructs a new empty buffer that specifying initial capacity and
sort order, using the natural order of the objects added.
Constructs a new empty buffer that specifying initial capacity,
sort order and comparator.
Constructs a new empty buffer that sorts in ascending order using the
specified comparator and initial capacity.
Defines a collection for priority queues, which can insert, peek and pop.
Subclasses of LRUMap may hook into this method to
provide specialized actions whenever an Object is
automatically removed from the cache.
Factory implementation that creates a new instance each time based on a prototype.
Creates a Factory that will return a clone of the same prototype object
each time the factory is used.
A Proxy Iterator
which delegates its methods to a proxy instance.
Constructs a new ProxyIterator
that will use the
given iterator.
A proxy ListIterator
which delegates its
methods to a proxy instance.
Constructs a new
ProxyListIterator
that will not
function until
setListIterator
is invoked.
Constructs a new ProxyListIterator
that will use the
given list iterator.
This Map
wraps another Map
implementation, using the wrapped instance for its default
implementation.
Constructor that uses the specified map to delegate to.
Purges stale mappings from this map.
Purges the specified reference.
Purges stale mappings from this map before read operations.
Purges stale mappings from this map before write operations.
Should the value be automatically purged when the associated key has been collected?
Pushes a new item onto the top of this stack.
Puts the key-value pair into the map, replacing any previous pair.
Puts a key-value mapping into this map.
Puts a key-value mapping into this map.
Sets the bean property with the given name to the given value.
Puts the key-value pair into the map, replacing any previous pair.
Associates the specified value with the specified key in this map
(optional operation).
Associates the specified value with the specified key in this
map.
Associate the specified value with the specified key in this map.
Associate the specified value with the specified key in this map.
Puts a key-value mapping into this map.
Removes the key and its Object from the Map.
Adds the value to the collection associated with the specified key.
Puts the key and value into the map, where the key must be a non-null
MultiKey object.
Adds the value to the collection associated with the specified key.
Invokes the underlying Map.put(Object,Object)
method.
Associates the given key with the given value.
Implements Map.put(Object, Object)
.
Puts a key-value mapping into this map where the key must match the existing key.
Implements Map.put(Object, Object)
.
Puts a new key value mapping into the map.
Puts the key-value pair into the map, replacing any previous pair.
Puts the key-value pair into the map, replacing any previous pair.
Stores the value against the specified multi-key.
Stores the value against the specified multi-key.
Stores the value against the specified multi-key.
Stores the value against the specified multi-key.
Called when the CompositeMap.put() method is invoked.
Puts all the values from the specified map into this map.
Copies all of the mappings from the specified map to this map
(optional operation).
Copy all of the mappings from the specified map to this one, replacing
any mappings with the same keys.
Copy all of the mappings from the specified map to this one, replacing
any mappings with the same keys.
Puts all the values from the specified map into this map.
Puts all the keys and values into this map.
Invokes the underlying Map.putAll(Map)
method.
Adds all the mappings in the specified map to this map, replacing any
mappings that already exist (as per Map.putAll(Map)
).
Puts the values from the specified map into this map.
Implements Map.putAll(Map)
.
Puts all the entries from the specified map into this map.
Puts all the mappings from the specified map into this map.
Adds a collection of values to the collection associated with the specified key.
Called when the CompositeMap.putAll() method is invoked.
Puts all of the writable properties from the given BeanMap into this
BeanMap.
Deserializes this map from the given stream.
Deserializes this map from the given stream.
A MapEntry implementation for the map.
Creates a new entry object for the ReferenceMap.
A Map
implementation that allows mappings to be
removed by the garbage collector and matches keys and values based
on ==
not equals()
.
Constructs a new ReferenceIdentityMap
that will
use hard references to keys and soft references to values.
Constructs a new ReferenceIdentityMap
that will
use the specified types of references.
Constructs a new ReferenceIdentityMap
that will
use the specified types of references.
Constructs a new ReferenceIdentityMap
with the
specified reference types, load factor and initial capacity.
Constructs a new ReferenceIdentityMap
with the
specified reference types, load factor and initial capacity.
Hash-based Map
implementation that allows
mappings to be removed by the garbage collector.
A Map
implementation that allows mappings to be
removed by the garbage collector.
Constructs a new ReferenceMap
that will
use hard references to keys and soft references to values.
Constructs a new ReferenceMap
that will
use hard references to keys and soft references to values.
Constructs a new ReferenceMap
that will
use the specified types of references.
Constructs a new ReferenceMap
that will
use the specified types of references.
Constructs a new ReferenceMap
that will
use the specified types of references.
Constructs a new ReferenceMap
that will
use the specified types of references.
Constructs a new ReferenceMap
with the
specified reference types, load factor and initial
capacity.
Constructs a new ReferenceMap
with the
specified reference types, load factor and initial
capacity.
Constructs a new ReferenceMap
with the
specified reference types, load factor and initial
capacity.
Constructs a new ReferenceMap
with the
specified reference types, load factor and initial
capacity.
Registers a cursor to be notified of changes to this list.
Removes the last returned key from the underlying Map
(optional operation).
Removes the last returned key from the underlying Map
(optional operation).
Removes the last returned key from the underlying Map
(optional operation).
Throws UnsupportedOperationException
.
Removes the element on the top of the stack.
Removes the priority element.
Removes the least recently inserted element from this buffer.
Removes the least recently inserted element from this buffer.
Gets and removes the next object from the buffer.
Removes the last returned element from the child iterator that
produced it.
Removes the last returned key from the underlying Map
.
Removes the last retrieved element if a collection is attached.
Removes from the underlying collection of the base iterator the last
element returned by this iterator.
Removes from the underlying collection the last element
returned by the Iterator.
Throws UnsupportedOperationException
.
Removes the previously retrieved item from the underlying collection.
Removes the last returned key from the underlying Map
(optional operation).
Throws UnsupportedOperationException
.
Removes from the underlying collection the last element returned.
Gets and removes the next object from the buffer.
Gets and removes the next element (pop).
Removes the last returned element from the collection that spawned
the underlying iterator.
Invokes the underlying ListIterator.remove()
method.
Remove the object from this iterator.
Remove the object from this iterator.
Gets and removes the next object from the buffer.
Removes the next object from the buffer
Removes the next object from the buffer
Gets and removes the next object from the buffer.
Removes the last returned key from the underlying Map
(optional operation).
Removes the element at the specified position in this list (optional
operation).
Remove the element at the specified position in the list, and shift
any subsequent elements down one position.
Removes the element at the specified index.
Removes the element at the specified index.
Removes the element at the specified index.
Removes the element at the specified index.
Removes the specified mapping from this map.
Removes all copies of the specified object from the bag.
Removes the specified mapping from this map.
(Violation)
Removes all occurrences of the given object from the bag.
Removes an object from the collection, throwing UnsupportedOperationException
unless a CollectionMutator strategy is specified.
Removes the mapping for this key from this map if it is present
(optional operation).
If a CollectionMutator
is defined for this CompositeSet then this
method will be called anyway.
Removes the first occurrence in this list of the specified element.
Removes the mapping for this key from this map if present
Remove the first occurrence of the specified element from the list,
and shift any subsequent elements down one position.
Remove any mapping for this key, and return any previously
mapped value.
Remove any mapping for this key, and return any previously
mapped value.
Removes the specified mapping from this map.
Removes all values associated with the specified key.
Invokes the underlying Map.remove(Object)
method.
Removes the key and its associated value from this map.
Implements Map.remove(Object)
.
Implements Map.remove(Object)
.
Removes the specified key from the map.
Removes the mapping for this key from this map if present.
Removes a specified number of copies of an object from the bag.
Removes nCopies
copies of the specified object from the Bag.
Removes nCopies
copies of the specified object from the Bag.
Removes nCopies
copies of the specified object from the Bag.
Removes a specific value from map.
Removes the specified multi-key from this map.
Removes a specific value from map.
Removes the specified multi-key from this map.
Removes the specified multi-key from this map.
Removes the specified multi-key from this map.
Called when an object is to be removed to the composite.
Removes objects from the bag according to their count in the specified collection.
(Violation)
Remove all elements represented in the given collection,
respecting cardinality.
Removes the elements in the specified collection from this composite collection.
Removes from this list all the elements that are contained in the
specified collection.
Remove from this collection all of its elements that are contained
in the specified collection.
Removes all mappings where the first key is that specified.
Removes all mappings where the first two keys are those specified.
Removes all mappings where the first three keys are those specified.
Removes all mappings where the first four keys are those specified.
Removes all nodes by resetting the circular list marker.
Removes all nodes by iteration.
Removes all the nodes from the list, storing as many as required in the
cache for reuse.
Removes a collection from the those being decorated in this composite.
Remove a Map from the composite.
Removes an entry from the chain stored in a particular index.
Removes an entry from the map and the linked list.
Removes the first element of this list, if any.
Removes the last element of this list, if any.
Removes the given
org.apache.commons.collections.CursorableLinkedList.Listable
from my list.
This method is used internally by the class for
finding and removing the LRU Object.
Subclass method to control removal of the least recently used entry from the map.
Removes a mapping from the map.
Removes the specified node from the list.
Removes the specified node from the list.
Removes the node from the list, storing it in the cache for reuse
if the cache is not yet full.
Removes the key-value pair that is currently mapped to the specified
value (optional operation).
Removes the key-value pair that is currently mapped to the specified
value (optional operation).
Removes the mapping for this value from this map if present
Removes the mapping for this value from this map if present.
Removes the key-value pair that is currently mapped to the specified
value (optional operation).
Resets the iterator back to the position at which the iterator
was created.
Resets the iterator back to the start index.
Resets the iterator back to the start index.
Resets the state of the iterator.
Resets the iterator back to the start of the collection.
Resets the iterator back to the start index.
Resets the iterator back to the start index.
Resets the iterator back to the position at which the iterator
was created.
Resets the iterator back to the position at which the iterator
was created.
Reset the iterator to the start.
Reset the iterator back to the start.
Singleton instance of the iterator.
Singleton instance of the iterator.
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.
Called when adding a new Composited Map results in a
key collision.
Called when a Set is added to the CompositeSet and there is a
collision between existing and added sets.
Remove any members of the bag that are not in the given
bag, respecting cardinality.
(Violation)
Remove any members of the bag that are not in the given
collection, respecting cardinality.
Retains all the elements in the specified collection in this composite collection,
removing all others.
Retains only the elements in this list that are contained in the
specified collection.
Remove any members of the bag that are not in the given
bag, respecting cardinality.
Remove from this collection all of its elements except those that are
contained in the specified collection.
Remove any members of the bag that are not in the given
bag, respecting cardinality.
Reuses an existing key-value mapping, storing completely new data.
Reuses an entry by removing it and moving it to a new place in the map.
Reverses the order of the given array.
Reverses the order of another comparator by reversing the arguments
to its
compare
method.
Creates a comparator that compares objects based on the inverse of their
natural ordering.
Creates a comparator that inverts the comparison
of the given comparator.
Gets a comparator that reverses the order of the given comparator.
The root object in the tree
Nice method for adding data to a map in such a way
as to not get NPE's.
Save the properties to the given output stream.
Returns the one-based position of the distance from the top that the
specified object exists on this stack, where the top-most element is
considered to be at distance 1
.
Selects all elements from input collection which match the given predicate
into an output collection.
Selects all elements from input collection which match the given predicate
and adds them to outputCollection.
Selects all elements from inputCollection which don't match the given predicate
into an output collection.
Selects all elements from inputCollection which don't match the given predicate
and adds them to outputCollection.
Returns a List view of the keys rather than a set view.
A map of objects whose mapping entries are sequenced based on the order in
which they were added.
Construct a new sequenced hash map with default initial size and load
factor.
Construct a new sequenced hash map with the specified initial size and
default load factor.
Construct a new sequenced hash map with the specified initial size and
load factor.
Construct a new sequenced hash map and add all the elements in the
specified map.
Internal Set to maintain uniqueness.
Replaces the element at the specified position in this list with the
specified element.
Replace the element at the specified position in this list with
the specified element.
Sets the value at the specified index avoiding duplicates.
Sets the element at the specified index.
Sets the element under the cursor.
Throws UnsupportedOperationException
.
Sets the element under the cursor.
Invokes the underlying ListIterator.set(Object)
method.
Set sets the value of the singleton.
Sets the array that the ArrayIterator should iterate over.
Sets the array that the ArrayIterator should iterate over.
Sets the bean to be operated on by this map.
Sets the Comparator
by which collation occurs.
Replace the Comparator at the given index, maintaining
the existing sort order.
Replace the Comparator at the given index in the
ComparatorChain, using the given sort order
Sets the underlying enumeration.
Sets whether this list will operate in fast mode.
Sets whether this map is operating in fast mode.
Sets whether this map is operating in fast mode.
Change the sort order at the given index in the
ComparatorChain to a forward sort.
Sets the property value for including other properties files.
Sets the iterator at the given index.
Set the Iterator at the given index
Sets the iterator for this iterator to use.
Sets the underlying iterator.
Setter for property iterator.
Sets the iterator for this iterator to use.
Sets the key stored in this Map Entry.
Sets the iterator for this iterator to use.
Setter for property iterator.
Utility method for implementations to set the map that backs
this bag.
Sets the maximum size of the cache.
Setter for property maximumSize.
Define callbacks for mutation operations.
Specify a CollectionMutator strategy instance to handle changes.
This can receive either a CompositeCollection.CollectionMutator
or a CompositeSet.SetMutator
.
Specify the MapMutator to be used by mutation operations.
Internal list to hold the sequence of objects
Sets the predicate this the iterator to use.
Sets the predicate this the iterator to use.
Set a property, this will replace any previously
set values.
Change the sort order at the given index in the
ComparatorChain to a reverse sort.
Sets the transformer this the iterator to use.
Decorates a List
to ensure that no duplicates are present
much like a Set
.
Constructor that wraps (not copies) the List and specifies the set to use.
Sets the behavior for comparing unknown objects.
Provides utility methods and decorators for
Set
and SortedSet
instances.
SetUtils
should not normally be instantiated.
Sets the value associated with the current key (optional operation).
Sets the value of the node.
Sets the value stored in this Map Entry.
Sets the value associated with the current key (optional operation).
Sets the value associated with the current key (optional operation).
Sets the value of the entry.
Sets the value stored in this Map Entry.
Sets the value associated with the current key.
Sets the value associated with the current key (optional operation).
Sets the value associated with the key direct onto the map.
Throws UnsupportedOperationException.
Sets the value associated with the current key (optional operation).
Reduce the size of the cache to the maximum, if necessary.
SingletonIterator
is an Iterator
over a single
object instance.
Gets a singleton iterator.
Constructs a new SingletonIterator
where remove
is a permitted operation.
Constructs a new SingletonIterator
optionally choosing if
remove
is a permitted operation.
SingletonIterator
is an ListIterator
over a single
object instance.
Gets a singleton list iterator.
Constructs a new SingletonListIterator
.
A Map
implementation that holds a single item and is fixed size.
Constructor that creates a map of null
to null
.
Constructor copying elements from another map.
Constructor specifying the key and value as a MapEntry
.
Constructor specifying the key and value.
Constructor specifying the key and value as a KeyValue
.
The number of elements currently in this buffer.
Gets the size of the map.
Returns the number of elements in this bag.
Gets the size of the map.
size() - method in class org.apache.commons.collections.
Bag Returns the total number of items in the bag across all types.
Returns the number of properties defined by the bean.
Returns the number of elements in this heap.
Returns the number of elements stored in the buffer.
Returns the number of elements stored in the buffer.
Number of Comparators in the current ComparatorChain.
Gets the size of this composite collection.
Returns the number of key-value mappings in this map.
Returns the number of elements in this list.
Returns the number of elements in this bag.
Returns the number of key-value mappings in this map.
Return the number of elements in this list.
Return the number of key-value mappings in this map.
Return the number of key-value mappings in this map.
Gets the size of the map.
Number of Iterators in the current IteratorChain.
Gets the size of the collection underlying the iterator.
size() - method in class org.apache.commons.collections.keyvalue.
MultiKey Gets the size of the list of keys.
Gets the number of keys in this map.
Returns the number of elements in this buffer.
Invokes the underlying Map.size()
method.
Returns the size of this map.
Gets the size of the map, always 1.
Gets the current size of the map.
Returns the number of key-value mappings in this map.
Gets the current size of the list.
Returns the number of elements stored in the buffer.
Returns the number of elements stored in the buffer.
Gets the size of the collection/iterator specified.
Gets the size of the collection mapped to the specified key.
Constant indicating that soft references should be used
Constant indicating that soft references should be used.
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.
Returns true
iff
I sort true
values before
false
values.
The start index to loop from
The start index to loop from
A StaticBucketMap is an efficient, thread-safe implementation of
java.util.Map
that performs well in in a highly
thread-contentious environment.
A StaticBucketMap is an efficient, thread-safe implementation of
java.util.Map
that performs well in in a highly
thread-contentious environment.
Initializes the map with the default number of buckets (255).
Initializes the map with the default number of buckets (255).
Initializes the map with a specified number of buckets.
Initializes the map with a specified number of buckets.
Transformer implementation that returns the String.valueOf
.
Gets a transformer that returns a java.lang.String
representation of the input object.
Gets a sublist of the main list.
Returns a fail-fast sublist.
Return a view of the portion of this list between fromIndex
(inclusive) and toIndex (exclusive).
Return a view of the portion of this map whose keys are in the
range fromKey (inclusive) to toKey (exclusive).
Create an ExtendedProperties object that is a subset
of this one.
Returns a new Collection
containing a - b.
Subtracts all elements in the second list from the first list,
placing the results in a new list.
Returns the sum of the given lists.
Closure implementation calls the closure whose predicate returns true,
like a switch statement.
Create a new Closure that calls one of the closures depending
on the predicates.
Create a new Closure that calls one of the closures depending
on the predicates.
Create a new Closure that calls one of the closures depending
on the predicates.
Constructor that performs no validation.
Create a new Closure that uses the input object as a key to find the
closure to call.
Create a new Transformer that uses the input object as a key to find the
transformer to call.
Transformer implementation calls the transformer whose predicate returns true,
like a switch statement.
Create a new Transformer that calls one of the transformers depending
on the predicates.
Create a new Transformer that calls one of two transformers depending
on the specified predicate.
Create a new Transformer that calls one of the transformers depending
on the predicates.
Constructor that performs no validation.
Create a new Transformer that calls one of the transformers depending
on the predicates.
Decorates another Bag
to synchronize its behaviour
for a multi-threaded environment.
Returns a synchronized (thread-safe) bag backed by the given bag.
Constructor that wraps (not copies).
Constructor that wraps (not copies).
Decorates another Buffer
to synchronize its behaviour
for a multi-threaded environment.
Returns a synchronized buffer backed by the given buffer.
Constructor that wraps (not copies).
Constructor that wraps (not copies).
Decorates another Collection
to synchronize its behaviour
for a multi-threaded environment.
Returns a synchronized collection backed by the given collection.
Constructor that wraps (not copies).
Constructor that wraps (not copies).
Decorates another List
to synchronize its behaviour
for a multi-threaded environment.
Returns a synchronized list backed by the given list.
Constructor that wraps (not copies).
Constructor that wraps (not copies).
Returns a synchronized map backed by the given map.
A thread safe version of the PriorityQueue.
Constructs a new synchronized priority queue.
Decorates another Set
to synchronize its behaviour for a
multi-threaded environment.
Returns a synchronized set backed by the given set.
Constructor that wraps (not copies).
Constructor that wraps (not copies).
Decorates another SortedBag
to synchronize its behaviour
for a multi-threaded environment.
Constructor that wraps (not copies).
Returns a synchronized (thread-safe) sorted bag backed by the given
sorted bag.
Constructor that wraps (not copies).
Returns a synchronized sorted map backed by the given sorted map.
Decorates another SortedSet
to synchronize its behaviour
for a multi-threaded environment.
Returns a synchronized sorted set backed by the given sorted set.
Constructor that wraps (not copies).
Constructor that wraps (not copies).
Return a view of the portion of this map whose keys are greater than
or equal to the specified key.
Test whether the string represent by value maps to a boolean
value or not.
A Map Entry tied to a map underneath.
Constructs a new entry with the given Map and key.
Returns an array of all of this bag's elements.
Returns an array containing all of the elements in this composite.
Returns an array containing all of the elements in this list in proper
sequence.
Returns an array of all of this bag's elements.
Return an array containing all of the elements in this list in the
correct order.
Converts the list into an array.
Returns an array containing all of the elements in this list in proper
sequence; the runtime type of the returned array is that of the
specified array.
Return an array containing all of the elements in this list in the
correct order.
Gets an array based on an iterator.
Gets an array based on an iterator.
Returns an array of all of this bag's elements.
Returns an object array, populating the supplied array if possible.
Returns an array of all of this bag's elements.
Returns a new collection containing all of the elements
Creates a list based on an enumeration.
Gets a list based on an iterator.
Gets a list based on an iterator.
Gets a list iterator based on a simple iterator.
Creates a new HashMap using data copied from a ResourceBundle.
Returns a new Map.Entry
object with key and value from this pair.
Gets a new Properties object initialised with the values from a Map.
Constructs a reference of the given type to the given referent.
Gets the map as a String.
Gets a debugging String view of the pair.
Implement a toString() method suitable for debugging.
Returns a string representation of this heap.
Returns a String
representation of this list, suitable for debugging.
Implement a toString() method suitable for debugging.
Written to match the output of the Map.Entry's used in
a java.util.HashMap
.
Gets the iterator as a String.
Return a String representation of this object.
Gets the map as a String.
Returns the Map as a string.
Uses the underlying List's toString so that order is achieved.
Gets a debugging string version of the key.
Returns a string representation of this heap.
Provides a string representation of the entries within the map.
Gets the map as a String.
Returns a string representation of the underlying queue.
Gets a string version of the entry.
Returns a string version of this Map in standard format.
Gets the total size of the map by counting all the values.
Transform the collection by applying a Transformer to each element.
Transforms the input to result via each decorated transformer
Transforms the input to result by cloning it.
Transforms the input to result by executing a closure.
Transforms the input by ignoring it and returning the stored constant instead.
Transforms the input to result by cloning it.
Transforms the input by ignoring the input and returning the result of
calling the decorated factory.
Transforms the input Class object to a result by instantiation.
Transforms the input to result by invoking a method on the input.
Transforms the input to result by looking it up in a Map
.
Transforms the input to result by doing nothing.
Transforms the input to result by calling a predicate.
Transforms the input to result by calling String.valueOf
.
Transforms the input to result by calling the transformer whose matching
predicate returns true.
Transforms the input object (leaving it unchanged) into some output object.
Transforms the given object using the transformer.
Decorates another Bag
to transform objects that are added.
Returns a transformed bag backed by the given bag.
Constructor that wraps (not copies).
Decorates another Buffer
to transform objects that are added.
Returns a transformed buffer backed by the given buffer.
Constructor that wraps (not copies).
Decorates another Collection
to transform objects that are added.
Returns a transformed bag backed by the given collection.
Constructor that wraps (not copies).
Gets a Comparator that passes transformed objects to the given comparator.
Gets an iterator that transforms the elements of another iterator.
Decorates another List
to transform objects that are added.
Returns a transformed list backed by the given list.
Constructor that wraps (not copies).
Inner class Iterator for the TransformedList
Decorates another Map
to transform objects that are added.
Returns a transformed map backed by the given map.
Constructor that wraps (not copies).
Predicate implementation that transforms the given object before invoking
another Predicate
.
Creates a predicate that transforms the input object before passing it
to the predicate.
Constructor that performs no validation.
Decorates another Set
to transform objects that are added.
Returns a transformed set backed by the given set.
Constructor that wraps (not copies).
Decorates another SortedBag
to transform objects that are added.
Returns a transformed sorted bag backed by the given bag.
Constructor that wraps (not copies).
Decorates another SortedMap
to transform objects that are added.
Returns a transformed sorted map backed by the given map.
Constructor that wraps (not copies).
Decorates another SortedSet
to transform objects that are added.
Returns a transformed sorted set backed by the given set.
Constructor that wraps (not copies).
Defines a functor interface implemented by classes that transform one
object into another.
The transformer being used.
Closure implementation that calls a Transformer using the input object
and ignore the result.
Constructor that performs no validation.
Predicate implementation that returns the result of a transformer.
Constructor that performs no validation.
TransformerUtils
provides reference implementations and
utilities for the Transformer functor interface.
This class is not normally instantiated.
Decorates another Comparator with transformation behavior.
Constructs an instance with the given Transformer and Comparator.
Decorates an iterator such that each element returned is transformed.
Constructs a new
TransformIterator
that will not function
until the
setIterator
method is
invoked.
Constructs a new TransformIterator
that won't transform
elements from the given iterator.
Constructs a new TransformIterator
that will use the
given iterator and transformer.
A
Bag
that is backed by a
TreeMap
.
Implements SortedBag
, using a TreeMap
to provide
the data storage.
Constructs an empty TreeBag
.
Constructs an empty TreeBag
.
Constructs a
Bag
containing all the members of the given
collection.
Constructs a TreeBag
containing all the members of the
specified collection.
Constructs an empty
Bag
that maintains order on its unique
representative members according to the given
Comparator
.
Constructs an empty bag that maintains order on its unique
representative members according to the given Comparator
.
Red-Black tree-based implementation of BidiMap where all objects added
implement the Comparable
interface.
Constructs a new empty TreeBidiMap.
Constructs a new TreeBidiMap by copying an existing Map.
A List
implementation that is optimised for fast insertions and
removals at any index in the list.
Constructs a new empty list.
Constructs a new empty list that copies the specified list.
Trim the capacity of this ArrayList
instance to be the
list's current size.
Predicate implementation that always returns true.
Gets a Predicate that always returns true.
Decorates another Bag
to validate that elements added
are of a specific type.
Returns a typed bag backed by the given bag.
Decorates another Buffer
to validate that elements added
are of a specific type.
Returns a typed buffer backed by the given buffer.
Decorates a Collection
to validate that elements added are of a specific type.
Returns a typed collection backed by the given collection.
Decorates another List
to validate that elements
added are of a specific type.
Returns a typed list backed by the given list.
Decorates another Map
to validate that elements added
are of a specific type.
Returns a typed map backed by the given map.
Decorates another Set
to validate that elements
added are of a specific type.
Returns a typed set backed by the given set.
Decorates another SortedBag
to validate that elements added
are of a specific type.
Returns a typed sorted bag backed by the given bag.
Decorates another SortedMap
to validate that elements added
are of a specific type.
Returns a typed sorted map backed by the given map.
Decorates another SortedSet
to validate that elements
added are of a specific type.
Returns a typed sorted set backed by the given set.