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.
(Violation)
Add the given object to the bag and keep a count.
Adds an object to this heap.
Adds the given element to this buffer.
Appends the specified element to the end of this 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.
Throws UnsupportedOperationException
.
Invokes the underlying ListIterator.add(Object)
method.
Add always throws UnsupportedOperationException
.
Adds the given element to this buffer.
Add i
copies of the given object to the bag and
keep a count.
Adds a new element to the bag by incrementing its count in the map.
Adds the String to the collection if it does not already
contain it.
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.
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 all Strings in the given StringStack to the collection
(skipping those it already contains)
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
Inserts the specified element at the beginning of this list.
Add the given Iterator
to my collection to collate.
Add an Iterator to the end of the chain
Inserts the specified element at the end of this list.
Add a property to the configuration.
Enumeration wrapper for array.
Implements an java.util.Iterator
over an array of objects.
Implements an Iterator
over an array of objects.
Construct an ArrayIterator.
Construct an ArrayIterator.
Construct an ArrayIterator that will iterate over the values in the
specified array.
Construct an ArrayIterator that will iterate over the values in the
specified array.
Construct an ArrayIterator that will iterate over the values in the
specified array.
Construct an ArrayIterator that will iterate over the values in the
specified array.
Construct an ArrayIterator that will iterate over the values in the
specified array.
Construct an ArrayIterator that will iterate over the values in the
specified array.
Gets an iterator over an array.
Gets an iterator over the end part of an array.
Gets an iterator over part of an 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.
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.
Prevents any operations from occuring on this map while the
given Runnable
executes.
Bag - interface org.apache.commons.collections.
Bag A Collection
that counts the number of times an object appears in
the collection.
Provides utility methods and decorators for
Bag
and
SortedBag
instances.
Base path of the configuration file used to create
this ExtendedProperties object.
An implementation of Map for JavaBeans which uses introspection to
get and put properties in the bean.
Constructs a new empty BeanMap
.
Constructs a new BeanMap
that operates on the
specified bean.
Constructs a new minimum binary heap.
Constructs a new minimum or maximum binary heap
Constructs a new BinaryHeap
.
Constructs a new BinaryHeap
that will use the given
comparator to order its elements.
Constructs a new minimum binary heap with the specified initial capacity.
Constructs a new minimum or maximum binary heap with the specified
initial capacity.
Constructs a new BinaryHeap
.
Constructs a new BinaryHeap
.
The BoundedFifoBuffer is a very efficient implementation of
Buffer that does not alter the size of the buffer at runtime.
Constructs a new BoundedFifoBuffer
big enough to hold
32 elements.
Constructs a new BoundedFifoBuffer
big enough to hold all
of the elements in the specified collection.
Constructs a new BoundedFifoBuffer
big enough to hold
the specified number of elements.
Informs all of my registerd cursors that the specified
element was changed.
Informs all of my registered cursors tha the specifed
element was just added to my list.
Informs all of my registered cursors tha the specifed
element was just removed from my list.
A Buffer is a collection that allows objects to be removed in some
well-defined order.
The BufferOverflowException is used when the buffer's capacity has been
exceeded.
Constructs a new BufferOverflowException
.
Construct a new BufferOverflowException
.
Construct a new BufferOverflowException
.
The BufferUnderflowException is used when the buffer is already empty
Constructs a new BufferUnderflowException
.
Construct a new BufferUnderflowException
.
Construct a new BufferUnderflowException
.
Contains static utility methods for operating on
Buffer
objects.
Actually walks the bag to make sure the count is correct and
resets the running total
Returns the number of occurrences of obj
in col.
Gets a comparator that compares using a collection of Comparator
s.
Gets a comparator that compares using two Comparator
s.
Gets a comparator that compares using an array of Comparator
s.
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.
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 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.
Clear all elements from queue.
Invokes the underlying Map.clear()
method.
Clear all elements from queue.
Clear a property in the configuration.
Clone this bean map using the following process:
- If there is no underlying bean, return a cloned BeanMap without a
bean.
Return a shallow copy of this FastArrayList
instance.
Return a shallow copy of this FastHashMap
instance.
Return a shallow copy of this FastTreeMap
instance.
Creates a shallow copy of this object, preserving the internal structure
by copying only references.
An interface to represent some Closure, a block of code which is executed
from inside some block, function or iteration which operates on an input
object.
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 Iterator
s.
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.
Transforms all elements from inputCollection with the given transformer
and adds them to the outputCollection.
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.
A set of Collection
related utility methods.
Please don't ever instantiate a CollectionUtils
.
Combines an existing Hashtable with this Hashtable.
A Comparator that compares Comparable objects.
Return the comparator used to order this map, or null
if this map uses its keys' natural order.
Returns the comparator associated with this sorted set, or null
if it uses its elements' natural ordering.
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.
Perform comaparisons on the Objects as per
Comparator.compare(o1,o2).
Perform a comparison between two objects.
Returns the result of comparing the values from the transform operation.
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.
Returns whether this stack contain the specified text.
(Violation)
Returns true
if the bag contains all elements in
the given collection, respecting cardinality.
Returns true if this list contains all of the elements of the
specified collection.
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 some element of a
is also an element of b (or, equivalently, if
some element of b is also an element of a).
Returns true if the bean defines a property with the given name.
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.
Invokes the underlying Map.containsKey(Object)
method.
Returns true
if this map contains the given key.
Implements Map.containsKey(Object)
.
Answers whether the argument is in the domain of the mappings
Implements Map.containsKey(Object)
.
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.
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.
Invokes the underlying Map.containsValue(Object)
method.
Implements Map.containsValue(Object)
.
Answers whether the argument is a Referenced value
Implements Map.containsValue(Object)
.
Convert a standard properties class into a configuration
class.
Converts the given value to the given type.
Simple method from which will come the new object from the factory.
Returns a reference to the argument.
Creates an array of parameters to pass to the given mutator method.
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 preceeding it (if any).
A doubly-linked list implementation of the List
interface,
supporting a ListIterator
that allows concurrent modifications
to the underlying list.
Return true
if this stack is currently empty.
Whether the stack is empty.
The empty iterator (immutable).
An iterator over no elements.
A list iterator over no elements
Provides an implementation of an empty iterator.
Provides an implementation of an empty list iterator.
Gets an empty list iterator.
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.
Convenience method for getting an iterator over the entries.
Get the mappings for this BeanMap
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.
Invokes the underlying Map.entrySet()
method.
Returns a set view of this map's entries.
Implements Map.entrySet()
.
Returns a set view of the mappings in the wrapped map
Implements Map.entrySet()
.
Returns a set view of the mappings contained in this map.
Adapter to make Enumeration
instances appear
to be Iterator
instances.
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 provides
an iterator view of the given enumeration.
Constructs a new EnumerationIterator
that will remove
elements from the specified collection.
Constructs a new EnumerationIterator
that will remove
elements from the specified collection.
Compares the specified object with this list for equality.
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.
Implemented per API documentation of
java.util.Map.Entry.equals(Object)
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.
Determines whether the specified object represents a comparator that is
equal to this comparator.
Invokes the underlying Map.equals(Object)
method.
Implements Map.equals(Object)
.
Answers whether this map and the argument are 'the same'
Implements Map.equals(Object)
.
Compares two StringStacks.
Returns true if the input object matches this predicate.
Performs some operation on the input object
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.
Factory
A simple interface that describes the most basic means of having the ability
to create an object.
Are we operating in "fast" mode?
Are we 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 a an empty map.
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.
A Proxy
Iterator
which takes a
Predicate
instance to filter
out objects from an underlying
Iterator
instance.
A Proxy
Iterator
which takes a
Predicate
instance to filter
out objects from an underlying
Iterator
instance.
Constructs a new
FilterIterator
that will not function
until
setIterator
is invoked.
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 not function
until
setPredicate
is invoked.
Constructs a new FilterIterator
that will use the
given iterator and predicate.
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.
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
that will not
function until
setPredicate
is invoked.
Constructs a new FilterListIterator
.
Constructs a new FilterListIterator
.
Constructs a new
FilterListIterator
that will not
function until
setListIterator
is invoked.
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.
Returns the first (lowest) member.
Return the first (lowest) key currently in this sorted map.
Returns a fixed-sized list backed by the given list.
Returns a fixed-sized map backed by the given map.
Returns a fixed-sized sorted map backed by the given sorted map.
Executes the given closure on each element in the collection.
Returns the element on the top of the stack.
Returns the priority element.
Returns the least recently inserted element in this buffer.
get() - method in class org.apache.commons.collections.
Buffer Returns the next object in the buffer without removing it.
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.
Returns the key at the specified index.
Get a string off the stack at a certain position.
Returns the value of the bean's property with the given name.
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.
Get the value for a key from the Map.
Invokes the underlying Map.get(Object)
method.
Returns the value associated with the given key, if any.
Implements Map.get(Object)
.
Retrieves the referent of the Referenced value
Implements Map.get(Object)
.
Retrieves the array that this iterator is iterating over.
Returns the bean currently being operated on.
Looks up the given key in the given map, converting the result into
a Boolean
.
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.
Looks up the given key in the given map, converting the result into
a Byte
.
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.
Returns a Map
mapping each unique element in
the given Collection
to an Integer
representing the number of occurances of that element
in the Collection
.
Gets the root cause of the exception.
Gets the root cause of the exception.
Get the Comparator
by which I collate.
Return 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.
Looks up the given key in the given map, converting the result into
a Double
.
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.
Returns the underlying enumeration.
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.
Looks up the given key in the given map, converting the result into
a Float
.
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 the property value for including other properties files.
Return a shared instance of a ComparableComparator.
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.
Looks up the given key in the given map, converting the result into
an Integer
.
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.
Returns the underlying iterator.
Getter for property iterator.
Returns an Iterator for the given object.
Gets a suitable Iterator for the given object.
Get the list of Iterators (unmodifiable)
Get the list of Iterators (unmodifiable)
Returns the key to which this map maps the specified value.
Get the list of the keys contained in the configuration
repository.
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.
Return the value for the "newest" mapping.
Returns the
org.apache.commons.collections.CursorableLinkedList.Listable
at the specified index.
Getter for property iterator.
Looks up the given key in the given map, converting the result into
a Long
.
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.
Utility method for implementations to access the map that backs
this bag.
Retrieves the wrapped HashMap
Looks up the given key in the given map, returning another map.
Looks up the given key in the given map, converting the result into
a map, using the default value if the the conversion fails.
Getter for property maximumSize.
Looks up the given key in the given map, converting the result into
a Number
.
Looks up the given key in the given map, converting the result into
a number, using the default value if the the conversion fails.
Synonym for Map.get(Object)
.
Looks up the given key in the given map, converting null into the
given default value.
Getter for property predicate.
Getter for the predicate property.
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.
Looks up the given key in the given map, converting the result into
a Short
.
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.
Looks up the given key in the given map, converting the result into
a string.
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.
Getter for property transformer.
Returns the type of the property with the given name.
Returns a transformer for the given primitive type.
Returns 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.
Increases the size of the heap to support additional elements
Constant indicating that hard references should be used.
An implementation of
Bag
that is backed by a
HashMap
.
Constructs a new empty HashBag
.
New
Bag
containing all the members of the given
collection.
Returns the hash code value for this list.
Returns the hash code of the underlying map.
Implemented per API documentation of
java.util.Map.Entry.hashCode()
Return the hash code value for this list.
Return the hash code value for this map.
Return the hash code value for this map.
Implement a hash code for this comparator that is consistent with
equals(Object)
.
Invokes the underlying Map.hashCode()
method.
Implements Map.hashCode()
.
Calculates the hash code for this map
Implements Map.hashCode()
.
Returns true if the underlying iterator has more elements.
Returns true if there are more elements to return from the array.
Returns true
if any child iterator has remaining elements.
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.
Returns true if the underlying iterator has more elements.
Invokes the underlying ListIterator.hasNext()
method.
Is another object available from the iterator.
Is another object available from the iterator.
Returns true if there are previous elements in the iterator.
Invokes the underlying ListIterator.hasPrevious()
method.
Is a previous object available from the iterator.
Return a view of the portion of this map whose keys are strictly
less than the specified key.
This is the name of the property that can point to other
properties file for including other properties files.
Given an Object, and an index, it will get the nth value in the
object.
Given an Object, and a key (index), it will get 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.
Returns the index of the specified key.
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
Singleton instance of the iterator.
Singleton instance of the iterator.
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 registerd cursors that they are now
invalid.
Returns true if this buffer is empty; false otherwise.
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.
Test if this list has no elements.
Invokes the underlying Map.isEmpty()
method.
Returns true
if this map is empty.
Implements Map.isEmpty()
.
Answers whether there are any mappings
Implements Map.isEmpty()
.
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 cardinality.
Has this configuration been intialized.
Indicate to client code whether property
resources have been initialized or not.
Determine if modifications can still be made to the
ComparatorChain.
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.
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.
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 a fail-fast iterator.
Return an iterator over the elements in this list in proper sequence.
Returns an iterator over this buffer's elements.
An IteratorChain is an Iterator that wraps one or
more 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
instances
Adapter to make an Iterator
instance appear to be an Enumeration
instances
Constructs a new
IteratorEnumeration
that will not
function until
setIterator
is
invoked.
Constructs a new
IteratorEnumeration
that will not
function until
setIterator
is
invoked.
Constructs a new IteratorEnumeration
that will use
the given iterator.
Constructs a new IteratorEnumeration
that will use
the given iterator.
Provides static utility methods and decorators for Iterator
instances.
Returns the last (highest) member.
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.
Returns the last index of the specified key.
Return the last (highest) key currently in this sorted map.
Returns a "lazy" list whose elements will be created on demand.
Returns a "lazy" map whose values will be created on demand.
Returns a "lazy" sorted map whose values will be created on demand.
The underlying list we are managing.
Returns a fail-fast ListIterator.
Return an iterator of the elements of this list, in proper sequence.
Returns a fail-fast ListIterator.
Return an iterator of the elements of this list, in proper sequence,
starting at the specified position.
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.
Contains static utility methods and decorators for List
instances.
Please don't ever instantiate a ListUtils
.
Load the properties from the given input stream.
Load the properties from the given input stream
and using the specified encoding.
Logs the given exception to System.out
.
Logs the given exception to System.out
.
Logs the given exception to System.err
.
An implementation of a Map which has a maximum size and uses a Least Recently Used
algorithm to remove items from the Map when the maximum size is reached and new items are added.
LRUMap() - constructor for class org.apache.commons.collections.
LRUMap Default constructor, primarily for the purpose of
de-externalization.
Create a new LRUMap with a maximum capacity of i.
Comparator for natural sort order.
Gets a comparator that uses the natural order of the objects.
Returns the next element in the array.
Returns the next ordered element from a child iterator.
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 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.
Returns the next element from the underlying iterator.
Returns in the index of the next element.
Invokes the underlying ListIterator.nextIndex()
method.
Returns the index of the element that would be returned by a subsequent
call to next.
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.
Cosntruct an instance that sorts null
higher or lower than
any non-null
object it is compared with.
Gets a Comparator that controls the comparison of null
values.
Gets a Comparator that controls the comparison of null
values.
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 top.
Percolates element down heap from top.
Percolates element up heap from bottom.
Percolates element up heap from 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.
Performs some predicate which returns true or false based on the input object.
Returns a predicated bag backed by the given bag.
Returns a predicated buffer backed by the given buffer.
Returns a predicated collection backed by the given collection.
Returns a predicated list backed by the given list.
Returns a predicated map backed by the given map.
Returns a predicated set backed by the given set.
Returns a predicated sorted bag backed by the given sorted bag.
Returns a predicated sorted map backed by the given map.
Returns a predicated sorted set backed by the given sorted set.
Returns the the previous element.
Invokes the underlying ListIterator.previous()
method.
Get the previous object from the iterator.
Returns the index of the previous element.
Invokes the underlying ListIterator.previousIndex()
method.
Returns the index of the element that would be returned by a subsequent
call to previous.
Interface for priority queues.
Subclasses of LRUMap may hook into this method to
provide specialized actions whenever an Object is
automatically removed from the cache.
A Proxy Iterator
which delegates its methods to a proxy instance.
A Proxy Iterator
which delegates its methods to a proxy instance.
Constructs a new ProxyIterator
that will use the
given iterator.
Constructs a new ProxyIterator
that will use the
given iterator.
A proxy ListIterator
which delegates its
methods to a proxy instance.
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 not
function until
setListIterator
is invoked.
Constructs a new ProxyListIterator
that will use the
given list iterator.
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.
Creates a new instance acting as a representative for the
specified Map
.
Removes References that have had their referents garbage collected
Pushes a new item onto the top of this stack.
Sets the bean property with the given name to the given value.
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.
Removes the key and its Object from the Map.
Invokes the underlying Map.put(Object,Object)
method.
Associates the given key with the given value.
Implements Map.put(Object, Object)
.
Adds a key-value mapping, wrapping the value in a Reference
Implements Map.put(Object, Object)
.
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.
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)
).
Put all of the mappings in the argument into this wrapped map
Implements Map.putAll(Map)
.
Puts all of the writeable properties from the given BeanMap into this
BeanMap.
Deserializes this map from the given stream.
Hashtable-based 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 the specified types of references.
Constructs a new ReferenceMap
with the
specified reference types, load factor and initial
capacity.
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 next object from the buffer.
Removes the last returned element from the child iterator that
produced it.
Functions if an associated Collection
is known.
Always throws UnsupportedOperationException as this class
does look-ahead with its internal iterator.
Removes from the underlying collection the last element
returned by the Iterator.
Throws UnsupportedOperationException
.
Removes the last returned element from the collection that spawned
the underlying iterator.
Invokes the underlying ListIterator.remove()
method.
Remove always throws UnsupportedOperationException
.
Remove always throws UnsupportedOperationException
.
Removes the next object from the buffer
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.
(Violation)
Remove all occurrences of the given object from the bag, and do
not represent the object in the
uniqueSet()
.
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.
Invokes the underlying Map.remove(Object)
method.
Removes the key and its associated value from this map.
Implements Map.remove(Object)
.
Removes a mapping from this map
Implements Map.remove(Object)
.
Remove the given number of occurrences from the bag.
(Violation)
Remove all elements represented in the given collection,
respecting cardinality.
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 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.
Removes the mapping for this value from this map if present
(Violation)
Remove any members of the bag that are not in the given
collection, respecting cardinality.
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.
Reverses the order of the given array
Reverses the order of another comparator.
Creates a comparator that compares objects based on the inverse of their
natural ordering.
Creates a reverse comparator that inverts the comparison
of the passed in comparator.
Gets a comparator that reverses the order of the given
comparator.
Nice method for adding data to a map in such a way
as to not get NPE's.
Save the properties to the given outputstream.
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.
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.
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.
Throws UnsupportedOperationException
.
Invokes the underlying ListIterator.set(Object)
method.
Set sets the value of the singleton.
Changes the array that the ArrayIterator should iterate over.
Sets the bean to be operated on by this map.
Set the Comparator
by which I collate.
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.
Set the Iterator at the given index
Set the Iterator at the given index
Sets the underlying iterator.
Setter for property iterator.
Setter for property iterator.
Utility method for implementations to set the map that backs
this bag.
Setter for property maximumSize.
Setter for property predicate.
Setter for the predicate property.
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.
Setter for property transformer.
Provides static utility methods and decorators for Set
and SortedSet
instances.
Note that this method only sets the local reference inside this object and
does not modify the original Map.
SingletonIterator
is an Iterator
over a single
object instance.
SingletonIterator
is an Iterator
over a single
object instance.
Gets a singleton iterator.
Constructs a new SingletonIterator
.
Constructs a new SingletonIterator
.
SingletonIterator
is an ListIterator
over a single
object instance.
Gets a singleton list iterator.
Constructs a new SingletonListIterator
.
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.
Number of Comparators in the current ComparatorChain.
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.
Number of Iterators in the current IteratorChain.
Invokes the underlying Map.size()
method.
Returns the size of this map.
Returns the number of mappings in this map
Returns the size of the stack.
Returns the number of elements stored in the buffer.
Constant indiciating that soft references should be used.
HashMap with SoftReference links to values which allows the values of the Map
to be garbage collected by the JVM if it becomes low on memory.
A type of
Bag
that maintains order among its unique
representative members.
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 a specified number of buckets.
This class implements a stack for String objects.
Creates an empty instance.
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 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.
Returns a synchronized (thread-safe) bag backed by the given bag.
Returns a synchronized buffer backed by the given buffer.
A thread safe version of the PriorityQueue.
Constructs a new synchronized priority queue.
Returns a synchronized (thread-safe) sorted bag backed by the given
sorted bag.
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.
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.
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.
Gets a list based on an iterator.
Gets a list based on an iterator.
Gets a list iterator based on a simple iterator.
Gets a new Properties object initialised with the values from a Map.
Returns a string representation of this heap.
Returns a String
representation of this list, suitable for debugging.
Implement a toString() method suitable for debugging
Return a String representation of this object.
Provides a string representation of the entries within the map.
Converts the stack to a single java.lang.String
with no
separator.
Returns a string representation of the underlying queue.
Converts the stack to a single java.lang.String
.
Turns this stack into an array.
Transform the collection by applying a Transformer to each element.
Transforms the input object (leaving it unchanged) into some output object.
Transforms the given object using the transformer.
Gets a Comparator that passes transformed objects to the given comparator.
Gets an iterator that transforms the elements of another iterator.
An object capable of transforming an input object into some output object.
Decorates another Comparator with transformation behavior.
Constructs an instance with the given Transformer and a ComparableComparator.
Constructs an instance with the given Transformer and Comparator
A Proxy
Iterator
which uses a
Transformer
instance to
transform the contents of the
Iterator
into some other form
A Proxy
Iterator
which uses a
Transformer
instance to
transform the contents of the
Iterator
into some other form
Constructs a new
TransformIterator
that will not function
until the
setIterator
method is
invoked.
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 won't transform
elements from the given iterator.
Constructs a new TransformIterator
that will use the
given iterator and transformer.
Constructs a new TransformIterator
that will use the
given iterator and transformer.
An implementation of
Bag
that is backed by a
TreeMap
.
Constructs a new empty TreeBag
.
New
Bag
containing all the members of the given
collection.
New
Bag
that maintains order on its unique
representative members according to the given
Comparator
.
Trim the capacity of this ArrayList
instance to be the
list's current size.