public class Strided1DWritableBuffer extends Strided1DBuffer
Strided1DBuffer of which this is
an extension providing write operations and a writable slice.PyBuffer.PointerANY_CONTIGUOUS, AS_ARRAY, C_CONTIGUOUS, CONTIG, CONTIG_RO, CONTIGUITY, F_CONTIGUOUS, FORMAT, FULL, FULL_RO, INDIRECT, IS_C_CONTIGUOUS, IS_F_CONTIGUOUS, MAX_NDIM, NAVIGATION, ND, RECORDS, RECORDS_RO, SIMPLE, STRIDED, STRIDED_RO, STRIDES, WRITABLE| Constructor and Description |
|---|
Strided1DWritableBuffer(int flags,
byte[] storage,
int index0,
int length,
int stride)
Provide an instance of
Strided1DWritableBuffer on a particular array of bytes
specifying a starting index, the number of items in the result, and a byte-indexing stride. |
| Modifier and Type | Method and Description |
|---|---|
void |
copyFrom(byte[] src,
int srcPos,
int destIndex,
int length)
Copy bytes from a slice of a (Java) byte array into the buffer.
|
PyBuffer |
getBufferSlice(int flags,
int start,
int length,
int stride)
Get a
PyBuffer that represents a slice of the current one described in terms of
a start index, number of items to include in the slice, and the stride in the current buffer. |
boolean |
isReadonly()
Determine whether the consumer is entitled to write to the exported storage.
|
void |
storeAt(byte value,
int index)
Store the given byte at the indexed location in of a one-dimensional buffer with item size
one.
|
byteAt, copyTo, getPointer, getPointer, getStridesbyteAt, close, copyFrom, copyTo, getBuf, getBuffer, getBufferAgain, getBufferSlice, getFormat, getItemsize, getLen, getNdim, getNIOByteBuffer, getShape, getSuboffsets, hasArray, intAt, intAt, isContiguous, isReleased, release, storeAt, toStringpublic Strided1DWritableBuffer(int flags,
byte[] storage,
int index0,
int length,
int stride)
throws ArrayIndexOutOfBoundsException,
NullPointerException,
PyException
Strided1DWritableBuffer on a particular array of bytes
specifying a starting index, the number of items in the result, and a byte-indexing stride.
The result of byteAt(i) will be equal to storage[index0+stride*i]
(whatever the sign of stride>0), valid for 0<=i<length.
The constructed PyBuffer meets the consumer's expectations as expressed in the
flags argument, or an exception will be thrown if these are incompatible with
the type (e.g. the consumer does not specify that it understands the strides array). Note
that the actual range in the storage array, the lowest and highest index, is not
explicitly passed, but is implicit in index0, length and
stride. The caller is responsible for checking these fall within the array, or
the sub-range the caller is allowed to use.
flags - consumer requirementsstorage - raw byte array containing exported dataindex0 - index into storage of item[0]length - number of items in the slicestride - in between successive elements of the new PyBufferNullPointerException - if storage is nullArrayIndexOutOfBoundsException - if index0, length and
stride are inconsistent with storage.lengthPyException - (BufferError) when expectations do not correspond with the typepublic boolean isReadonly()
PyBUFisReadonly in interface PyBUFisReadonly in class Strided1DBufferpublic void storeAt(byte value,
int index)
throws IndexOutOfBoundsException,
PyException
PyBufferitemsize>1.storeAt in interface PyBufferstoreAt in class BaseBuffervalue - to storeindex - to locationIndexOutOfBoundsExceptionPyExceptionpublic void copyFrom(byte[] src,
int srcPos,
int destIndex,
int length)
throws IndexOutOfBoundsException,
PyException
length*itemsize bytes will be read from the source.
The default implementation in BaseBuffer deals with the general one-dimensional
case of arbitrary item size and stride. Strided1DWritableBuffer provides a version optimised for strided
bytes in one dimension.
copyFrom in interface PyBuffercopyFrom in class BaseBuffersrc - source byte arraysrcPos - location in source of first byte to copydestIndex - starting index in the destination (i.e. this)length - number of bytes to copy inIndexOutOfBoundsException - if access out of bounds in source or destinationPyException - (TypeError) if read-only bufferpublic PyBuffer getBufferSlice(int flags, int start, int length, int stride)
PyBuffer that represents a slice of the current one described in terms of
a start index, number of items to include in the slice, and the stride in the current buffer.
A consumer that obtains a PyBuffer with getBufferSlice must release
it with PyBuffer.release() just as if it had been obtained with
PyBuffer.getBuffer(int)
Suppose that x(i) denotes the ith element of the current buffer, that is, the
byte retrieved by this.byteAt(i) or the unit indicated by
this.getPointer(i). A request for a slice where start = s,
length = N and stride = m, results in a buffer
y such that y(k) = x(s+km) where k=0..(N-1). In Python terms, this is
the slice x[s : s+(N-1)m+1 : m] (if m>0) or the slice x[s : s+(N-1)m-1 :
m] (if m<0). Implementations should check that this range is entirely within
the current buffer.
In a simple buffer backed by a contiguous byte array, the result is a strided PyBuffer on the
same storage but where the offset is adjusted by s and the stride is as supplied. If
the current buffer is already strided and/or has an item size larger than single bytes, the
new start index, length and stride will be translated
from the arguments given, through this buffer's stride and item size. The caller always
expresses start and strides in terms of the abstract view of this
buffer.
Strided1DBuffer provides an implementation for slicing already-strided bytes in
one dimension. In that case, x(i) = u(r+ip) for i = 0..L-1 where u is the
underlying buffer, and r, p and L are the start, stride and length with
which x was created from u. Thus y(k) = u(r+sp+kmp), that is, the
composite index0 is r+sp and the composite stride is
mp.
Strided1DWritableBuffer provides an implementation that returns a writable
slice.
getBufferSlice in interface PyBuffergetBufferSlice in class Strided1DBufferflags - specifying features demanded and the navigational capabilities of the consumerstart - index in the current bufferlength - number of items in the required slicestride - index-distance in the current buffer between consecutive items in the slice