All Packages  Class Hierarchy  This Package  Previous  Next  Index

Interface collections.UpdatableSeq

public interface interface UpdatableSeq

extends UpdatableCollection, Seq

appendElements(Enumeration)

Append all elements of enumeration e, preserving their order.

insertAt(int, Object)

Insert element at indicated index.

insertElementsAt(int, Enumeration)

Insert all elements of enumeration e at a given index, preserving their order.

insertFirst(Object)

Insert element at front of the sequence.

insertLast(Object)

insert element at end of the sequence Behaviorally equivalent to insertAt(size(), element)

prependElements(Enumeration)

Prepend all elements of enumeration e, preserving their order.

removeAt(int)

Remove element at indicated index.

removeFirst()

Remove the leftmost element.

removeFromTo(int, int)

Remove the elements from fromIndex to toIndex, inclusive.

removeLast()

Remove the rightmost element.

replaceAt(int, Object)

replace element at indicated index with new value

replaceFirst(Object)

replace element at front of the sequence with new value.

replaceLast(Object)

replace element at end of the sequence with new value Behaviorally equivalent to replaceAt(size()-1, element);

 public abstract void insertAt(int index,
                               Object element) throws IllegalElementException, NoSuchElementException

Insert element at indicated index. The index can range from 0..size() (i.e., one past the current last index). If the index is equal to size(), the element is appended as the new last element.

Parameters:

index - the index to add at

element - the element to add

Returns:

condition:

 size() == PREV(this).size()+1 &&
 at(index).equals(element) &&
 foreach (int i in 0 .. index-1)      at(i).equals(PREV(this).at(i))
 foreach (int i in index+1..size()-1) at(i).equals(PREV(this).at(i-1))
 Version change: always
 

Throws: NoSuchElementException

if index is not in range 0..size()

Throws: IllegalElementException

if !canInclude(element)

 public abstract void replaceAt(int index,
                                Object element) throws IllegalElementException, NoSuchElementException

replace element at indicated index with new value

Parameters:

index - the index at which to replace value

element - the new value

Returns:

condition:

 size() == PREV(this).size() &&
 at(index).equals(element) &&
 no spurious effects
 Version change <-- !element.equals(PREV(this).at(index)
                    (but MAY change even if equal).
 

Throws: NoSuchElementException

if index is not in range 0..size()-1

Throws: IllegalElementException

if !canInclude(element)

 public abstract void removeAt(int index) throws NoSuchElementException

Remove element at indicated index. All elements to the right have their indices decremented by one.

Parameters:

index - the index of the element to remove

Returns:

condition:

 size() = PREV(this).size()-1 &&
 foreach (int i in 0..index-1)      at(i).equals(PREV(this).at(i)); &&
 foreach (int i in index..size()-1) at(i).equals(PREV(this).at(i+1));
 Version change: always
 

Throws: NoSuchElementException

if index is not in range 0..size()-1

 public abstract void insertFirst(Object element) throws IllegalElementException

Insert element at front of the sequence. Behaviorally equivalent to insertAt(0, element)

Parameters:

element - the element to add

Throws: IllegalElementException

if !canInclude(element)

 public abstract void replaceFirst(Object element) throws IllegalElementException, NoSuchElementException

replace element at front of the sequence with new value. Behaviorally equivalent to replaceAt(0, element);

 public abstract void removeFirst() throws NoSuchElementException

Remove the leftmost element. Behaviorally equivalent to removeAt(0);

 public abstract void insertLast(Object element) throws IllegalElementException

insert element at end of the sequence Behaviorally equivalent to insertAt(size(), element)

Parameters:

element - the element to add

Throws: IllegalElementException

if !canInclude(element)

 public abstract void replaceLast(Object element) throws IllegalElementException, NoSuchElementException

replace element at end of the sequence with new value Behaviorally equivalent to replaceAt(size()-1, element);

 public abstract void removeLast() throws NoSuchElementException

Remove the rightmost element. Behaviorally equivalent to removeAt(size()-1);

Throws: NoSuchElementException

if isEmpty

 public abstract void removeFromTo(int fromIndex,
                                   int toIndex) throws NoSuchElementException

Remove the elements from fromIndex to toIndex, inclusive. No effect if fromIndex > toIndex. Behaviorally equivalent to

 for (int i = fromIndex; i <= toIndex; ++i) removeAt(fromIndex);
 

Parameters:

index - the index of the first element to remove

index - the index of the last element to remove

Returns:

condition:

 let n = max(0, toIndex - fromIndex + 1 in
  size() == PREV(this).size() - 1 &&
  for (int i in 0 .. fromIndex - 1)     at(i).equals(PREV(this).at(i)) && 
  for (int i in fromIndex .. size()- 1) at(i).equals(PREV(this).at(i+n) 
  Version change iff n > 0 
 

Throws: NoSuchElementException

if fromIndex or toIndex is not in range 0..size()-1

 public abstract void insertElementsAt(int index,
                                       Enumeration e) throws IllegalElementException, CorruptedEnumerationException, NoSuchElementException

Insert all elements of enumeration e at a given index, preserving their order. The index can range from 0..size() (i.e., one past the current last index). If the index is equal to size(), the elements are appended.

Parameters:

index - the index to start adding at

e - the elements to add

Returns:

condition:

 foreach (int i in 0 .. index-1) at(i).equals(PREV(this)at(i)); &&
 All existing elements at indices at or greater than index have their
  indices incremented by the number of elements 
  traversable via e.nextElement() &&
 The new elements are at indices index + their order in
   the enumeration's nextElement traversal.
 !(e.hasMoreElements()) &&
 (version() != PREV(this).version()) == PREV(e).hasMoreElements() 
 

Throws: IllegalElementException

if !canInclude some element of e; this may or may not nullify the effect of insertions of other elements.

Throws: NoSuchElementException

if index is not in range 0..size()

Throws: CorruptedEnumerationException

is propagated if raised; this may or may not nullify the effects of insertions of other elements.

 public abstract void prependElements(Enumeration e) throws IllegalElementException, CorruptedEnumerationException

Prepend all elements of enumeration e, preserving their order. Behaviorally equivalent to addElementsAt(0, e)

Parameters:

e - the elements to add

 public abstract void appendElements(Enumeration e) throws IllegalElementException, CorruptedEnumerationException

Append all elements of enumeration e, preserving their order. Behaviorally equivalent to addElementsAt(size(), e)

Parameters:

e - the elements to add

All Packages  Class Hierarchy  This Package  Previous  Next  Index