SimpleVector

java.lang.Object
- gnu.lists.AbstractSequence<E>
- - gnu.lists.SimpleVector<E>

All Implemented Interfaces:

BoundedHashable, Array<E>, AVector<E>, Consumable, Sequence<E>, java.io.Externalizable, java.io.Serializable, java.lang.Iterable<E>, java.util.Collection<E>, java.util.List<E>, java.util.RandomAccess

Direct Known Subclasses:

AbstractCharVector, BitVector, F32Vector, F64Vector, FVector, Nodes.NodeVector, PrimIntegerVector
```
public abstract class SimpleVector<E>
extends AbstractSequence<E>
implements AVector<E>, java.io.Externalizable, java.util.RandomAccess
```
A generic simple vector. This is normally a wrapper around a plain Java array, the "data buffer", which is the value of codegetBuffer(). (FUTURE: could be a wrapper around a String?) The elements of the vector (viewed as a java.util.List) are stored in order, in the array, in one of these modes:
Very-simple mode: All of elements of the data buffer are used. Normally get(i) is the @code{i}'th element of the data buffer. An exception: For a CharSequence (FString), the value of get(i) is a Unicode code point, so it is found at offset computed by Character.offsetByCodePoints(i).
Sub-range mode: The elements of this vector are a contiguous sub-range of the data buffer, given by a start offset and a size. This is used for creating a read-only sub-list with sharing of the data buffer. The original is made copy-on-write.
Gap-buffer mode: The elements of this vector are in two contiguous sub-range of the data buffer, one at the very start of the buffer, and one at the very end, with an unused gap between them. (The gap and either sub-range may be empty.)

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected static long`	`COPY_ON_WRITE`
`protected static long`	`GAP_FLAG`
`protected long`	`info`
`static int`	`MAX_GAP_SIZE`
`protected static long`	`READ_ONLY_FLAG`
`protected static long`	`SHARED_FLAG`
`protected static long`	`SUBRANGE_FLAG`
`protected static long`	`VERY_SIMPLE_FLAG`

Fields inherited from class gnu.lists.AbstractSequence
noInts

Fields inherited from interface gnu.lists.Sequence
ATTRIBUTE_VALUE, BOOLEAN_VALUE, CDATA_VALUE, CHAR_VALUE, COMMENT_VALUE, DOCUMENT_VALUE, DOUBLE_VALUE, ELEMENT_VALUE, EOF_VALUE, eofValue, FLOAT_VALUE, INT_S16_VALUE, INT_S32_VALUE, INT_S64_VALUE, INT_S8_VALUE, INT_U16_VALUE, INT_U32_VALUE, INT_U64_VALUE, INT_U8_VALUE, OBJECT_VALUE, PRIM_VALUE, PROCESSING_INSTRUCTION_VALUE, TEXT_BYTE_VALUE

Constructor Summary

Constructors
Constructor and Description

SimpleVector()

Constructors
Constructor and Description
`SimpleVector()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(E o)` See java.util.Collection.
`void`	`add(int index, E o)` See java.util.List.
`protected int`	`addPos(int ipos, E value)` Add a value at a specified Pos.
`protected void`	`addSpace(int index, int count)` Insert count unspecified elements at index.
`SimpleVector<E>`	`asImmutable()`
`protected void`	`checkCanWrite()`
`protected abstract void`	`clearBuffer(int start, int count)`
`abstract void`	`copyBuffer(int length)`
`void`	`delete(int start, int end)`
`protected void`	`doCopyOnWrite(int sz)`
`int`	`effectiveIndex(int index)`
`void`	`fill(E value)`
`void`	`forEach(java.util.function.Consumer<? super E> action)`
`protected void`	`gapReserve(int where, int needed)`
`protected void`	`gapReserveGeneric(int where, int needed)`
`protected abstract java.lang.Object`	`getBuffer()`
`abstract int`	`getBufferLength()`
`protected int`	`getGapEnd()`
`protected int`	`getGapSize()`
`protected int`	`getGapStart()`
`protected int`	`getOffsetBits()`
`E`	`getRowMajor(int i)`
`long`	`getSegment(int index)` Get sub-range of this vector, starting at given index.
`int`	`getSegment(int index, int len)`
`int`	`getSegmentReadOnly(int start, int len)`
`protected int`	`getSizeBits()`
`java.lang.String`	`getTag()` This is convenience hack for printing "uniform vectors" (srfi 4).
`protected boolean`	`isAfterPos(int ipos)` Tests whether the position has the "isAfter" property.
`protected boolean`	`isGapBuffer()` The values are `buffer[0 <: size] ++ buffer[gapEnd <: ]`, where gapEnd = size + offset
`boolean`	`isReadOnly()`
`protected boolean`	`isSubRange()` The values are `buffer[offset <: offset+size]`.
`protected boolean`	`isVerySimple()` If isSimple(), the values are all the values of the buffer.
`protected int`	`length()`
`protected abstract SimpleVector`	`newInstance(int newSize)`
`void`	`readExternal(java.io.ObjectInput in)`
`protected abstract void`	`setBuffer(java.lang.Object obj)`
`protected void`	`setGapBounds(int gapStart, int gapEnd)`
`protected void`	`setGapBounds(int gapStart, int gapEnd, long flags)`
`protected void`	`setInfoField(int size, int offset, long flags)`
`void`	`setReadOnly()`
`void`	`shift(int srcStart, int dstStart, int count)`
`int`	`size()` See java.util.List.
`java.lang.Object`	`toDataArray()`
`void`	`writeExternal(java.io.ObjectOutput out)`

Methods inherited from class gnu.lists.AbstractSequence
addAll, addAll, badRank, boundedHash, checkRank, clear, compare, compare, compare, consume, consume, consumeNext, consumePosRange, contains, containsAll, copyPos, createPos, createRelativePos, effectiveIndex, effectiveIndex, effectiveIndex, effectiveIndex, elements, endPos, equals, equals, fill, fillPosRange, firstAttributePos, firstChildPos, firstChildPos, fromEndIndex, get, get, get, get, get, getAttribute, getAttributeLength, getBooleanRaw, getByteRaw, getCharRaw, getContainingSequenceSize, getDoubleRaw, getElementKind, getFloatRaw, getIndexDifference, getInt, getInt, getInt, getInt, getInt, getIntRaw, getIterator, getIterator, getIteratorAtPos, getLongRaw, getLowBound, getNextKind, getNextTypeName, getNextTypeObject, getPosNext, getPosPrevious, getRaw, getShortRaw, getSize, getSize, gotoAttributesStart, gotoChildrenStart, gotoParent, hashCode, hasNext, hasPrevious, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, nextIndex, nextIndex, nextMatching, nextPos, parentPos, previousPos, rank, releasePos, remove, remove, removeAll, removePos, removePosRange, retainAll, set, set, setAt, setPosNext, setPosPrevious, setRaw, stableCompare, startPos, subList, subSequence, subSequencePos, toArray, toArray, toString, toString, unsupported, unsupportedException

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

Methods inherited from interface gnu.lists.Array
effectiveIndex, effectiveIndex, effectiveIndex, effectiveIndex, get, get, get, get, get, getBooleanRaw, getByteRaw, getCharRaw, getDoubleRaw, getElementKind, getFloatRaw, getInt, getInt, getInt, getInt, getInt, getIntRaw, getLongRaw, getLowBound, getRaw, getShortRaw, getSize, getSize, isEmpty, rank, set, setRaw

Methods inherited from interface gnu.lists.Sequence
elements, get, getInt, isEmpty, set

Methods inherited from interface java.util.List
addAll, addAll, clear, contains, containsAll, equals, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, replaceAll, retainAll, sort, spliterator, subList, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface gnu.lists.Consumable
consume

Methods inherited from interface gnu.kawa.util.BoundedHashable
boundedHash

- Field Detail
  - info
```
protected long info
```
  - MAX_GAP_SIZE
```
public static final int MAX_GAP_SIZE
```
    See Also:
    
    Constant Field Values
  - READ_ONLY_FLAG
```
protected static final long READ_ONLY_FLAG
```
    See Also:
    
    Constant Field Values
  - SHARED_FLAG
```
protected static final long SHARED_FLAG
```
    See Also:
    
    Constant Field Values
  - COPY_ON_WRITE
```
protected static final long COPY_ON_WRITE
```
    See Also:
    
    Constant Field Values
  - SUBRANGE_FLAG
```
protected static final long SUBRANGE_FLAG
```
    See Also:
    
    Constant Field Values
  - GAP_FLAG
```
protected static final long GAP_FLAG
```
    See Also:
    
    Constant Field Values
  - VERY_SIMPLE_FLAG
```
protected static final long VERY_SIMPLE_FLAG
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - SimpleVector
```
public SimpleVector()
```
- Method Detail
  - isVerySimple
```
protected final boolean isVerySimple()
```
    If isSimple(), the values are all the values of the buffer. In this case getSize() == getBufferLength();
  - isSubRange
```
protected final boolean isSubRange()
```
    The values are buffer[offset <: offset+size].
  - isGapBuffer
```
protected final boolean isGapBuffer()
```
    The values are buffer[0 <: size] ++ buffer[gapEnd <: ], where gapEnd = size + offset
  - setInfoField
```
protected final void setInfoField(int size,
                                  int offset,
                                  long flags)
```
  - getGapStart
```
protected final int getGapStart()
```
  - getGapEnd
```
protected final int getGapEnd()
```
  - getGapSize
```
protected final int getGapSize()
```
  - setGapBounds
```
protected final void setGapBounds(int gapStart,
                                  int gapEnd,
                                  long flags)
```
  - setGapBounds
```
protected final void setGapBounds(int gapStart,
                                  int gapEnd)
```
  - getSizeBits
```
protected final int getSizeBits()
```
  - getOffsetBits
```
protected final int getOffsetBits()
```
  - isReadOnly
```
public boolean isReadOnly()
```
  - setReadOnly
```
public void setReadOnly()
```
  - size
```
public int size()
```
    Description copied from interface: Sequence
    
    See java.util.List.
    
    Specified by:
    
    size in interface Sequence<E>
    
    Specified by:
    
    size in interface java.util.Collection<E>
    
    Specified by:
    
    size in interface java.util.List<E>
    
    Overrides:
    
    size in class AbstractSequence<E>
  - length
```
protected int length()
```
  - effectiveIndex
```
public int effectiveIndex(int index)
```
    Specified by:
    
    effectiveIndex in interface Array<E>
    
    Overrides:
    
    effectiveIndex in class AbstractSequence<E>
  - gapReserve
```
protected void gapReserve(int where,
                          int needed)
```
  - gapReserveGeneric
```
protected final void gapReserveGeneric(int where,
                                       int needed)
```
  - setBuffer
```
protected abstract void setBuffer(java.lang.Object obj)
```
    Overrides:
    
    setBuffer in class AbstractSequence<E>
  - getBufferLength
```
public abstract int getBufferLength()
```
  - copyBuffer
```
public abstract void copyBuffer(int length)
```
  - newInstance
```
protected abstract SimpleVector newInstance(int newSize)
```
  - asImmutable
```
public SimpleVector<E> asImmutable()
```
    Specified by:
    
    asImmutable in interface Array<E>
    
    Overrides:
    
    asImmutable in class AbstractSequence<E>
  - checkCanWrite
```
protected void checkCanWrite()
```
    Overrides:
    
    checkCanWrite in class AbstractSequence<E>
  - doCopyOnWrite
```
protected void doCopyOnWrite(int sz)
```
  - getSegment
```
public long getSegment(int index)
```
    Get sub-range of this vector, starting at given index.
    
    Returns:
    
    (size<<32)|where such that get(i) is data[where]; get(i+1) is data[where+1]; until get(i+size-1). The size is at least 1 (unless index==size()), but we try to do better.
  - getSegment
```
public int getSegment(int index,
                      int len)
```
  - getSegmentReadOnly
```
public int getSegmentReadOnly(int start,
                              int len)
```
  - isAfterPos
```
protected boolean isAfterPos(int ipos)
```
    Description copied from class: AbstractSequence
    
    Tests whether the position has the "isAfter" property. I.e. if something is inserted at the position, will the iterator end up being after the new data?
    
    Overrides:
    
    isAfterPos in class AbstractSequence<E>
  - getBuffer
```
protected abstract java.lang.Object getBuffer()
```
  - getRowMajor
```
public E getRowMajor(int i)
```
    Specified by:
    
    getRowMajor in interface Array<E>
    
    Overrides:
    
    getRowMajor in class AbstractSequence<E>
  - forEach
```
public void forEach(java.util.function.Consumer<? super E> action)
```
    Specified by:
    
    forEach in interface java.lang.Iterable<E>
  - fill
```
public void fill(E value)
```
    Specified by:
    
    fill in interface Sequence<E>
    
    Overrides:
    
    fill in class AbstractSequence<E>
  - shift
```
public void shift(int srcStart,
                  int dstStart,
                  int count)
```
  - add
```
public boolean add(E o)
```
    Description copied from class: AbstractSequence
    
    See java.util.Collection.
    
    Specified by:
    
    add in interface java.util.Collection<E>
    
    Specified by:
    
    add in interface java.util.List<E>
    
    Overrides:
    
    add in class AbstractSequence<E>
  - add
```
public void add(int index,
                E o)
```
    Description copied from class: AbstractSequence
    
    See java.util.List.
    
    Specified by:
    
    add in interface java.util.List<E>
    
    Overrides:
    
    add in class AbstractSequence<E>
  - addPos
```
protected int addPos(int ipos,
                     E value)
```
    Description copied from class: AbstractSequence
    
    Add a value at a specified Pos.
    
    Overrides:
    
    addPos in class AbstractSequence<E>
    
    Returns:
    
    the updated Pos, which is after the inserted value..
  - addSpace
```
protected void addSpace(int index,
                        int count)
```
    Insert count unspecified elements at index.
  - delete
```
public void delete(int start,
                   int end)
```
  - clearBuffer
```
protected abstract void clearBuffer(int start,
                                    int count)
```
  - toDataArray
```
public java.lang.Object toDataArray()
```
  - getTag
```
public java.lang.String getTag()
```
    This is convenience hack for printing "uniform vectors" (srfi 4). It may go away without notice!
  - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
    Specified by:
    
    writeExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
  - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
    Specified by:
    
    readExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
    
    java.lang.ClassNotFoundException

Class SimpleVector<E>

Field Summary

Fields inherited from class gnu.lists.AbstractSequence

Fields inherited from interface gnu.lists.Sequence

Constructor Summary

Method Summary

Methods inherited from class gnu.lists.AbstractSequence

Methods inherited from class java.lang.Object

Methods inherited from interface gnu.lists.Array

Methods inherited from interface gnu.lists.Sequence

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface gnu.lists.Consumable

Methods inherited from interface gnu.kawa.util.BoundedHashable

Field Detail

info

MAX_GAP_SIZE

READ_ONLY_FLAG

SHARED_FLAG

COPY_ON_WRITE

SUBRANGE_FLAG

GAP_FLAG

VERY_SIMPLE_FLAG

Constructor Detail

SimpleVector

Method Detail

isVerySimple

isSubRange

isGapBuffer

setInfoField

getGapStart

getGapEnd

getGapSize

setGapBounds

setGapBounds

getSizeBits

getOffsetBits

isReadOnly

setReadOnly

size

length

effectiveIndex

gapReserve

gapReserveGeneric

setBuffer

getBufferLength

copyBuffer

newInstance

asImmutable

checkCanWrite

doCopyOnWrite

getSegment

getSegment

getSegmentReadOnly

isAfterPos

getBuffer

getRowMajor

forEach

fill

shift

add

add

addPos

addSpace

delete

clearBuffer

toDataArray

getTag

writeExternal

readExternal