Constructor Detail

• Strided1DWritableBuffer

  public Strided1DWritableBuffer​(int flags,
                                 BufferProtocol obj,
                                 byte[] storage,
                                 int index0,
                                 int count,
                                 int stride)
                          throws java.lang.ArrayIndexOutOfBoundsException,
                                 java.lang.NullPointerException,
                                 PyException

  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. The result of byteAt(i) will be equal to storage[index0+stride*i] (whatever the sign of stride>0), valid for 0<=i<count.

  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, count and stride. The caller is responsible for checking these fall within the array, or the sub-range the caller is allowed to use.

  Parameters:

  flags - consumer requirements

  obj - exporting object (or null)

  storage - raw byte array containing exported data

  index0 - index into storage of item[0]

  count - number of items in the slice

  stride - byte-index distance from one element to the next in the new PyBuffer

  Throws:

  java.lang.NullPointerException - if storage is null

  java.lang.ArrayIndexOutOfBoundsException - if index0, count and stride are inconsistent with storage.length

  PyException - (BufferError) when expectations do not correspond with the type

Method Detail

• isReadonly

  public final boolean isReadonly()

  Determine whether the consumer is entitled to write to the exported storage.

  Declared final returning true in Strided1DWritableBuffer to make checks unnecessary.

  Specified by:

  isReadonly in interface PyBUF

  Overrides:

  isReadonly in class Strided1DBuffer

  Returns:

  true if writing is not allowed, false if it is.

• getBufferSlice

  public PyBuffer getBufferSlice​(int flags,
                                 int start,
                                 int count,
                                 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. 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.

  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 count 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.

  Specified by:

  getBufferSlice in interface PyBuffer

  Overrides:

  getBufferSlice in class Strided1DBuffer

  Parameters:

  flags - specifying features demanded and the navigational capabilities of the consumer

  start - index in the current buffer

  count - number of items in the required slice

  stride - index-distance in the current buffer between consecutive items in the slice

  Returns:

  a buffer representing the slice