public Interface PyBUF

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it will assume a contiguous organisation of the items, but will enquire which organisation it actually is. getBuffer will raise an exception if the exporter's buffer is not contiguous. ANY_CONTIGUOUS implies STRIDES.

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it expects to access the buffer contents directly as an array (rather than through the purely abstract part of the API). getBuffer will raise an exception if the exporter cannot expose its storage as Java array.

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it will assume C-order organisation of the items. getBuffer will raise an exception if the exporter's buffer is not C-ordered. C_CONTIGUOUS implies STRIDES.

Equivalent to (ND | WRITABLE)

Equivalent to ND

Field mask, used as in if ((flags&CONTIGUITY)== ... ) ....

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it will assume Fortran-order organisation of the items. getBuffer will raise an exception if the exporter's buffer is not Fortran-ordered. F_CONTIGUOUS implies STRIDES.

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it requires PyBuffer#getFormat() to return a String indicating the type of the unit. This exists for compatibility with CPython, as in Jython the format is always provided by getFormat().

Equivalent to (INDIRECT | WRITABLE | FORMAT). Also use this in the request if you plan only to use the fully-encapsulated API (byteAt, storeAt, copyTo, copyFrom, etc.), without ever calling PyBuffer#getNIOByteBuffer() or using PyBuffer.Pointer.

Equivalent to (INDIRECT | FORMAT). Also use this in the request if you plan only to use the fully-encapsulated API (byteAt, copyTo, etc.), read only, without ever calling PyBuffer#getNIOByteBuffer() or using PyBuffer.Pointer.

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it understands the suboffsets array. getBuffer will raise an exception if consumer does not specify the flag but the exporter's buffer cannot be navigated without understanding the suboffsets array. INDIRECT implies STRIDES.

A constant used by the exporter in processing BufferProtocol#getBuffer(int) to check for assumed C-order organisation of the items. C_CONTIGUOUS = IS_C_CONTIGUOUS | STRIDES.

A constant used by the exporter in processing BufferProtocol#getBuffer(int) to check for assumed C-order Fortran-order organisation of the items. F_CONTIGUOUS = IS_F_CONTIGUOUS | STRIDES.

The maximum allowed number of dimensions (CPython restriction).

Field mask, used as in if ((flags&NAVIGATION) == STRIDES) .... The importance of the subset of flags defined by this mask is not so much in their "navigational" character as in the way they are treated in a buffer request.

The NAVIGATION set are used to specify which navigation arrays the consumer will use, and therefore the consumer must ask for all those necessary to use the buffer successfully (which is a function of the buffer's actual type). Asking for extra ones is not an error, since all are supplied (in Jython): asking for too few is an error.

Flags outside the NAVIGATION set, work the other way round. Asking for one the buffer cannot match is an error: not asking for a feature the buffer does not have is an error.

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it is prepared to navigate the buffer as multi-dimensional using the shape array. getBuffer will raise an exception if consumer does not specify the flag but the exporter's buffer cannot be navigated without taking into account its multiple dimensions.

Equivalent to (STRIDES | WRITABLE | FORMAT)

Equivalent to (STRIDES | FORMAT)

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it assumes a simple one-dimensional organisation of the exported storage with item size of one. getBuffer will raise an exception if the consumer sets this flag and the exporter cannot represent itself as byte array data.

Equivalent to (STRIDES | WRITABLE)

Equivalent to STRIDES

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it expects to use the strides array. getBuffer will raise an exception if consumer does not specify the flag but the exporter's buffer cannot be navigated without using the strides array.

A constant used by the consumer in its call to BufferProtocol#getBuffer(int) to specify that it expects to write to the buffer contents. getBuffer will raise an exception if the exporter's buffer cannot meet this requirement.

The number of bytes stored in each indexable item.

Returns:int

the number of bytes comprising each item.

The total number of bytes represented by the view, which will be the product of the elements of the shape array, and the item size in bytes.

Returns:int

the total number of bytes represented.

The number of dimensions to the buffer. This number is the length of the shape array. The actual storage may be a linear array, but this is the number of dimensions in the interpretation that the exporting object gives the data.

Returns:int

number of dimensions

An array reporting the size of the buffer, considered as a multidimensional array, in each dimension and (by its length) giving the number of dimensions. The size of the buffer is its size in "items". An item is the amount of buffer content addressed by one index or set of indices. In the simplest case an item is a single unit (byte), and there is one dimension. In complex cases, the array is multi-dimensional, and the item at each location is multi-unit (multi-byte). The consumer must not modify this array. A valid shape array is always returned (difference from CPython).

Returns:int[]

the dimensions of the buffer as an array

The strides array gives the distance in the storage array between adjacent items (in each dimension). In the rawest parts of the buffer API, the consumer of the buffer is able to navigate the exported storage. The "strides" array is part of the support for interpreting the buffer as an n-dimensional array of items. It provides the coefficients of the "addressing polynomial". (More on this in the CPython documentation.) The consumer must not modify this array. A valid strides array is always returned (difference from CPython).

Returns:int[]

the distance in the storage array between adjacent items (in each dimension)

The suboffsets array is a further part of the support for interpreting the buffer as an n-dimensional array of items, where the array potentially uses indirect addressing (like a real Java array of arrays, in fact). This is only applicable when there is more than 1 dimension, and it works in conjunction with the strides array. (More on this in the CPython documentation.) When used, suboffsets[k] is an integer index, not a byte offset as in CPython. The consumer must not modify this array. When not needed for navigation null is returned (as in CPython).

Returns:int[]

suboffsets array or null if not necessary for navigation

Enquire whether the array is represented contiguously in the backing storage, according to C or Fortran ordering. A one-dimensional contiguous array is both.

Parameters

order:char

'C', 'F' or 'A', as the storage order is C, Fortran or either.

Returns:boolean

true iff the array is stored contiguously in the order specified

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

Returns:boolean

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