Vector (Parallel Template Library (PTL)™ 4.0)

java.lang.Object
- Progeneric.Ptl.Containers.Vector<T>

Type Parameters:
T - Specifies the type of elements in the sequence.
Remarks: The container is allocated in memory and the predefined maximum size can be at most 2,147,483,647 (Integer.MAX_VALUE) elements of type T.

All Implemented Interfaces:

IBackSequence<T>, IBidSequence32<T,Vector.Iterator>, IContainer32<T>, IFrontSequence<T>, IFwdContainer32<T,Vector.Iterator>, IFwdSequence32<T,Vector.Iterator>, IInsertSequence<T,Vector.Iterator>, IRanSequence32<T,Vector.Iterator>
```
public class Vector<T>
extends java.lang.Object
implements IRanSequence32<T,Vector.Iterator>, IInsertSequence<T,Vector.Iterator>
```
Defines a container with a predefined maximum size that allows fast random access to any element, constant time insertions and deletions at the beginning and the end of the sequence and linear time insertion and removal of elements in the middle.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Vector.Iterator` Defines a random iterator that provides constant-time methods for moving forward and backward in arbitrary-sized steps and for comparing two iterators.
`class`	`Vector.ReverseIterator` Defines a random-access iterator that enables backward traversal of a range.
`class`	`Vector.UIterator` Defines a random-access unchecked iterator that provides constant-time methods for moving forward and backward in arbitrary-sized steps and for comparing two iterators.
`class`	`Vector.UReverseIterator` Defines a reverse iterator that enables backward traversal of a range.

Constructor Summary

Constructors
Constructor and Description
`Vector(java.lang.Class<T> type, int maxSize)` Creates an empty sequence of the specified type.
`Vector(int n, T item, int maxSize)` Creates a sequence of the specified type and initializes it with the specified element.
`Vector(Vector<T> x)` Constructs a new instance of the Vector from another sequence.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`Add(int n, T item)` Appends to the back of the sequence n copies of the specified value.
`void`	`Add(T item)` Adds an element to the end of the sequence.
`<TInpIter extends IInpIter<T,TInpIter>> void`	`Add(TInpIter first, TInpIter last)` Appends the specified elements to the back of the sequence.
`void`	`Assign(int n, T item)` Erases all the elements and replaces them with n copies of item.
`void`	`Assign(T item)` Erases all the elements and replaces them with the specified value.
`<TInpIter extends IInpIter<T,TInpIter>> void`	`Assign(TInpIter first, TInpIter last)` Erases a sequence and copies the specified elements to the empty sequence.
`T`	`Back()` Gets the last element of the sequence.
`Vector.Iterator`	`Begin()` Returns a random-access iterator to the first element in the container.
`void`	`Clear()` Erases all the elements of the sequence.
`T[]`	`Container()` Gets the underlying container of the current instance.
`boolean`	`Contains(IPredicate<T> pred)` Determines whether an element is in the sequence.
`boolean`	`Contains(T item)` Determines whether an element is in the sequence.
`void`	`CopyTo(T[] array, int arrayIndex)` Copies the sequence to a compatible one-dimensional array, starting at the specified index of the target array.
`boolean`	`Empty()` Tests if the sequence is empty (the size of the sequence is zero).
`Vector.Iterator`	`End()` Returns a random-access iterator to the position that is one past the final element in the container.
`boolean`	`equals(java.lang.Object obj)` Tests whether this instance is equal to a specified object.
`boolean`	`equals(Vector<T> x)` Tests whether this instance is equal to a specified Vector object.
`int`	`Erase(int first, int last)` Removes a range of elements in a sequence from specified positions.
`Vector.Iterator`	`Erase(Vector.Iterator pos)` Removes an element in a sequence from a specified position.
`Vector.Iterator`	`Erase(Vector.Iterator first, Vector.Iterator last)` Removes a range of elements in a sequence from specified positions.
`Vector.UIterator`	`Erase(Vector.UIterator pos)` Removes an element in a sequence from a specified position.
`Vector.UIterator`	`Erase(Vector.UIterator first, Vector.UIterator last)` Removes a range of elements in a sequence from specified positions.
`void`	`EraseBegin(Vector.Iterator pos)` Removes the elements in a sequence from the beginning of the container to a specified position.
`void`	`EraseBegin(Vector.UIterator pos)` Removes the elements in a sequence from the beginning of the container to a specified position.
`void`	`EraseEnd(Vector.Iterator pos)` Removes the elements in a sequence from a specified position to the end of the container.
`void`	`EraseEnd(Vector.UIterator pos)` Removes the elements in a sequence from a specified position to the end of the container.
`int`	`First()` Gets the position of the first element in the sequence.
`T`	`Front()` Gets the first element of the sequence.
`int`	`hashCode()` Returns the hash code for this instance.
`int`	`IndexOf(IPredicate<T> pred)` Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
`int`	`IndexOf(T item)` Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
`void`	`Insert(int index, T item)` Inserts an element into the sequence before the element at a specified position.
`void`	`Insert(Vector.Iterator pos, int n, T item)` Inserts a number of elements into the sequence before the element at a specified position.
`Vector.Iterator`	`Insert(Vector.Iterator pos, T item)` Inserts an element into the sequence before the element at a specified position.
`<TInpIter extends IInpIter<T,TInpIter>> void`	`Insert(Vector.Iterator pos, TInpIter first, TInpIter last)` Inserts a range of elements into the sequence before the element at a specified position..
`void`	`Insert(Vector.UIterator pos, int n, T item)` Inserts a number of elements into the sequence before the element at a specified position.
`Vector.UIterator`	`Insert(Vector.UIterator pos, T item)` Inserts an element into the sequence before the element at a specified position.
`<TInpIter extends IInpIter<T,TInpIter>> void`	`Insert(Vector.UIterator pos, TInpIter first, TInpIter last)` Inserts a range of elements into the sequence before the element at a specified position..
`T`	`Item(int index)` Gets a sequence element at a specified position.
`int`	`Last()` Gets the position that is one past the final element in the sequence.
`void`	`Load(java.lang.String fileName)` Erases all the elements and replaces them with the elements stored in the specified file.
`int`	`MaxSize()` Returns the maximum possible length of the sequence.
`void`	`PAdd(int n, T item)` Parallel Add: Appends to the back of the sequence n copies of the specified value.
`<TInpIter extends IInpIter<T,TInpIter>> void`	`PAdd(TInpIter first, TInpIter last)` Parallel Add: Appends the specified elements to the back of the sequence.
`void`	`PAssign(int n, T item)` Parallel Assign: Erases all the elements and replaces them with n copies of item.
`void`	`PAssign(T item)` Parallel Assign: Erases all the elements and replaces them with the specified value.
`<TInpIter extends IInpIter<T,TInpIter>> void`	`PAssign(TInpIter first, TInpIter last)` Parallel Assign: Erases a sequence and copies the specified elements to the empty sequence.
`boolean`	`PContains(IPredicate<T> pred)` Parallel Contains: Determines whether an element is in the sequence.
`boolean`	`PContains(T item)` Parallel Contains: Determines whether an element is in the sequence.
`void`	`PCopyTo(T[] array, int arrayIndex)` Parallel CopyTo: Copies the sequence to a compatible one-dimensional array, starting at the specified index of the target array.
`boolean`	`PEquals(Vector<T> x)` Parallel Equals: Tests whether this instance is equal to a specified Vector object.
`Vector.Iterator`	`PErase(Vector.Iterator pos)` Parallel Erase: Removes an element in a sequence from a specified position.
`Vector.UIterator`	`PErase(Vector.UIterator pos)` Parallel Erase: Removes an element in a sequence from a specified position.
`int`	`PIndexOf(IPredicate<T> pred)` Parallel IndexOf: Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
`int`	`PIndexOf(T item)` Parallel IndexOf: Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
`void`	`PInsert(int index, T item)` Parallel Insert: Inserts an element into the sequence before the element at a specified position.
`Vector.Iterator`	`PInsert(Vector.Iterator pos, T item)` Parallel Insert: Inserts an element into the sequence before the element at a specified position.
`Vector.UIterator`	`PInsert(Vector.UIterator pos, T item)` Parallel Insert: Inserts an element into the sequence before the element at a specified position.
`void`	`PopBack()` Deletes the element at the end of the sequence.
`void`	`PopFront()` Deletes the element at the beginning of the sequence.
`boolean`	`PRemove(IPredicate<T> pred)` Parallel Remove: Removes the first occurrence of a specific object from the sequence.
`boolean`	`PRemove(T item)` Parallel Remove: Removes the first occurrence of a specific object from the sequence.
`void`	`PRemoveAt(int index)` Parallel RemoveAt: Removes the element at the specified index of the sequence.
`void`	`PushBack(T item)` Adds an element to the end of the sequence.
`void`	`PushFront(T item)` Adds an element to the beginning of the sequence.
`void`	`Read(java.io.DataInput reader)` Loads the entire container from the specified reader.
`boolean`	`Remove(IPredicate<T> pred)` Removes the first occurrence of a specific object from the sequence.
`boolean`	`Remove(T item)` Removes the first occurrence of a specific object from the sequence.
`void`	`RemoveAt(int index)` Removes the element at the specified index of the sequence.
`void`	`Resize(int newSize)` Specifies a new size for a sequence.
`void`	`Resize(int newSize, T item)` Specifies a new size for a sequence.
`Vector.ReverseIterator`	`ReverseBegin()` Returns a random-access reverse iterator to the first element in the reversed container.
`Vector.ReverseIterator`	`ReverseEnd()` Returns a random-access reverse iterator to the position that is one past the final element in the reversed container.
`void`	`Save(java.lang.String fileName)` Saves the container elements to the specified file.
`void`	`SetBack(T value)` Sets the last element of the sequence.
`void`	`SetFront(T value)` Sets the first element of the sequence.
`void`	`SetItem(int index, T value)` Sets a sequence element at a specified position.
`int`	`Size()` Returns the number of elements in the sequence.
`void`	`Swap(Vector<T> x)` Exchanges the elements of two vectors.
`void`	`SwapRef(Vector<T> x)` Swaps the member references of two sequences.
`void`	`ToStream(java.io.PrintStream sw)` Writes the elements of the current container to the specified stream.
`void`	`ToStream(Vector.Iterator first, Vector.Iterator last, java.io.PrintStream sw)` Writes the elements of the current container from the specified range to the specified stream.
`java.lang.String`	`toString()` Returns a string that represents the content of the current container.
`java.lang.String`	`ToString(Vector.Iterator first, Vector.Iterator last)` Returns a string that represents the elements of the current container from the specified range.
`java.lang.Class<T>`	`Type()` Returns the type of the elements in the container.
`Vector.UIterator`	`UBegin()` Returns a random-access unchecked iterator to the first element in the container.
`Vector.UIterator`	`UEnd()` Returns a random-access unchecked iterator to the position that is one past the final element in the container.
`Vector.UReverseIterator`	`UReverseBegin()` Returns a random-access unchecked reverse iterator to the first element in the reversed container.
`Vector.UReverseIterator`	`UReverseEnd()` Returns a random-access unchecked reverse iterator to the position that is one past the final element in the reversed container.
`void`	`Write(java.io.DataOutput writer)` Stores the entire container to the specified writer.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Vector
```
public Vector(java.lang.Class<T> type,
      int maxSize)
```
    Creates an empty sequence of the specified type.
    
    Parameters:
    type - The specified data type.
    maxSize - The maximum size of the sequence.
  - Vector
```
public Vector(int n,
      T item,
      int maxSize)
```
    Creates a sequence of the specified type and initializes it with the specified element.
    
    Parameters:
    n - The number of copies of an element being inserted into the sequence.
    item - The value of the sequence's elements.
    maxSize - The maximum size of the sequence.
  - Vector
```
public Vector(Vector<T> x)
```
    Constructs a new instance of the Vector from another sequence.
    
    Parameters:
    x - The sequence to copy.
- Method Detail
  - Type
```
public java.lang.Class<T> Type()
```
    Returns the type of the elements in the container.
    
    Specified by:
    
    Type in interface IContainer32<T>
    
    Returns:
    The type of the elements in the container.
  - Load
```
public void Load(java.lang.String fileName)
```
    Erases all the elements and replaces them with the elements stored in the specified file.
    
    Parameters:
    fileName - The specified file.
    
    Throws:
    
    java.lang.RuntimeException - If an I/O error occurs.
  - Save
```
public void Save(java.lang.String fileName)
```
    Saves the container elements to the specified file.
    
    Parameters:
    fileName - The specified file.
    
    Throws:
    
    java.lang.RuntimeException - If an I/O error occurs.
  - Read
```
public void Read(java.io.DataInput reader)
```
    Loads the entire container from the specified reader.
    
    Parameters:
    reader - The specified reader.
    
    Throws:
    
    java.lang.RuntimeException - If an I/O error occurs.
    Remarks: The container must be stored previously to the specified stream using the Write method.
  - Write
```
public void Write(java.io.DataOutput writer)
```
    Stores the entire container to the specified writer.
    
    Parameters:
    writer - The specified writer.
    
    Throws:
    
    java.lang.RuntimeException - If an I/O error occurs.
    Remarks: The container must be read from the specified stream using the Read method.
  - Assign
```
public void Assign(T item)
```
    Erases all the elements and replaces them with the specified value.
    
    Parameters:
    item - The value of the element being inserted into the sequence.
  - PAssign
```
public void PAssign(T item)
```
    Parallel Assign: Erases all the elements and replaces them with the specified value.
    
    Parameters:
    item - The value of the element being inserted into the sequence.
  - Assign
```
public void Assign(int n,
          T item)
```
    Erases all the elements and replaces them with n copies of item.
    
    Parameters:
    n - The number of copies of an element being inserted into the sequence.
    item - The value of the element being inserted into the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the number of copies of an element being inserted into the sequence is greater than the maximum size of the sequence.
  - PAssign
```
public void PAssign(int n,
           T item)
```
    Parallel Assign: Erases all the elements and replaces them with n copies of item.
    
    Parameters:
    n - The number of copies of an element being inserted into the sequence.
    item - The value of the element being inserted into the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the number of copies of an element being inserted into the sequence is greater than the maximum size of the sequence.
  - Assign
```
public <TInpIter extends IInpIter<T,TInpIter>> void Assign(TInpIter first,
                                                  TInpIter last)
```
    Erases a sequence and copies the specified elements to the empty sequence.
    
    Type Parameters:
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - Position of the first element in the range of elements to be copied.
    last - Position that is one past the final element in the range of elements to be copied.
    
    Throws:
    
    java.lang.RuntimeException - When the iterator range is invalid and the number of elements being inserted into the sequence exceeds the maximum size of the sequence.
  - PAssign
```
public <TInpIter extends IInpIter<T,TInpIter>> void PAssign(TInpIter first,
                                                   TInpIter last)
```
    Parallel Assign: Erases a sequence and copies the specified elements to the empty sequence.
    
    Type Parameters:
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - Position of the first element in the range of elements to be copied.
    last - Position that is one past the final element in the range of elements to be copied.
    
    Throws:
    
    java.lang.RuntimeException - When the iterator range is invalid and the number of elements being inserted into the sequence exceeds the maximum size of the sequence.
  - Add
```
public void Add(int n,
       T item)
```
    Appends to the back of the sequence n copies of the specified value.
    
    Parameters:
    n - The number of copies of an element being appended to the sequence.
    item - The value of the element being appended to the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the number of copies of an element being appended to the sequence exceeds the maximum size of the sequence.
  - PAdd
```
public void PAdd(int n,
        T item)
```
    Parallel Add: Appends to the back of the sequence n copies of the specified value.
    
    Parameters:
    n - The number of copies of an element being appended to the sequence.
    item - The value of the element being appended to the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the number of copies of an element being appended to the sequence exceeds the maximum size of the sequence.
  - Add
```
public <TInpIter extends IInpIter<T,TInpIter>> void Add(TInpIter first,
                                               TInpIter last)
```
    Appends the specified elements to the back of the sequence.
    
    Type Parameters:
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - Position of the first element in the range of elements to be copied.
    last - Position that is one past the final element in the range of elements to be copied.
    
    Throws:
    
    java.lang.RuntimeException - When the iterator range is invalid and the number of elements being appended to the sequence exceeds the maximum size of the sequence.
  - PAdd
```
public <TInpIter extends IInpIter<T,TInpIter>> void PAdd(TInpIter first,
                                                TInpIter last)
```
    Parallel Add: Appends the specified elements to the back of the sequence.
    
    Type Parameters:
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - Position of the first element in the range of elements to be copied.
    last - Position that is one past the final element in the range of elements to be copied.
    
    Throws:
    
    java.lang.RuntimeException - When the iterator range is invalid and the number of elements being appended to the sequence exceeds the maximum size of the sequence.
  - Size
```
public int Size()
```
    Returns the number of elements in the sequence.
    
    Specified by:
    
    Size in interface IContainer32<T>
    
    Returns:
    The number of elements in the sequence.
  - MaxSize
```
public int MaxSize()
```
    Returns the maximum possible length of the sequence.
    
    Specified by:
    
    MaxSize in interface IContainer32<T>
    
    Returns:
    The maximum possible length of the sequence.
  - Empty
```
public boolean Empty()
```
    Tests if the sequence is empty (the size of the sequence is zero).
    
    Returns:
    True if the queue contains no elements; otherwise, false.
  - Item
```
public T Item(int index)
```
    Gets a sequence element at a specified position.
    
    Specified by:
    
    Item in interface IRanSequence32<T,Vector.Iterator>
    
    Parameters:
    index - The zero-based index of the element to get or set.
    
    Returns:
    The element at the specified index.
    
    Throws:
    
    java.lang.RuntimeException - When the specified index is out of [0, Size - 1] range.
  - SetItem
```
public void SetItem(int index,
           T value)
```
    Sets a sequence element at a specified position.
    
    Specified by:
    
    SetItem in interface IRanSequence32<T,Vector.Iterator>
    
    Parameters:
    index - The zero-based index of the element to get or set.
    value - The specified value to be set.
    
    Throws:
    
    java.lang.RuntimeException - When the specified index is out of [0, Size - 1] range.
  - Contains
```
public boolean Contains(T item)
```
    Determines whether an element is in the sequence.
    
    Parameters:
    item - The object to locate in the sequence.
    
    Returns:
    True if item is found in the sequence; otherwise, false.
  - PContains
```
public boolean PContains(T item)
```
    Parallel Contains: Determines whether an element is in the sequence.
    
    Parameters:
    item - The object to locate in the sequence.
    
    Returns:
    True if item is found in the sequence; otherwise, false.
  - Contains
```
public boolean Contains(IPredicate<T> pred)
```
    Determines whether an element is in the sequence.
    
    Parameters:
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    True if item is found in the sequence; otherwise, false.
  - PContains
```
public boolean PContains(IPredicate<T> pred)
```
    Parallel Contains: Determines whether an element is in the sequence.
    
    Parameters:
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    True if item is found in the sequence; otherwise, false.
  - IndexOf
```
public int IndexOf(T item)
```
    Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
    
    Parameters:
    item - The object to locate in the sequence.
    
    Returns:
    The zero-based index of the first occurrence of item within the entire sequence, if found; otherwise, false.
  - PIndexOf
```
public int PIndexOf(T item)
```
    Parallel IndexOf: Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
    
    Parameters:
    item - The object to locate in the sequence.
    
    Returns:
    The zero-based index of the first occurrence of item within the entire sequence, if found; otherwise, false.
  - IndexOf
```
public int IndexOf(IPredicate<T> pred)
```
    Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
    
    Parameters:
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    The zero-based index of the first occurrence of item within the entire sequence, if found; otherwise, false.
  - PIndexOf
```
public int PIndexOf(IPredicate<T> pred)
```
    Parallel IndexOf: Searches for the specified object and returns the zero-based index of the first occurrence within the entire sequence.
    
    Parameters:
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    The zero-based index of the first occurrence of item within the entire sequence, if found; otherwise, false.
  - Add
```
public void Add(T item)
```
    Adds an element to the end of the sequence.
    
    Parameters:
    item - The item to be added to the end of the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the container's size is equal to the maximum size.
  - Insert
```
public void Insert(int index,
          T item)
```
    Inserts an element into the sequence before the element at a specified position.
    
    Parameters:
    index - The position in the sequence where the element is inserted that must be inside of the [0, Size) range.
    item - The value of the element being inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the the index is outside of the [0, Size) range or the container's size is equal to the maximum size of the storage.
  - PInsert
```
public void PInsert(int index,
           T item)
```
    Parallel Insert: Inserts an element into the sequence before the element at a specified position.
    
    Parameters:
    index - The position in the sequence where the element is inserted that must be inside of the [0, Size) range.
    item - The value of the element being inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the the index is outside of the [0, Size) range or the container's size is equal to the maximum size of the storage.
  - Remove
```
public boolean Remove(T item)
```
    Removes the first occurrence of a specific object from the sequence.
    
    Parameters:
    item - The object to remove from the sequence.
    
    Returns:
    True if item is successfully removed; otherwise, false. This method also returns false if item was not found in the sequence.
  - PRemove
```
public boolean PRemove(T item)
```
    Parallel Remove: Removes the first occurrence of a specific object from the sequence.
    
    Parameters:
    item - The object to remove from the sequence.
    
    Returns:
    True if item is successfully removed; otherwise, false. This method also returns false if item was not found in the sequence.
  - Remove
```
public boolean Remove(IPredicate<T> pred)
```
    Removes the first occurrence of a specific object from the sequence.
    
    Parameters:
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being removed.
    
    Returns:
    True if item is successfully removed; otherwise, false. This method also returns false if item was not found in the sequence.
  - PRemove
```
public boolean PRemove(IPredicate<T> pred)
```
    Parallel Remove: Removes the first occurrence of a specific object from the sequence.
    
    Parameters:
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being removed.
    
    Returns:
    True if item is successfully removed; otherwise, false. This method also returns false if item was not found in the sequence.
  - RemoveAt
```
public void RemoveAt(int index)
```
    Removes the element at the specified index of the sequence.
    
    Parameters:
    index - The zero-based index of the element to remove.
    
    Throws:
    
    java.lang.RuntimeException - When the index is outside of the [0, Size - 1] range.
    Remarks: This method is an O(n) operation, where n is Min(index, Count - index).
  - PRemoveAt
```
public void PRemoveAt(int index)
```
    Parallel RemoveAt: Removes the element at the specified index of the sequence.
    
    Parameters:
    index - The zero-based index of the element to remove.
    
    Throws:
    
    java.lang.RuntimeException - When the index is outside of the [0, Size - 1] range.
    Remarks: This method is an O(n) operation, where n is Min(index, Count - index).
  - Clear
```
public void Clear()
```
    Erases all the elements of the sequence.
    
    Specified by:
    
    Clear in interface IContainer32<T>
  - CopyTo
```
public void CopyTo(T[] array,
          int arrayIndex)
```
    Copies the sequence to a compatible one-dimensional array, starting at the specified index of the target array.
    
    Parameters:
    array - The one-dimensional array that is the destination of the elements copied from sequence. The array must have zero-based indexing.
    arrayIndex - The zero-based index in array at which copying begins.
  - PCopyTo
```
public void PCopyTo(T[] array,
           int arrayIndex)
```
    Parallel CopyTo: Copies the sequence to a compatible one-dimensional array, starting at the specified index of the target array.
    
    Parameters:
    array - The one-dimensional array that is the destination of the elements copied from sequence. The array must have zero-based indexing.
    arrayIndex - The zero-based index in array at which copying begins.
  - Begin
```
public Vector.Iterator Begin()
```
    Returns a random-access iterator to the first element in the container.
    
    Specified by:
    
    Begin in interface IFwdContainer32<T,Vector.Iterator>
    
    Returns:
    An iterator to the beginning of the sequence object.
  - End
```
public Vector.Iterator End()
```
    Returns a random-access iterator to the position that is one past the final element in the container.
    
    Specified by:
    
    End in interface IFwdContainer32<T,Vector.Iterator>
    
    Returns:
    An iterator to the end of the sequence object.
  - UBegin
```
public Vector.UIterator UBegin()
```
    Returns a random-access unchecked iterator to the first element in the container.
    
    Returns:
    An unchecked iterator to the beginning of the sequence object.
  - UEnd
```
public Vector.UIterator UEnd()
```
    Returns a random-access unchecked iterator to the position that is one past the final element in the container.
    
    Returns:
    An unchecked iterator to the end of the sequence object.
  - ReverseBegin
```
public Vector.ReverseIterator ReverseBegin()
```
    Returns a random-access reverse iterator to the first element in the reversed container.
    
    Returns:
    An iterator at the beginning of the reversed sequence object.
  - ReverseEnd
```
public Vector.ReverseIterator ReverseEnd()
```
    Returns a random-access reverse iterator to the position that is one past the final element in the reversed container.
    
    Returns:
    An iterator at the end of the reversed sequence object.
  - UReverseBegin
```
public Vector.UReverseIterator UReverseBegin()
```
    Returns a random-access unchecked reverse iterator to the first element in the reversed container.
    
    Returns:
    An iterator at the beginning of the reversed sequence object.
  - UReverseEnd
```
public Vector.UReverseIterator UReverseEnd()
```
    Returns a random-access unchecked reverse iterator to the position that is one past the final element in the reversed container.
    
    Returns:
    An iterator at the end of the reversed sequence object.
  - Container
```
public T[] Container()
```
    Gets the underlying container of the current instance.
    
    Returns:
    The underlying container of the current instance.
  - First
```
public int First()
```
    Gets the position of the first element in the sequence.
    
    Returns:
    The position of the first element in the sequence.
  - Last
```
public int Last()
```
    Gets the position that is one past the final element in the sequence.
    
    Returns:
    The position that is one past the final element in the sequence.
  - Front
```
public T Front()
```
    Gets the first element of the sequence.
    Remarks: The container must contain at least one element.
    
    Specified by:
    
    Front in interface IFrontSequence<T>
    
    Returns:
    The first element of the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the container is empty.
  - SetFront
```
public void SetFront(T value)
```
    Sets the first element of the sequence.
    
    Specified by:
    
    SetFront in interface IFrontSequence<T>
    
    Parameters:
    value - The value to be set at the front of the sequence.
    Remarks: The container must contain at least one element.
    
    Throws:
    
    java.lang.RuntimeException - When the container is empty.
  - Back
```
public T Back()
```
    Gets the last element of the sequence.
    
    Specified by:
    
    Back in interface IBackSequence<T>
    
    Returns:
    The last element of the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the container is empty.
  - SetBack
```
public void SetBack(T value)
```
    Sets the last element of the sequence.
    
    Specified by:
    
    SetBack in interface IBackSequence<T>
    
    Parameters:
    value - The value to be set at the back of the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the container is empty.
  - PushBack
```
public void PushBack(T item)
```
    Adds an element to the end of the sequence.
    
    Specified by:
    
    PushBack in interface IBackSequence<T>
    
    Parameters:
    item - The element added to the end of the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the container's size is equal to the maximum size.
  - PopBack
```
public void PopBack()
```
    Deletes the element at the end of the sequence.
    
    Specified by:
    
    PopBack in interface IBackSequence<T>
    
    Throws:
    
    java.lang.RuntimeException - When the container is empty.
  - PushFront
```
public void PushFront(T item)
```
    Adds an element to the beginning of the sequence.
    
    Specified by:
    
    PushFront in interface IFrontSequence<T>
    
    Parameters:
    item - The element added to the beginning of the sequence.
    
    Throws:
    
    java.lang.RuntimeException - When the container starts at the position zero in the sequence.
  - PopFront
```
public void PopFront()
```
    Deletes the element at the beginning of the sequence.
    
    Specified by:
    
    PopFront in interface IFrontSequence<T>
    
    Throws:
    
    java.lang.RuntimeException - When the container is empty.
  - Insert
```
public Vector.UIterator Insert(Vector.UIterator pos,
                      T item)
```
    Inserts an element into the sequence before the element at a specified position.
    
    Parameters:
    pos - The position in the sequence where the element is inserted.
    item - The value of the element being inserted into the sequence.
    
    Returns:
    An iterator that points to the position where the new element was inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size is equal to the maximum size of the storage.
  - PInsert
```
public Vector.UIterator PInsert(Vector.UIterator pos,
                       T item)
```
    Parallel Insert: Inserts an element into the sequence before the element at a specified position.
    
    Parameters:
    pos - The position in the sequence where the element is inserted.
    item - The value of the element being inserted into the sequence.
    
    Returns:
    An iterator that points to the position where the new element was inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size is equal to the maximum size of the storage.
  - Insert
```
public Vector.Iterator Insert(Vector.Iterator pos,
                     T item)
```
    Inserts an element into the sequence before the element at a specified position.
    
    Specified by:
    
    Insert in interface IInsertSequence<T,Vector.Iterator>
    
    Parameters:
    pos - The position in the sequence where the element is inserted.
    item - The value of the element being inserted into the sequence.
    
    Returns:
    An iterator that points to the position where the new element was inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size is equal to the maximum size of the storage.
  - PInsert
```
public Vector.Iterator PInsert(Vector.Iterator pos,
                      T item)
```
    Parallel Insert: Inserts an element into the sequence before the element at a specified position.
    
    Parameters:
    pos - The position in the sequence where the element is inserted.
    item - The value of the element being inserted into the sequence.
    
    Returns:
    An iterator that points to the position where the new element was inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size is equal to the maximum size of the storage.
  - Insert
```
public void Insert(Vector.UIterator pos,
          int n,
          T item)
```
    Inserts a number of elements into the sequence before the element at a specified position.
    
    Parameters:
    pos - The position in the sequence where the elements are inserted.
    n - The number of elements being inserted into the sequence.
    item - The value of the elements being inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size plus number of elements to be inserted is equal to the maximum size of the storage.
  - Insert
```
public void Insert(Vector.Iterator pos,
          int n,
          T item)
```
    Inserts a number of elements into the sequence before the element at a specified position.
    
    Parameters:
    pos - The position in the sequence where the elements are inserted.
    n - The number of elements being inserted into the sequence.
    item - The value of the elements being inserted into the sequence.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size plus number of elements to be inserted is equal to the maximum size of the storage.
  - Insert
```
public <TInpIter extends IInpIter<T,TInpIter>> void Insert(Vector.UIterator pos,
                                                  TInpIter first,
                                                  TInpIter last)
```
    Inserts a range of elements into the sequence before the element at a specified position..
    
    Type Parameters:
    TInpIter - The type of iterators in the specified range.
    Parameters:
    pos - The position in the sequence where the elements are inserted.
    first - An input iterator addressing the position of the first element in the range to be inserted.
    last - An input iterator addressing the position that is one past the final element in the range to be inserted.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size plus number of elements to be inserted is equal to the maximum size of the storage.
  - Insert
```
public <TInpIter extends IInpIter<T,TInpIter>> void Insert(Vector.Iterator pos,
                                                  TInpIter first,
                                                  TInpIter last)
```
    Inserts a range of elements into the sequence before the element at a specified position..
    
    Type Parameters:
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    pos - The position in the sequence where the elements are inserted.
    first - An input iterator addressing the position of the first element in the range to be inserted.
    last - An input iterator addressing the position that is one past the final element in the range to be inserted.
    Remarks: The insertion operation can be expensive.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid or the container's size plus number of elements to be inserted is equal to the maximum size of the storage.
  - Erase
```
public Vector.UIterator Erase(Vector.UIterator pos)
```
    Removes an element in a sequence from a specified position.
    
    Parameters:
    pos - Position of the element to be removed from the sequence.
    
    Returns:
    An iterator that designates the first element remaining beyond the element removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - PErase
```
public Vector.UIterator PErase(Vector.UIterator pos)
```
    Parallel Erase: Removes an element in a sequence from a specified position.
    
    Parameters:
    pos - Position of the element to be removed from the sequence.
    
    Returns:
    An iterator that designates the first element remaining beyond the element removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - Erase
```
public Vector.Iterator Erase(Vector.Iterator pos)
```
    Removes an element in a sequence from a specified position.
    
    Parameters:
    pos - Position of the element to be removed from the sequence.
    
    Returns:
    An iterator that designates the first element remaining beyond the element removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - PErase
```
public Vector.Iterator PErase(Vector.Iterator pos)
```
    Parallel Erase: Removes an element in a sequence from a specified position.
    
    Parameters:
    pos - Position of the element to be removed from the sequence.
    
    Returns:
    An iterator that designates the first element remaining beyond the element removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - Erase
```
public int Erase(int first,
        int last)
```
    Removes a range of elements in a sequence from specified positions.
    
    Parameters:
    first - Position of the first element removed from the sequence.
    last - Position just beyond the last element removed from the sequence.
    
    Returns:
    An integer that designates the first element remaining beyond the elements removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - Erase
```
public Vector.UIterator Erase(Vector.UIterator first,
                     Vector.UIterator last)
```
    Removes a range of elements in a sequence from specified positions.
    
    Parameters:
    first - Position of the first element removed from the sequence.
    last - Position just beyond the last element removed from the sequence.
    
    Returns:
    An iterator that designates the first element remaining beyond the elements removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - Erase
```
public Vector.Iterator Erase(Vector.Iterator first,
                    Vector.Iterator last)
```
    Removes a range of elements in a sequence from specified positions.
    
    Parameters:
    first - Position of the first element removed from the sequence.
    last - Position just beyond the last element removed from the sequence.
    
    Returns:
    An iterator that designates the first element remaining beyond the elements removed, or a pointer to the end of the sequence if no such element exists.
    Remarks: The erase operation can be expensive.
  - EraseBegin
```
public void EraseBegin(Vector.UIterator pos)
```
    Removes the elements in a sequence from the beginning of the container to a specified position.
    
    Parameters:
    pos - Position of the first element in the sequence after removing the specified elements.
    Remarks: The EraseBegin is a constant time operation.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid.
  - EraseBegin
```
public void EraseBegin(Vector.Iterator pos)
```
    Removes the elements in a sequence from the beginning of the container to a specified position.
    
    Parameters:
    pos - Position of the first element in the sequence after removing the specified elements.
    Remarks: The EraseBegin is a constant time operation.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid.
  - EraseEnd
```
public void EraseEnd(Vector.UIterator pos)
```
    Removes the elements in a sequence from a specified position to the end of the container.
    
    Parameters:
    pos - Position of the first element removed from the sequence.
    Remarks: The EraseEnd is a constant time operation.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid.
  - EraseEnd
```
public void EraseEnd(Vector.Iterator pos)
```
    Removes the elements in a sequence from a specified position to the end of the container.
    
    Parameters:
    pos - Position of the first element removed from the sequence.
    Remarks: The EraseEnd is a constant time operation.
    
    Throws:
    
    java.lang.RuntimeException - When the specified iterator is invalid.
  - Resize
```
public void Resize(int newSize)
```
    Specifies a new size for a sequence.
    
    Parameters:
    newSize - The new size of the sequence.
    Remarks: If the new size is larger than the original size, the new objects are assigned the default value.
    
    Throws:
    
    java.lang.RuntimeException - When the specified size is greater than maximum size of the storage.
  - Resize
```
public void Resize(int newSize,
          T item)
```
    Specifies a new size for a sequence.
    
    Parameters:
    newSize - The new size of the sequence.
    item - The value of new elements added to the sequence, if the new size is larger than the original size.
    
    Throws:
    
    java.lang.RuntimeException - When the specified size is greater than maximum size of the storage.
  - Swap
```
public void Swap(Vector<T> x)
```
    Exchanges the elements of two vectors.
    
    Parameters:
    x - A sequence whose elements are to be exchanged.
    Remarks: The complexity is linear with the size of the containers.
  - SwapRef
```
public void SwapRef(Vector<T> x)
```
    Swaps the member references of two sequences.
    
    Parameters:
    x - A sequence whose elements are to be exchanged.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Tests whether this instance is equal to a specified object.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - An object to compare with this instance.
    
    Returns:
    True if obj is an instance of Vector and equals the value of this instance; otherwise, false.
  - hashCode
```
public int hashCode()
```
    Returns the hash code for this instance.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    A 32-bit signed integer hash code.
  - equals
```
public boolean equals(Vector<T> x)
```
    Tests whether this instance is equal to a specified Vector object.
    
    Parameters:
    x - An object to compare with this instance.
    
    Returns:
    True if seq equals the value of this instance; otherwise, false.
  - PEquals
```
public boolean PEquals(Vector<T> x)
```
    Parallel Equals: Tests whether this instance is equal to a specified Vector object.
    
    Parameters:
    x - An object to compare with this instance.
    
    Returns:
    True if seq equals the value of this instance; otherwise, false.
  - toString
```
public java.lang.String toString()
```
    Returns a string that represents the content of the current container.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    A string that represents the content of the current container.
    Remarks: If the container has a great number of elements this function may throw an exception. It is recommended to use the overloaded function to limit the number of elements that are dumped to a string.
  - ToString
```
public java.lang.String ToString(Vector.Iterator first,
                        Vector.Iterator last)
```
    Returns a string that represents the elements of the current container from the specified range.
    
    Parameters:
    first - Position of the first element in the range of elements.
    last - Position that is one past the final element in the range of elements.
    Remarks: If the specified range has a great number of elements this function may throw an exception.
    
    Returns:
    a string that represents the elements of the current container from the specified range.
  - ToStream
```
public void ToStream(java.io.PrintStream sw)
```
    Writes the elements of the current container to the specified stream.
    
    Parameters:
    sw - A StreamWriter object to write to.
  - ToStream
```
public void ToStream(Vector.Iterator first,
            Vector.Iterator last,
            java.io.PrintStream sw)
```
    Writes the elements of the current container from the specified range to the specified stream.
    
    Parameters:
    first - Position of the first element in the range of elements.
    last - Position that is one past the final element in the range of elements.
    sw - A StreamWriter object to write to.

Class Vector<T>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Vector

Vector

Vector

Method Detail

Type

Load

Save

Read

Write

Assign

PAssign

Assign

PAssign

Assign

PAssign

Add

PAdd

Add

PAdd

Size

MaxSize

Empty

Item

SetItem

Contains

PContains

Contains

PContains

IndexOf

PIndexOf

IndexOf

PIndexOf

Add

Insert

PInsert

Remove

PRemove

Remove

PRemove

RemoveAt

PRemoveAt

Clear

CopyTo

PCopyTo

Begin

End

UBegin

UEnd

ReverseBegin

ReverseEnd

UReverseBegin

UReverseEnd

Container

First

Last

Front

SetFront

Back

SetBack

PushBack

PopBack

PushFront

PopFront

Insert

PInsert

Insert

PInsert

Insert

Insert

Insert

Insert

Erase

PErase

Erase