Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

jaggregate
Class OrderedCollection<E>

java.lang.Object
  extended by jaggregate.AbstractCollection<E>
      extended by jaggregate.AbstractExtensibleCollection<E>
          extended by jaggregate.OrderedCollection<E>
Type Parameters:
E - a restriction on the types of elements that may be included in the collection
All Implemented Interfaces:
Collection<E>, ContractibleSequence<E>, ExtensibleCollection<E>, ReadOnlySequence<E>, Sequence<E>, Serializable
public class OrderedCollection<E>
extends AbstractExtensibleCollection<E>
implements ContractibleSequence<E>, Sequence<E>, Serializable

Represents an ordered, variable-sized collection of objects, where elements may be added, removed, or inserted, and can be accessed using external integer keys.

Version:
$Id: OrderedCollection.java,v 1.8 2008/10/03 19:01:23 pholser Exp $
Author:
Paul Holser
See Also:
Serialized Form

Constructor Summary
OrderedCollection()
          Creates an empty ordered collection.
OrderedCollection(Collection<? extends E> elements)
          Creates an ordered collection containing the elements in the given collection.
OrderedCollection(E... elements)
          Creates an ordered collection containing the elements in the given array.
OrderedCollection(int capacity)
          Creates an empty ordered collection with the given initial capacity.
OrderedCollection(Iterable<? extends E> elements)
          Creates an ordered collection containing the elements in the given iterable object.
 
Method Summary
 void add(E newElement)
          Adds a new element to this collection.

newElement is added to the end of this collection's elements so that it becomes the last element in the traversal order.
 void addAfter(E newElement, E target)
          Adds a new element to this collection immediately following the first element which is equivalent to a given target.
 void addAfterIndex(E newElement, int index)
          Adds a new element to this collection immediately following the element at the given index.
 void addAllAfter(Collection<? extends E> newElements, E target)
          Adds each element of the given collection to this collection immediately after the first element in this collection which is equivalent to a given target.
 void addAllAfter(E[] newElements, E target)
           
 void addAllAfter(Iterable<? extends E> newElements, E target)
           
 void addAllAfterIndex(Collection<? extends E> newElements, int index)
          Adds each element of the given collection to this collection immediately following the element at the given index.
 void addAllAfterIndex(E[] newElements, int index)
           
 void addAllAfterIndex(Iterable<? extends E> newElements, int index)
           
 void addAllBefore(Collection<? extends E> newElements, E target)
          Adds each element of the given collection to this collection immediately before the first element in this collection which is equivalent to a given target.
 void addAllBefore(E[] newElements, E target)
           
 void addAllBefore(Iterable<? extends E> newElements, E target)
           
 void addAllBeforeIndex(Collection<? extends E> newElements, int index)
          Adds each element of the given collection to this collection immediately preceding the element at the given index.
 void addAllBeforeIndex(E[] newElements, int index)
           
 void addAllBeforeIndex(Iterable<? extends E> newElements, int index)
           
 void addAllFirst(Collection<? extends E> newElements)
          Adds each element of the given collection to the beginning of this collection's elements.
 void addAllFirst(E... newElements)
           
 void addAllFirst(Iterable<? extends E> newElements)
           
 void addAllLast(Collection<? extends E> newElements)
          Adds each element of the given collection to the end of this collection's elements.
 void addAllLast(E... newElements)
           
 void addAllLast(Iterable<? extends E> newElements)
           
 void addBefore(E newElement, E target)
          Adds a new element to this collection immediately preceding the first element which is equivalent to a given target.
 void addBeforeIndex(E newElement, int index)
          Adds a new element to this collection immediately preceding the element at the given index.
 void addFirst(E newElement)
          Adds a new element to the beginning of this collection's elements.
 void addLast(E newElement)
          Adds a new element to the end of this collection's elements.
 E after(E target)
          Answers the object immediately following the first element which is equivalent to the given target in this sequence.
 E at(int index)
          Answers the element at the given position in this sequence.
 E before(E target)
          Answers the object immediately preceding the first element which is equivalent to the given target in this sequence.
<R> OrderedCollection<R>
collect(UnaryFunctor<? super E,? extends R> transformer)
          Evaluates the given transformer for each element of this collection, with the element as the parameter, and answers a new collection containing the results of these evaluations.

The elements are traversed in the order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection.
 OrderedCollection<E> concat(ReadOnlySequence<? extends E> otherSequence)
          Answers a new sequence containing all of this sequence's elements in their original order followed by all of the elements of the given sequence, in their original order.
 OrderedCollection<E> copyRange(int start, int stop)
          Answers a new sequence containing the specified range of elements of this sequence in their original order.
 OrderedCollection<E> copyWith(E newElement)
          Answers a new sequence with size one greater than the size of this sequence, containing the elements of this sequence and a given new element placed at the end.
 OrderedCollection<E> copyWithout(E oldElement)
          Answers a new sequence with all of the elements of this sequence that are not equivalent to the given element, in their original order.
 void doWithIndex(BinaryFunctor<? super Integer,? super E,?> operation)
          Evaluates the given operation with the index of each element of this sequence, in order, together with the element itself.
<T> void
doWithOthers(ReadOnlySequence<? extends T> otherSequence, BinaryFunctor<? super E,? super T,?> operation)
          For each element of this sequence and the corresponding element of the given sequence, evaluates the given operation with this sequence's element as the first parameter, and the element of the other sequence as the second parameter.
static
<T> OrderedCollection<T>
emptyOrderedCollection()
          Creates an empty ordered collection.
 boolean equals(Object that)
          
 int findFirst(UnaryCondition<? super E> discriminator)
          Answers the index of the first element which causes the given discriminator to answer true when the element is used as a parameter.
 int findLast(UnaryCondition<? super E> discriminator)
          Answers the index of the last element which causes the given discriminator to answer true when the element is used as a parameter.
 E first()
          Answers the element at index 0 in this sequence.
 void forEachDo(UnaryFunctor<? super E,?> operation)
          For each element of this collection, evaluates the given operation with the element as the parameter.
 void forEachInRangeDo(int start, int stop, UnaryFunctor<? super E,?> operation)
          For those elements of this sequence between two given positions, inclusive, evaluates the given operation with the element at that index as its argument.
 void forEachInRangeDoWithIndex(int start, int stop, BinaryFunctor<? super Integer,? super E,?> operation)
          For those elements of this sequence between two given positions, inclusive, evaluates the given operation with an element of this sequence as the first argument and the element's position (index) as the second.
 void forEachInReverseDo(UnaryFunctor<? super E,?> operation)
          Evaluates the given operation with each element of this sequence in the reverse of this sequence's standard traversal order.
 int hashCode()
          
 int indexOf(E target)
          Answers the index of the first element which is equivalent to the given target}.
 int indexOf(ReadOnlySequence<? extends E> targetSequence, int start)
          Answers the index of the first element of this sequence which is the start of a subsequence which matches a given target sequence.
 E last()
          Answers the last element of this sequence, the element at the index equal to this sequence's size minus 1.
static
<T> OrderedCollection<T>
orderedCollectionFrom(Collection<? extends T> elements)
          Creates an ordered collection containing the elements in the given collection.
static
<T> OrderedCollection<T>
orderedCollectionFrom(Iterable<? extends T> elements)
          Creates an ordered collection containing the elements in the given iterable object.
static
<T> OrderedCollection<T>
orderedCollectionFrom(T[] elements)
          Creates an ordered collection containing the elements in the given array.
static
<T> OrderedCollection<T>
orderedCollectionWith(T newElement, T... restOfNewElements)
          Creates an ordered collection containing the given elements.
 E putAt(int index, E newElement)
          Replaces the element in this sequence at a given index with a new element.
 void putAtAll(Collection<? extends Integer> indices, E newElement)
          Replaces the elements in this sequence specified by the given indices with a new element.
 void putAtAll(E newElement)
          Replaces all the elements in this sequence with a new element.
 void putAtAll(int[] indices, E newElement)
          
 void putAtAll(Integer[] indices, E newElement)
          
 void putAtAll(Iterable<? extends Integer> indices, E newElement)
          
 OrderedCollection<E> reject(UnaryCondition<? super E> discriminator)
          Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer false.

For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer false is included in the new collection.

The elements are traversed in the order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.
 boolean remove(E oldElement)
          Removes the first element of this collection which is equivalent to the given element.
 E removeAt(int index)
          Removes and answers the element at a given position in this sequence.
 E removeFirst()
          Removes and answers the first element of this sequence.
 boolean removeIf(UnaryCondition<? super E> discriminator)
          Removes each element of this collection which causes the given discriminator to answer true.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.
 E removeLast()
          Removes and answers the last element of this sequence.
 void replace(int start, int stop, E replacement)
          Replaces the elements of this sequence between two positions, inclusive, with a given element.
 void replaceRange(int start, int stop, ReadOnlySequence<? extends E> replacements)
          Replaces the elements of this sequence between two positions, inclusive, with a given replacement sequence in their original order.
 void replaceRange(int start, int stop, ReadOnlySequence<? extends E> replacements, int replacementStart)
          Replaces the elements of this sequence between two positions, inclusive, with a given replacement sequence, in their original order, starting at a given position in the replacement sequence.
 boolean retainIf(UnaryCondition<? super E> discriminator)
          Removes each element of this collection which causes the given discriminator to answer false.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.
 OrderedCollection<E> reverse()
          Answers a sequence with the elements of this sequence arranged in reverse order.
 OrderedCollection<E> select(UnaryCondition<? super E> discriminator)
          Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer true.

For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer true is included in the new collection.

The elements are traversed in order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.
 int size()
          Answers the number of elements in this collection.
 Object[] toArray(Class<? super E> componentClass)
          Answers an array with the same elements as this collection, with the same size as this collection, and a component type of the given class. This means that only elements of the given class or any of its derivatives may be inserted into the result.

Note that even though the given class will be the runtime component class of the result array, the return type of this method is Object[]. With Java generics, it is not possible to express the return type as an array of the component class without sacrificing the flexibility of providing a componentClass that is a supertype of the generic parameter's actual argument. Therefore, the caller should downcast to the desired type, or risk raising ArrayStoreException when inserting via a reference of type Object[].

If this collection maintains an ordering for its elements, the order of those elements will be preserved in the result.
 OrderedCollection<E> toOrderedCollection()
          Answers an ordered collection with the same elements as this collection. The result has the same size as this collection.

If this collection maintains an ordering for its elements, the order of those elements will be preserved in the result.

Answers self.
 String toString()
          
 
Methods inherited from class jaggregate.AbstractExtensibleCollection
addAll, addAll, addAll, addAll, removeAll, removeAll, removeAll, removeAll, retainAll, retainAll, retainAll, retainAll
 
Methods inherited from class jaggregate.AbstractCollection
allSatisfy, anySatisfy, detect, includes, inject, isEmpty, occurrencesOf, rehash, toArray, toBag, toIdentityBag, toIdentitySet, toSet, toSortedCollection, toSortedCollection
 
Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait
 

Constructor Detail

OrderedCollection

public OrderedCollection()
Creates an empty ordered collection.

OrderedCollection

public OrderedCollection(Collection<? extends E> elements)
Creates an ordered collection containing the elements in the given collection.

Parameters:
elements - elements to add to the new ordered collection
Throws:
NullPointerException - if elements is null

OrderedCollection

public OrderedCollection(E... elements)
Creates an ordered collection containing the elements in the given array.

Parameters:
elements - elements to add to the new ordered collection
Throws:
NullPointerException - if elements is null

OrderedCollection

public OrderedCollection(Iterable<? extends E> elements)
Creates an ordered collection containing the elements in the given iterable object.

Parameters:
elements - elements to add to the new ordered collection
Throws:
NullPointerException - if elements is null

OrderedCollection

public OrderedCollection(int capacity)
Creates an empty ordered collection with the given initial capacity.

Parameters:
capacity - the initial capacity
Throws:
IllegalArgumentException - if capacity <= 0
Method Detail

emptyOrderedCollection

public static <T> OrderedCollection<T> emptyOrderedCollection()
Creates an empty ordered collection.

Type Parameters:
T - the type of elements allowed in the new ordered collection
Returns:
a new empty ordered collection

orderedCollectionFrom

public static <T> OrderedCollection<T> orderedCollectionFrom(Collection<? extends T> elements)
Creates an ordered collection containing the elements in the given collection.

Type Parameters:
T - the type of elements allowed in the new ordered collection
Parameters:
elements - elements to add to the new ordered collection
Returns:
the new ordered collection
Throws:
NullPointerException - if elements is null

orderedCollectionFrom

public static <T> OrderedCollection<T> orderedCollectionFrom(T[] elements)
Creates an ordered collection containing the elements in the given array.

Type Parameters:
T - the type of elements allowed in the new ordered collection
Parameters:
elements - elements to add to the new ordered collection
Returns:
a new ordered collection
Throws:
NullPointerException - if elements is null

orderedCollectionWith

public static <T> OrderedCollection<T> orderedCollectionWith(T newElement,
                                                             T... restOfNewElements)
Creates an ordered collection containing the given elements.

Type Parameters:
T - the type of elements allowed in the new ordered collection
Parameters:
newElement - first new element to ordered collection
restOfNewElements - remainder of the elements to ordered collection
Returns:
a new ordered collection
Throws:
NullPointerException - if restOfNewElements is null
IllegalArgumentException - if any of the new elements is found to violate restrictions on the characteristics of valid elements
See Also:
AbstractExtensibleCollection.addAll(Collection)

orderedCollectionFrom

public static <T> OrderedCollection<T> orderedCollectionFrom(Iterable<? extends T> elements)
Creates an ordered collection containing the elements in the given iterable object.

Type Parameters:
T - the type of elements allowed in the new ordered collection
Parameters:
elements - elements to add to the new ordered collection
Returns:
a new ordered collection
Throws:
NullPointerException - if elements is null

toArray

public Object[] toArray(Class<? super E> componentClass)
Answers an array with the same elements as this collection, with the same size as this collection, and a component type of the given class. This means that only elements of the given class or any of its derivatives may be inserted into the result.

Note that even though the given class will be the runtime component class of the result array, the return type of this method is Object[]. With Java generics, it is not possible to express the return type as an array of the component class without sacrificing the flexibility of providing a componentClass that is a supertype of the generic parameter's actual argument. Therefore, the caller should downcast to the desired type, or risk raising ArrayStoreException when inserting via a reference of type Object[].

If this collection maintains an ordering for its elements, the order of those elements will be preserved in the result.

Specified by:
toArray in interface Collection<E>
Overrides:
toArray in class AbstractCollection<E>
Parameters:
componentClass - the desired type of the result array's components
Returns:
an array of this collection's elements
See Also:
Collections.toArray(Collection,Class)

toOrderedCollection

public OrderedCollection<E> toOrderedCollection()
Answers an ordered collection with the same elements as this collection. The result has the same size as this collection.

If this collection maintains an ordering for its elements, the order of those elements will be preserved in the result.

Answers self.

Specified by:
toOrderedCollection in interface Collection<E>
Overrides:
toOrderedCollection in class AbstractCollection<E>
Returns:
an ordered collection of this collection's elements

collect

public <R> OrderedCollection<R> collect(UnaryFunctor<? super E,? extends R> transformer)
Evaluates the given transformer for each element of this collection, with the element as the parameter, and answers a new collection containing the results of these evaluations.

The elements are traversed in the order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection.

Specified by:
collect in interface Collection<E>
Specified by:
collect in interface ContractibleSequence<E>
Specified by:
collect in interface ExtensibleCollection<E>
Specified by:
collect in interface ReadOnlySequence<E>
Specified by:
collect in interface Sequence<E>
Overrides:
collect in class AbstractExtensibleCollection<E>
Type Parameters:
R - return type of the transformer
Parameters:
transformer - the transformer to evaluate
Returns:
a collection of the transformations

forEachDo

public void forEachDo(UnaryFunctor<? super E,?> operation)
For each element of this collection, evaluates the given operation with the element as the parameter.

Unless specifically refined, the elements are not traversed in a particular order. Each element is visited exactly once. Conformant protocols may refine this message to specify a particular ordering.

Specified by:
forEachDo in interface Collection<E>
Specified by:
forEachDo in interface ReadOnlySequence<E>
Parameters:
operation - the operation to perform

reject

public OrderedCollection<E> reject(UnaryCondition<? super E> discriminator)
Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer false.

For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer false is included in the new collection.

The elements are traversed in the order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.

Specified by:
reject in interface Collection<E>
Specified by:
reject in interface ContractibleSequence<E>
Specified by:
reject in interface ExtensibleCollection<E>
Specified by:
reject in interface ReadOnlySequence<E>
Specified by:
reject in interface Sequence<E>
Overrides:
reject in class AbstractExtensibleCollection<E>
Parameters:
discriminator - the discriminator to evaluate
Returns:
a collection of the rejected elements of this collection

select

public OrderedCollection<E> select(UnaryCondition<? super E> discriminator)
Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer true.

For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer true is included in the new collection.

The elements are traversed in order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.

Specified by:
select in interface Collection<E>
Specified by:
select in interface ContractibleSequence<E>
Specified by:
select in interface ExtensibleCollection<E>
Specified by:
select in interface ReadOnlySequence<E>
Specified by:
select in interface Sequence<E>
Overrides:
select in class AbstractExtensibleCollection<E>
Parameters:
discriminator - the discriminator to evaluate
Returns:
a collection of the selected elements of this collection

size

public int size()
Answers the number of elements in this collection.

Specified by:
size in interface Collection<E>
Returns:
the number of elements in this collection

findFirst

public int findFirst(UnaryCondition<? super E> discriminator)
Answers the index of the first element which causes the given discriminator to answer true when the element is used as a parameter. Answers -1 if no such element is found.

The elements are traversed in the order specified by forEachDo for this sequence.

Specified by:
findFirst in interface ReadOnlySequence<E>
Parameters:
discriminator - the discriminator to evaluate
Returns:
the index of the first match, or -1 if there is no match

findLast

public int findLast(UnaryCondition<? super E> discriminator)
Answers the index of the last element which causes the given discriminator to answer true when the element is used as a parameter. Answers -1 if no such element is found.

The elements are traversed in the order specified by forEachInReverseDo for this sequence.

Specified by:
findLast in interface ReadOnlySequence<E>
Parameters:
discriminator - the discriminator to evaluate
Returns:
the index of the last match, or -1 if there is no match

forEachInReverseDo

public void forEachInReverseDo(UnaryFunctor<? super E,?> operation)
Evaluates the given operation with each element of this sequence in the reverse of this sequence's standard traversal order. The elements are traversed in the opposite order from forEachDo. Each element is visited exactly once.

Specified by:
forEachInReverseDo in interface ReadOnlySequence<E>
Parameters:
operation - the operation to evaluate

first

public E first()
Answers the element at index 0 in this sequence.

Specified by:
first in interface ReadOnlySequence<E>
Returns:
the first element in the sequence

forEachInRangeDo

public void forEachInRangeDo(int start,
                             int stop,
                             UnaryFunctor<? super E,?> operation)
For those elements of this sequence between two given positions, inclusive, evaluates the given operation with the element at that index as its argument.

Specified by:
forEachInRangeDo in interface ReadOnlySequence<E>
Parameters:
start - beginning index
stop - ending index
operation - the operation to evaluate

forEachInRangeDoWithIndex

public void forEachInRangeDoWithIndex(int start,
                                      int stop,
                                      BinaryFunctor<? super Integer,? super E,?> operation)
For those elements of this sequence between two given positions, inclusive, evaluates the given operation with an element of this sequence as the first argument and the element's position (index) as the second.

Specified by:
forEachInRangeDoWithIndex in interface ReadOnlySequence<E>
Parameters:
start - beginning index
stop - ending index
operation - the operation to evaluate

indexOf

public int indexOf(E target)
Answers the index of the first element which is equivalent to the given target}. Answers -1 if no such element is found.

The elements are traversed in the order specified by forEachDo for this sequence.

Specified by:
indexOf in interface ReadOnlySequence<E>
Parameters:
target - element to match
Returns:
index of first match, or -1 if no match

indexOf

public int indexOf(ReadOnlySequence<? extends E> targetSequence,
                   int start)
Answers the index of the first element of this sequence which is the start of a subsequence which matches a given target sequence.

Each subsequence of this sequence starting at index start is checked for a match with targetSequence. To match, each element of a subsequence of this sequence must be equivalent to the corresponding element of\ targetSequence. Answers the index of the first element which begins a matching subsequence; no further subsequences are considered. Answers -1 if no such subsequence is found in this sequence, or if targetSequence is empty.

The elements are traversed in the order specified by forEachDo message for this sequence.

Specified by:
indexOf in interface ReadOnlySequence<E>
Parameters:
targetSequence - sequence to match
start - index at which to begin the search
Returns:
index of the beginning of the first match, or -1 if none

doWithIndex

public void doWithIndex(BinaryFunctor<? super Integer,? super E,?> operation)
Evaluates the given operation with the index of each element of this sequence, in order, together with the element itself.

operation is evaluated with the index of each element of this sequence as the first argument and the element itself as the second argument. Evaluation is in indexed order starting at 0. The first element is at index 0, the second at index 1, etc. The index of the last element is equal to this sequence's size minus 1.

Specified by:
doWithIndex in interface ReadOnlySequence<E>
Parameters:
operation - the operation to perform

last

public E last()
Answers the last element of this sequence, the element at the index equal to this sequence's size minus 1.

Specified by:
last in interface ReadOnlySequence<E>
Returns:
the last element in the sequence

add

public void add(E newElement)
Adds a new element to this collection. Unless specifically refined, the position of newElement in the element traversal order is unspecified.

Conformant protocols may place restrictions on the characteristics of objects that are valid elements. Unless otherwise specified, any object that is of the same class as or of a subclass of this collection's type parameter is acceptable.

newElement is added to the end of this collection's elements so that it becomes the last element in the traversal order. This message is equivalent to addLast for this collection with newElement as the parameter.

Specified by:
add in interface ExtensibleCollection<E>
Parameters:
newElement - the element to add

remove

public boolean remove(E oldElement)
Removes the first element of this collection which is equivalent to the given element.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.

Specified by:
remove in interface ExtensibleCollection<E>
Parameters:
oldElement - the element to remove
Returns:
true if any removal occurred

removeIf

public boolean removeIf(UnaryCondition<? super E> discriminator)
Removes each element of this collection which causes the given discriminator to answer true.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.

Specified by:
removeIf in interface ExtensibleCollection<E>
Overrides:
removeIf in class AbstractExtensibleCollection<E>
Parameters:
discriminator - the discriminator to evaluate
Returns:
true if any removal occurred

retainIf

public boolean retainIf(UnaryCondition<? super E> discriminator)
Removes each element of this collection which causes the given discriminator to answer false.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.

Specified by:
retainIf in interface ExtensibleCollection<E>
Overrides:
retainIf in class AbstractExtensibleCollection<E>
Parameters:
discriminator - the discriminator to evaluate
Returns:
true if any removal occurred

removeAt

public E removeAt(int index)
Removes and answers the element at a given position in this sequence.

Specified by:
removeAt in interface ContractibleSequence<E>
Parameters:
index - the index at which to remove the element
Returns:
the removed element

removeFirst

public E removeFirst()
Removes and answers the first element of this sequence.

Specified by:
removeFirst in interface ContractibleSequence<E>
Returns:
the removed element

removeLast

public E removeLast()
Removes and answers the last element of this sequence.

Specified by:
removeLast in interface ContractibleSequence<E>
Returns:
the removed element

concat

public OrderedCollection<E> concat(ReadOnlySequence<? extends E> otherSequence)
Answers a new sequence containing all of this sequence's elements in their original order followed by all of the elements of the given sequence, in their original order. The size of the new sequence is equal to the sum of the sizes of this sequence and otherSequence.

Sequences that enforce an ordering on their elements are permitted to refine this message to reorder the result.

Specified by:
concat in interface ReadOnlySequence<E>
Specified by:
concat in interface Sequence<E>
Parameters:
otherSequence - the sequence to concatenate
Returns:
the result of the concatenation

after

public E after(E target)
Answers the object immediately following the first element which is equivalent to the given target in this sequence. An element immediately follows another if its index is one greater than that of the other. The order used to determine which of this sequence's elements is the first to be equivalent to target is the traversal order defined by forEachDo for this sequence.

Specified by:
after in interface ReadOnlySequence<E>
Parameters:
target - the object to lookup
Returns:
the object following target

at

public E at(int index)
Answers the element at the given position in this sequence.

Specified by:
at in interface ReadOnlySequence<E>
Parameters:
index - the index to lookup
Returns:
the corresponding element

before

public E before(E target)
Answers the object immediately preceding the first element which is equivalent to the given target in this sequence. An element immediately precedes another if its index is one less than that of the other.

Specified by:
before in interface ReadOnlySequence<E>
Parameters:
target - the object to lookup
Returns:
the object preceding target

copyRange

public OrderedCollection<E> copyRange(int start,
                                      int stop)
Answers a new sequence containing the specified range of elements of this sequence in their original order. The element at index start in this sequence is at index 0 in the new sequence; the element at start + 1 is at index 1, etc. If stop < start, then the new sequence is empty. Otherwise, the size of the new sequence is max(0, stop - start).

The given indices must be non-negative.

Specified by:
copyRange in interface ReadOnlySequence<E>
Specified by:
copyRange in interface Sequence<E>
Parameters:
start - the beginning index
stop - the ending index
Returns:
a new sequence containing the specified range of elements

copyWith

public OrderedCollection<E> copyWith(E newElement)
Answers a new sequence with size one greater than the size of this sequence, containing the elements of this sequence and a given new element placed at the end.

Unless specifically refined, this message is defined to answer an instance of the same class as this sequence.

Sequences that enforce an ordering on their elements are permitted to refine this message to reorder the result.

Specified by:
copyWith in interface ReadOnlySequence<E>
Specified by:
copyWith in interface Sequence<E>
Parameters:
newElement - element to add to the copy
Returns:
copy of this sequence with newElement appended

copyWithout

public OrderedCollection<E> copyWithout(E oldElement)
Answers a new sequence with all of the elements of this sequence that are not equivalent to the given element, in their original order.

Specified by:
copyWithout in interface ReadOnlySequence<E>
Specified by:
copyWithout in interface Sequence<E>
Parameters:
oldElement - the element to strip from the copy of this sequence
Returns:
copy of this sequence with oldElement removed

reverse

public OrderedCollection<E> reverse()
Answers a sequence with the elements of this sequence arranged in reverse order.

This operation is equivalent to:

  1. Create a new sequence which conforms to the same protocols as this sequence.
  2. Traverse the elements of this sequence in the order specified by forEachInReverseDo message, adding each element of this sequence to the new sequence.
  3. Answer the new sequence.

Specified by:
reverse in interface ReadOnlySequence<E>
Specified by:
reverse in interface Sequence<E>
Returns:
a new sequence with the elements of this sequence in reverse order

doWithOthers

public <T> void doWithOthers(ReadOnlySequence<? extends T> otherSequence,
                             BinaryFunctor<? super E,? super T,?> operation)
For each element of this sequence and the corresponding element of the given sequence, evaluates the given operation with this sequence's element as the first parameter, and the element of the other sequence as the second parameter. This sequence and otherSequence must have the same size.

The elements of this sequence and otherSequence are traversed in indexed order starting at 0. The operation is evaluated with the elements at index 0 in the two sequences, then index 1, etc.

Specified by:
doWithOthers in interface ReadOnlySequence<E>
Type Parameters:
T - a constraint on the types of elements in the given sequence
Parameters:
otherSequence - the other elements to use in the evaluation
operation - the operation to perform

putAt

public E putAt(int index,
               E newElement)
Replaces the element in this sequence at a given index with a new element.

Specified by:
putAt in interface Sequence<E>
Parameters:
index - the index at which to replace the element
newElement - the element to place at index
Returns:
the previous element at index, or null if there is no such element

putAtAll

public void putAtAll(Collection<? extends Integer> indices,
                     E newElement)
Replaces the elements in this sequence specified by the given indices with a new element.

This message is equivalent to storing newElement in this sequence at each index specified by indices using putAt.

Specified by:
putAtAll in interface Sequence<E>
Parameters:
indices - the indices at which to replace elements
newElement - the element to place at each of the indices

putAtAll

public void putAtAll(int[] indices,
                     E newElement)

Specified by:
putAtAll in interface Sequence<E>
Parameters:
indices - the indices at which to replace elements
newElement - the element to place at each of the indices
See Also:
Sequence.putAtAll(Collection,Object)

putAtAll

public void putAtAll(Integer[] indices,
                     E newElement)

Specified by:
putAtAll in interface Sequence<E>
Parameters:
indices - the indices at which to replace elements
newElement - the element to place at each of the indices
See Also:
Sequence.putAtAll(Collection,Object)

putAtAll

public void putAtAll(Iterable<? extends Integer> indices,
                     E newElement)

Specified by:
putAtAll in interface Sequence<E>
Parameters:
indices - the indices at which to replace elements
newElement - the element to place at each of the indices
See Also:
Sequence.putAtAll(Collection,Object)

putAtAll

public void putAtAll(E newElement)
Replaces all the elements in this sequence with a new element.

This message is equivalent to storing newElement in this sequence at each index from 0 to this sequence's size minus 1 using putAt.

Specified by:
putAtAll in interface Sequence<E>
Parameters:
newElement - the element to place at each index

replace

public void replace(int start,
                    int stop,
                    E replacement)
Replaces the elements of this sequence between two positions, inclusive, with a given element.

Specified by:
replace in interface Sequence<E>
Parameters:
start - beginning index
stop - ending index
replacement - element with which to replace the elements between start and stop, inclusive

replaceRange

public void replaceRange(int start,
                         int stop,
                         ReadOnlySequence<? extends E> replacements)
Replaces the elements of this sequence between two positions, inclusive, with a given replacement sequence in their original order.

The first element of replacements is stored in this sequence at position start, the second at position start + 1, etc. Any previously stored elements at these positions are replaced.

Specified by:
replaceRange in interface Sequence<E>
Parameters:
start - beginning index
stop - ending index
replacements - elements to replace in between start and stop, inclusive

replaceRange

public void replaceRange(int start,
                         int stop,
                         ReadOnlySequence<? extends E> replacements,
                         int replacementStart)
Replaces the elements of this sequence between two positions, inclusive, with a given replacement sequence, in their original order, starting at a given position in the replacement sequence.

The element at position replacementStart in replacements is stored in this sequence at position start; the element at replacementStart + 1 is stored at position start + 1; etc. Any previously stored elements at these positions are replaced.

Specified by:
replaceRange in interface Sequence<E>
Parameters:
start - beginning index
stop - ending index
replacements - elements to replace in between start and stop, inclusive
replacementStart - index to start at in replacements

addAfter

public void addAfter(E newElement,
                     E target)
Adds a new element to this collection immediately following the first element which is equivalent to a given target. An element immediately follows another if its index is one greater than that of the other. The order used to determine which of this collection's elements is the first to equal target is the traversal order defined by forEachDo for this collection.

Parameters:
newElement - the element to add
target - the element after which to add newElement
Throws:
NoSuchElementException - if this collection does not include target

addAfterIndex

public void addAfterIndex(E newElement,
                          int index)
Adds a new element to this collection immediately following the element at the given index. newElement is inserted at position index + 1. If index == -1, newElement becomes the first element of this collection.

Parameters:
newElement - the element to add
index - the index after which to add newElement
Throws:
IndexOutOfBoundsException - if index < -1 or index >= this collection's size.

addBefore

public void addBefore(E newElement,
                      E target)
Adds a new element to this collection immediately preceding the first element which is equivalent to a given target. An element immediately precedes another if its index is one less than that of the other. The order used to determine which of this collection's elements is the first to equal target is the traversal order defined by forEachDo for this collection.

Parameters:
newElement - the element to add
target - the element before which to add newElement
Throws:
NoSuchElementException - if this collection does not include target

addBeforeIndex

public void addBeforeIndex(E newElement,
                           int index)
Adds a new element to this collection immediately preceding the element at the given index. If index == this collection's size, then newElement will become the last element of this collection.

Parameters:
newElement - the element to add
index - the before after which to add newElement
Throws:
IndexOutOfBoundsException - if index < 0 or index > this collection's size.

addAllAfter

public void addAllAfter(Collection<? extends E> newElements,
                        E target)
Adds each element of the given collection to this collection immediately after the first element in this collection which is equivalent to a given target.

The elements of newElements are added to this collection in the traversal order defined by forEachDo for newElements. An element immediately follows another if its index is one greater than that of the other. The order used to determine which of this collection's elements is the first to equal target is the traversal order defined by forEachDo for this collection.

Parameters:
newElements - the elements to add
target - the element after which to perform the additions
Throws:
NullPointerException - if newElements is null
NoSuchElementException - if this collection does not include target

addAllAfter

public void addAllAfter(E[] newElements,
                        E target)
Parameters:
newElements - the elements to add
target - the element after which to perform the additions
Throws:
NullPointerException - if newElements is null
NoSuchElementException - if this collection does not include target
See Also:
addAllAfter(Collection,Object)

addAllAfter

public void addAllAfter(Iterable<? extends E> newElements,
                        E target)
Parameters:
newElements - the elements to add
target - the element after which to perform the additions
Throws:
NullPointerException - if newElements is null
NoSuchElementException - if this collection does not include target
See Also:
addAllAfter(Collection,Object)

addAllAfterIndex

public void addAllAfterIndex(Collection<? extends E> newElements,
                             int index)
Adds each element of the given collection to this collection immediately following the element at the given index.

The elements of newElements are added to this collection in the traversal order defined by forEachDo for newElements. newElements are inserted immediately after the element in this collection at position index. If index == -1, newElements are inserted at the beginning of this collection.

Parameters:
newElements - the elements to add
index - the index after which to add newElements
Throws:
NullPointerException - if newElements is null
IndexOutOfBoundsException - if index < -1 or index >= this collection's size

addAllAfterIndex

public void addAllAfterIndex(E[] newElements,
                             int index)
Parameters:
newElements - the elements to add
index - the index after which to add newElements
Throws:
NullPointerException - if newElements is null
IndexOutOfBoundsException - if index < -1 or index >= this collection's size
See Also:
addAllAfterIndex(Collection,int)

addAllAfterIndex

public void addAllAfterIndex(Iterable<? extends E> newElements,
                             int index)
Parameters:
newElements - the elements to add
index - the index after which to add newElements
Throws:
NullPointerException - if newElements is null
IndexOutOfBoundsException - if index < -1 or index >= this collection's size
See Also:
addAllAfterIndex(Collection,int)

addAllBefore

public void addAllBefore(Collection<? extends E> newElements,
                         E target)
Adds each element of the given collection to this collection immediately before the first element in this collection which is equivalent to a given target.

The elements of newElements are added to this collection in the traversal order defined by forEachDo for newElements. An element immediately precedes another if its index is one greater than that of the other. The order used to determine which of this collection's elements is the first to equal target is the traversal order defined by forEachDo for this collection.

Parameters:
newElements - the elements to add
target - the element before which to perform the additions
Throws:
NullPointerException - if newElements is null
NoSuchElementException - if this collection does not include target

addAllBefore

public void addAllBefore(E[] newElements,
                         E target)
Parameters:
newElements - the elements to add
target - the element before which to perform the additions
Throws:
NullPointerException - if newElements is null
NoSuchElementException - if this collection does not include target
See Also:
addAllBefore(Collection,Object)

addAllBefore

public void addAllBefore(Iterable<? extends E> newElements,
                         E target)
Parameters:
newElements - the elements to add
target - the element before which to perform the additions
Throws:
NullPointerException - if newElements is null
NoSuchElementException - if this collection does not include target
See Also:
addAllBefore(Collection,Object)

addAllBeforeIndex

public void addAllBeforeIndex(Collection<? extends E> newElements,
                              int index)
Adds each element of the given collection to this collection immediately preceding the element at the given index.

The elements of newElements are added to this collection in the traversal order defined by forEachDo for newElements. newElements are inserted immediately before the element in this collection at position index. If index == this collection's size, newElements are inserted at the end of this collection.

Parameters:
newElements - the elements to add
index - the index after which to add newElements
Throws:
NullPointerException - if newElements is null
IndexOutOfBoundsException - if index < 0 or index > this collection's size

addAllBeforeIndex

public void addAllBeforeIndex(E[] newElements,
                              int index)
Parameters:
newElements - the elements to add
index - the index after which to add newElements
Throws:
NullPointerException - if newElements is null
IndexOutOfBoundsException - if index < 0 or index > this collection's size
See Also:
addAllBeforeIndex(Collection,int)

addAllBeforeIndex

public void addAllBeforeIndex(Iterable<? extends E> newElements,
                              int index)
Parameters:
newElements - the elements to add
index - the index after which to add newElements
Throws:
NullPointerException - if newElements is null
IndexOutOfBoundsException - if index < 0 or index > this collection's size
See Also:
addAllBeforeIndex(Collection,int)

addAllFirst

public void addAllFirst(Collection<? extends E> newElements)
Adds each element of the given collection to the beginning of this collection's elements.

This operation is equivalent to adding each successive element of newElements to this collection using addFirst with the element as the parameter, where newElements are traversed in the order specified by forEachInReverseDo for newElements.

Parameters:
newElements - the elements to add
Throws:
NullPointerException - if newElements is null

addAllFirst

public void addAllFirst(E... newElements)
Parameters:
newElements - the elements to add
Throws:
NullPointerException - if newElements is null
See Also:
addAllFirst(Collection)

addAllFirst

public void addAllFirst(Iterable<? extends E> newElements)
Parameters:
newElements - the elements to add
Throws:
NullPointerException - if newElements is null
See Also:
addAllFirst(Collection)

addAllLast

public void addAllLast(Collection<? extends E> newElements)
Adds each element of the given collection to the end of this collection's elements.

This operation is equivalent to adding each successive element of newElements to this collection using addLast with the element as the parameter, where newElements are traversed in the order specified by forEachDo for newElements.

Parameters:
newElements - the elements to add
Throws:
NullPointerException - if newElements is null

addAllLast

public void addAllLast(E... newElements)
Parameters:
newElements - the elements to add
Throws:
NullPointerException - if newElements is null
See Also:
addAllLast(Collection)

addAllLast

public void addAllLast(Iterable<? extends E> newElements)
Parameters:
newElements - the elements to add
Throws:
NullPointerException - if newElements is null
See Also:
addAllLast(Collection)

addFirst

public void addFirst(E newElement)
Adds a new element to the beginning of this collection's elements. newElement becomes the first element in the traversal order.

Parameters:
newElement - the element to add

addLast

public void addLast(E newElement)
Adds a new element to the end of this collection's elements. newElement becomes the last element in the traversal order.

Parameters:
newElement - the element to add

equals

public boolean equals(Object that)

Overrides:
equals in class Object

hashCode

public int hashCode()

Overrides:
hashCode in class Object

toString

public String toString()

Overrides:
toString in class Object
Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
© Copyright 2004-2008 Paul R. Holser, Jr. All rights reserved. Licensed under the Academic Free License version 3.0. pholser@alumni.rice.edu