public class SimpleNIOBuffer extends BaseNIOBuffer
java.nio.ByteBuffer of one-byte items.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 | 
|---|
| SimpleNIOBuffer(int flags,
               BufferProtocol obj,
               ByteBuffer storage)Provide an instance of  SimpleNIOBuffer, on the entirety of aByteBuffer,
 meeting the consumer's expectations as expressed in theflagsargument, which is
 checked against the capabilities of the buffer type. | 
| SimpleNIOBuffer(int flags,
               BufferProtocol obj,
               ByteBuffer storage,
               int index0,
               int size)Provide an instance of  SimpleNIOBuffer, on a slice of aByteBuffer,
 meeting the consumer's expectations as expressed in theflagsargument, which is
 checked against the capabilities of the buffer type. | 
| Modifier and Type | Method and Description | 
|---|---|
| int | byteIndex(int index)Convert an item index (for a one-dimensional buffer) to an absolute byte index in the storage
 shared by the exporter. | 
| PyBuffer | getBufferSlice(int flags,
              int start,
              int count)Equivalent to  PyBuffer.getBufferSlice(int, int, int, int)with stride 1. | 
| PyBuffer | getBufferSlice(int flags,
              int start,
              int count,
              int stride)Get a  PyBufferthat 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. | 
| int | getLen()The total number of bytes represented by the view, which will be the product of the elements of the
  shapearray, and the item size in bytes. | 
byteIndex, copyFrom, copyTo, copyTo, getBufisContiguousbyteAt, byteAt, close, copyFrom, copyTo, getBuffer, getBufferAgain, getFormat, getItemsize, getNdim, getNIOByteBuffer, getObj, getPointer, getPointer, getShape, getStrides, getSuboffsets, hasArray, intAt, intAt, isReadonly, isReleased, release, storeAt, storeAt, toStringpublic SimpleNIOBuffer(int flags,
                       BufferProtocol obj,
                       ByteBuffer storage,
                       int index0,
                       int size)
                throws PyException,
                       ArrayIndexOutOfBoundsException,
                       NullPointerException
SimpleNIOBuffer, on a slice of a ByteBuffer,
 meeting the consumer's expectations as expressed in the flags argument, which is
 checked against the capabilities of the buffer type. No reference will be kept to the
 ByteBuffer passed in. (It is duplicated.)flags - consumer requirementsobj - exporting object (or null)storage - the ByteBuffer wrapping the exported object stateindex0 - offset where the data starts in that buffer (item[0])size - the number of bytes occupiedNullPointerException - if storage is nullArrayIndexOutOfBoundsException - if index0 and size are
             inconsistent with storage.lengthPyException - (BufferError) when expectations do not correspond with the typepublic SimpleNIOBuffer(int flags,
                       BufferProtocol obj,
                       ByteBuffer storage)
                throws PyException,
                       NullPointerException
SimpleNIOBuffer, on the entirety of a ByteBuffer,
 meeting the consumer's expectations as expressed in the flags argument, which is
 checked against the capabilities of the buffer type. No reference will be kept to the
 ByteBuffer passed in. (It is duplicated.)flags - consumer requirementsobj - exporting object (or null)storage - the ByteBuffer wrapping the exported object stateNullPointerException - if storage is nullPyException - (BufferError) when expectations do not correspond with the typepublic int getLen()
shape array, and the item size in bytes.
 
 SimpleNIOBuffer provides an implementation optimised for contiguous bytes in
 one-dimension.
getLen in interface PyBUFgetLen in class Base1DBufferpublic final int byteIndex(int index)
                    throws IndexOutOfBoundsException
PyBufferPyBuffer is a linearly-indexed
 sequence of bytes, although it may not actually be a heap-allocated Java byte[]
 object. The purpose of this method is to allow the exporter to define the relationship
 between the item index (as used in PyBuffer.byteAt(int)) and the byte-index (as used with the
 ByteBuffer returned by PyBuffer.getNIOByteBuffer()). See
 PyBuffer.byteIndex(int[]) for discussion of the multi-dimensional case.byteIndex in interface PyBufferbyteIndex in class BaseBufferindex - item-index from consumerIndexOutOfBoundsExceptionpublic PyBuffer getBufferSlice(int flags, int start, int count)
PyBufferPyBuffer.getBufferSlice(int, int, int, int) with stride 1.getBufferSlice in interface PyBuffergetBufferSlice in class BaseBufferflags - specifying features demanded and the navigational capabilities of the consumerstart - index in the current buffercount - number of items in the required slicepublic PyBuffer getBufferSlice(int flags, int start, int count, 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,
 count = 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, count 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.
 
 SimpleNIOBuffer provides an implementation for slicing contiguous bytes in one
 dimension. In that case, x(i) = u(r+i) for i = 0..L-1 where u is the underlying
 buffer, and r and L are the start and count with which x was created
 from u. Thus y(k) = u(r+s+km), that is, the composite offset is r+s and
 the stride is m.
flags - specifying features demanded and the navigational capabilities of the consumerstart - index in the current buffercount - number of items in the required slicestride - index-distance in the current buffer between consecutive items in the slice