org.python.core.buffer

## Class SimpleWritableBuffer

- java.lang.Object
- - org.python.core.buffer.BaseBuffer
  - - org.python.core.buffer.Base1DBuffer
    - - org.python.core.buffer.BaseArrayBuffer
      - - org.python.core.buffer.SimpleBuffer
        - - org.python.core.buffer.SimpleWritableBuffer

All Implemented Interfaces:
  java.lang.AutoCloseable, BufferProtocol, PyBUF, PyBuffer

    public class SimpleWritableBuffer
    extends SimpleBuffer

Buffer API over a writable one-dimensional array of one-byte items.

### Nested Class Summary

### Nested classes/interfaces inherited from interface org.python.core.PyBuffer

`PyBuffer.Pointer`

### Field Summary

### Fields inherited from interface org.python.core.PyBUF

`ANY_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 Summary

Constructors
Constructor and Description
`SimpleWritableBuffer(int flags, BufferProtocol obj, byte[] storage)` Provide an instance of `SimpleWritableBuffer`, on the entirety of a byte array, meeting the consumer's expectations as expressed in the `flags` argument, which is checked against the capabilities of the buffer type.
`SimpleWritableBuffer(int flags, BufferProtocol obj, byte[] storage, int index0, int size)` Provide an instance of `SimpleWritableBuffer`, on a slice of a byte array, meeting the consumer's expectations as expressed in the `flags` argument, which is checked against the capabilities of the buffer type.

### Method Summary

All Methods Instance Methods Concrete Methods
`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 `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.

### Methods inherited from class org.python.core.buffer.SimpleBuffer

`byteIndex, getLen, getPointer, getPointer, toString`

### Methods inherited from class org.python.core.buffer.BaseArrayBuffer

`byteIndex, copyFrom, copyFrom, copyTo, getBuf`

### Methods inherited from class org.python.core.buffer.Base1DBuffer

`isContiguous`

### Methods inherited from class org.python.core.buffer.BaseBuffer

`byteAt, byteAt, close, copyTo, getBuffer, getBufferAgain, getFormat, getItemsize, getNdim, getNIOByteBuffer, getObj, getShape, getStrides, getSuboffsets, hasArray, intAt, intAt, isReleased, release, storeAt, storeAt`

### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Constructor Detail

#### SimpleWritableBuffer

    public SimpleWritableBuffer(int flags,
                                BufferProtocol obj,
                                byte[] storage,
                                int index0,
                                int size)
                         throws PyException,
                                java.lang.NullPointerException

Provide an instance of `SimpleWritableBuffer`, on a slice of a byte array, meeting the consumer's expectations as expressed in the `flags` argument, which is checked against the capabilities of the buffer type.

Parameters:
  `flags` - consumer requirements
  `obj` - exporting object (or `null`)
  `storage` - the array of bytes storing the implementation of the exporting object
  `index0` - offset where the data starts in that array (item[0])
  `size` - the number of bytes occupied
Throws:
  `PyException` - `BufferError` when expectations do not correspond with the type
  `java.lang.NullPointerException`

#### SimpleWritableBuffer

    public SimpleWritableBuffer(int flags,
                                BufferProtocol obj,
                                byte[] storage)
                         throws PyException,
                                java.lang.NullPointerException

Provide an instance of `SimpleWritableBuffer`, on the entirety of a byte array, meeting the consumer's expectations as expressed in the `flags` argument, which is checked against the capabilities of the buffer type.

Parameters:
  `flags` - consumer requirements
  `obj` - exporting object (or `null`)
  `storage` - the array of bytes storing the implementation of the exporting object
Throws:
  `PyException` - `BufferError` when expectations do not correspond with the type
  `java.lang.NullPointerException`

### Method Detail

#### isReadonly

    public final boolean isReadonly()

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

Declared `final` returning `true` in `SimpleWritableBuffer` to make checks unnecessary.

Specified by:
  `isReadonly` in interface `PyBUF`
Overrides:
  `isReadonly` in class `BaseBuffer`
Returns:
  true if writing is not allowed, false if it is.

#### getBufferSlice

    public PyBuffer getBufferSlice(int flags,
                                   int start,
                                   int count)

Equivalent to `PyBuffer.getBufferSlice(int, int, int, int)` with stride 1.

`SimpleWritableBuffer` provides an implementation ensuring the returned slice is writable.

Specified by:
  `getBufferSlice` in interface `PyBuffer`
Overrides:
  `getBufferSlice` in class `SimpleBuffer`
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
Returns:
  a buffer representing the slice

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

`SimpleBuffer` 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.

`SimpleWritableBuffer` provides an implementation ensuring the returned slice is writable.

Specified by:
  `getBufferSlice` in interface `PyBuffer`
Overrides:
  `getBufferSlice` in class `SimpleBuffer`
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