/**

protected BufferProtocol obj;

/**

protected int[] shape;

/**

protected int[] strides;

/**

protected int index0;

/**

protected int exports = 1;

/**

private int gFeatureFlags = ~NAVIGATION; // featureFlags = 0

/**

protected BaseBuffer(int featureFlags, int index0, int[] shape, int[] strides) {

setFeatureFlags(featureFlags | FORMAT);

this.index0 = index0;

this.shape = shape;

this.strides = strides;

}

/**

protected final int getFeatureFlags() {

return NAVIGATION ^ (~gFeatureFlags);

}

/**

protected final void setFeatureFlags(int flags) {

gFeatureFlags = (~NAVIGATION) ^ flags;

}

/**

protected final void addFeatureFlags(int flags) {

setFeatureFlags(flags | getFeatureFlags());

}

/**

protected final void removeFeatureFlags(int flags) {

setFeatureFlags(~flags & getFeatureFlags());

}

/**

protected void checkRequestFlags(int flags) throws PyException {

/*

int syndrome = gFeatureFlags & (flags ^ NAVIGATION);

if (syndrome != 0) {

throw bufferErrorFromSyndrome(syndrome);

}

}

@Override

public boolean isReadonly() {

// WRITABLE is a non-navigation flag, so is inverted in gFeatureFlags

return (gFeatureFlags & WRITABLE) != 0; // i.e. featureFlags & WRITABLE is false

}

@Override

public int getNdim() {

return shape.length;

}

@Override

public int[] getShape() {

// Difference from CPython: never null, even when the consumer doesn't request it.

return shape;

}

// XXX Consider making this part of the PyBUF interface

protected int getSize() {

final int N = shape.length;

int size = shape[0];

for (int k = 1; k < N; k++) {

size *= shape[k];

}

return size;

}

@Override

public int getLen() {

final int N = shape.length;

int len = getItemsize();

for (int k = 0; k < N; k++) {

len *= shape[k];

}

return len;

}

@Override

public final BufferProtocol getObj() {

return obj;

}

/**

abstract protected byte byteAtImpl(int byteIndex) throws IndexOutOfBoundsException;

/**

abstract protected void storeAtImpl(byte value, int byteIndex)

throws IndexOutOfBoundsException, PyException;

/**

@Override

public byte byteAt(int index) throws IndexOutOfBoundsException {

return byteAtImpl(byteIndex(index));

}

/**

@Override

public int intAt(int index) throws IndexOutOfBoundsException {

return 0xff & byteAtImpl(byteIndex(index));

}

/**

@Override

public void storeAt(byte value, int index) throws IndexOutOfBoundsException, PyException {

storeAtImpl(value, byteIndex(index));

}

/**

@Override

public byte byteAt(int... indices) throws IndexOutOfBoundsException {

return byteAtImpl(byteIndex(indices));

}

/**

@Override

public int intAt(int... indices) throws IndexOutOfBoundsException {

return 0xff & byteAt(indices);

}

/**

@Override

public void storeAt(byte value, int... indices) throws IndexOutOfBoundsException, PyException {

storeAtImpl(value, byteIndex(indices));

}

/*

@Override

public int byteIndex(int index) throws IndexOutOfBoundsException {

// Treat as one-dimensional

if (index < 0 || index >= shape[0]) {

throw new IndexOutOfBoundsException();

}

return index0 + index * strides[0];

}

/*

@Override

public int byteIndex(int... indices) throws IndexOutOfBoundsException {

final int N = checkDimension(indices);

// In general: index0 + sum(k=0,N-1) indices[k]*strides[k]

int index = index0;

for (int k = 0; k < N; k++) {

int ik = indices[k];

if (ik < 0 || ik >= shape[k]) {

throw new IndexOutOfBoundsException();

}

index += ik * strides[k];

}

return index;

}

/**

protected int calcGreatestIndex() {

final int N = shape.length;

// If all the strides are positive, the maximal value is found from:

// index = index0 + sum(k=0,N-1) (shape[k]-1)*strides[k]

// but in general, for any k where strides[k]<=0, the term should be zero.

int index = index0;

int[] strides = getStrides();

for (int k = 0; k < N; k++) {

int stride = strides[k];

if (stride > 0) {

index += (shape[k] - 1) * stride;

}

}

return index;

}

/**

protected int calcLeastIndex() {

final int N = shape.length;

// If all the strides are positive, the maximal value is just index0,

// but in general, we must allow strides[k]<=0 for some k:

// index = index0 + sum(k=0,N-1) (strides[k]<0) ? (shape[k]-1)*strides[k] : 0

int index = index0;

int[] strides = getStrides();

for (int k = 0; k < N; k++) {

int stride = strides[k];

if (stride < 0) {

index += (shape[k] - 1) * stride;

}

}

return index;

}

/**

@Override

public void copyTo(byte[] dest, int destPos) throws IndexOutOfBoundsException {

// Note shape[0] is the number of items in the array

copyTo(0, dest, destPos, getSize());

}

/**

@Override

public void copyTo(int srcIndex, byte[] dest, int destPos, int count)

throws IndexOutOfBoundsException, PyException {

checkDimension(1);

int itemsize = getItemsize();

int s = srcIndex, d = destPos;

if (itemsize == 1) {

// Single byte items

for (int i = 0; i < count; i++) {

dest[d++] = byteAt(s++);

}

} else {

// Multi-byte items

for (int i = 0; i < count; i++) {

int p = byteIndex(s++);

for (int j = 0; j < itemsize; j++) {

dest[d++] = byteAtImpl(p + j);

}

}

}

}

/**

@Override

public void copyFrom(byte[] src, int srcPos, int destIndex, int count)

throws IndexOutOfBoundsException, PyException {

checkDimension(1);

checkWritable();

int itemsize = getItemsize();

int d = destIndex, s = srcPos;

if (itemsize == 1) {

// Single byte items

for (int i = 0; i < count; i++) {

storeAt(src[s++], d++);

}

} else {

// Multi-byte items

for (int i = 0; i < count; i++) {

int p = byteIndex(d++);

for (int j = 0; j < itemsize; j++) {

storeAtImpl(src[s++], p++);

}

}

}

}

/**

@Override

public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {

checkDimension(1);

checkWritable();

int itemsize = getItemsize();

int count = getSize();

int byteLen = src.getLen();

// Block operation if different item or overall size (permit reshape)

if (src.getItemsize() != itemsize || byteLen != count * itemsize) {

throw differentStructure();

}

/*

byte[] t = new byte[byteLen];

src.copyTo(t, 0);

this.copyFrom(t, 0, 0, count);

}

@Override

public synchronized PyBuffer getBuffer(int flags) {

if (exports > 0) {

// Always safe to re-export if the current count is not zero

return getBufferAgain(flags);

} else {

// exports==0 so refuse

throw bufferReleased("getBuffer");

}

}

/**

public synchronized BaseBuffer getBufferAgain(int flags) {

// If only the request flags are correct for this type, we can re-use this buffer

checkRequestFlags(flags);

// Count another consumer of this

exports += 1;

return this;

}

/**

@Override

public void release() {

if (--exports == 0) {

// This is a final release.

releaseAction();

// We have to release the root too if we are not a root.

PyBuffer root = getRoot();

if (root != this) {

root.release();

}

} else if (exports < 0) {

// Buffer already had 0 exports. (Put this right, in passing.)

exports = 0;

throw bufferReleased("release");

}

}

@Override

public void close() {

release();

}

@Override

public boolean isReleased() {

return exports <= 0;

}

@Override

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

return getBufferSlice(flags, start, count, 1);

}

// Let the sub-class implement

// @Override public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {}

/**

abstract protected ByteBuffer getNIOByteBufferImpl();

@Override

public ByteBuffer getNIOByteBuffer() {

// The buffer spans the whole storage

ByteBuffer b = getNIOByteBufferImpl();

// For the one-dimensional contiguous case it makes sense to set the limit:

if (shape.length == 1 && isContiguous('A')) {

int stride = strides[0];

if (getItemsize() == stride) {

b.limit(index0 + shape[0] * stride);

}

}

// The buffer is positioned at item[0]

b.position(index0);

return b;

}

@Override

public boolean hasArray() {

// AS_ARRAY is a non-navigation flag, so is inverted in gFeatureFlags

return (gFeatureFlags & AS_ARRAY) == 0; // i.e. featureFlags & AS_ARRAY is true

}

@SuppressWarnings("deprecation")

@Override

public Pointer getBuf() {

checkHasArray();

return new Pointer(getNIOByteBuffer().array(), index0);

}

@SuppressWarnings("deprecation")

@Override

public Pointer getPointer(int index) throws IndexOutOfBoundsException {

Pointer p = getBuf();

p.offset = byteIndex(index);

return p;

}

@SuppressWarnings("deprecation")

@Override

public Pointer getPointer(int... indices) throws IndexOutOfBoundsException {

Pointer p = getBuf();

p.offset = byteIndex(indices);

return p;

}

@Override

public int[] getStrides() {

return strides;

}

@Override

public int[] getSuboffsets() {

// No actual 'suboffsets' member until a sub-class needs it

return null;

}

private boolean isCContiguous() {

/*

final int N = shape.length;

/*

int size = getItemsize();

for (int k = N - 1; k >= 0; k--) {

int nk = shape[k];

if (nk > 1) {

if (strides[k] != size) {

return false;

}

size *= nk;

}

}

return true;

}

private boolean isFortranContiguous() {

/*

final int N = shape.length;

/*

int size = getItemsize();

for (int k = 0; k < N; k++) {

int nk = shape[k];

if (nk > 1) {

if (strides[k] != size) {

return false;

}

size *= nk;

}

}

return true;

}

@Override

public boolean isContiguous(char order) {

if (getSuboffsets() != null) {

return false;

}

switch (order) {

case 'C':

return isCContiguous();

case 'F':

return isFortranContiguous();

case 'A':

return isCContiguous() || isFortranContiguous();

default:

return false;

}

}

@Override

public String getFormat() {

// Avoid having to have an actual 'format' member

return "B";

}

@Override

public int getItemsize() {

// Avoid having to have an actual 'itemsize' member

return 1;

}

/**

protected void releaseAction() {}

/**

protected PyBuffer getRoot() {

return this;

}

/**

@Override

public String toString() {

int n = getLen();

StringBuilder sb = new StringBuilder(n);

for (int i = 0; i < n; i++) {

sb.appendCodePoint(intAt(i));

}

return sb.toString();

}

/**

int checkDimension(int[] indices) throws PyException {

int n = indices.length;

checkDimension(n);

return n;

}

/**

void checkDimension(int n) throws PyException {

int ndim = getNdim();

if (n != ndim) {

String fmt = "buffer with %d dimension%s accessed as having %d dimension%s";

String msg = String.format(fmt, ndim, ndim == 1 ? "" : "s", n, n, n == 1 ? "" : "s");

throw Py.BufferError(msg);

}

}

/**

protected void checkWritable() throws PyException {

if (isReadonly()) {

throw notWritable();

}

}

/**

protected void checkHasArray() throws PyException {

if (!hasArray()) {

throw bufferIsNot("accessible as a Java array");

}

}

/**

private static PyException bufferErrorFromSyndrome(int syndrome) {

if ((syndrome & ND) != 0) {

return bufferRequires("shape array");

} else if ((syndrome & WRITABLE) != 0) {

return bufferIsNot("writable");

} else if ((syndrome & AS_ARRAY) != 0) {

return bufferIsNot("accessible as a Java array");

} else if ((syndrome & C_CONTIGUOUS) != 0) {

return bufferIsNot("C-contiguous");

} else if ((syndrome & F_CONTIGUOUS) != 0) {

return bufferIsNot("Fortran-contiguous");

} else if ((syndrome & ANY_CONTIGUOUS) != 0) {

return bufferIsNot("contiguous");

} else if ((syndrome & STRIDES) != 0) {

return bufferRequires("strides array");

} else if ((syndrome & INDIRECT) != 0) {

return bufferRequires("suboffsets array");

} else {

// Catch-all error (never in practice if this method is complete)

return bufferIsNot("capable of matching request");

}

}

/**

protected static PyException notWritable() {

return Py.TypeError("cannot modify read-only memory");

}

/**

protected static PyException bufferIsNot(String property) {

return Py.BufferError("underlying buffer is not " + property);

}

/**

protected static PyException differentStructure() {

return Py.ValueError("buffer assignment: lvalue and rvalue have different structures");

}

/**

protected static PyException bufferRequires(String feature) {

return Py.BufferError("buffer structure requires consumer to use " + feature);

}

/**

protected static PyException bufferReleased(String operation) {

String op = (operation == null) ? "" : operation + " ";

return Py.BufferError(op + "operation forbidden on released buffer object");

}