/** The {@link PyType} of <code>bytearray</code>. */

public static final PyType TYPE = PyType.fromClass(PyByteArray.class);

/**

public PyByteArray(PyType type) {

super(type);

}

/**

public PyByteArray() {

super(TYPE);

}

/**

public PyByteArray(int size) {

super(TYPE);

init(size);

}

/**

public PyByteArray(int[] value) {

super(TYPE, value);

}

/**

public PyByteArray(BaseBytes value) {

super(TYPE);

init(value);

}

/**

PyByteArray(PyBuffer value) {

super(TYPE);

init(value);

}

/**

public PyByteArray(BufferProtocol value) {

super(TYPE);

init(value);

}

/**

public PyByteArray(Iterable<? extends PyObject> value) {

super(TYPE);

init(value);

}

/**

public PyByteArray(PyString arg, PyObject encoding, PyObject errors) {

super(TYPE);

init(arg, encoding, errors);

}

/**

public PyByteArray(PyString arg, String encoding, String errors) {

super(TYPE);

init(arg, encoding, errors);

}

/**

public PyByteArray(PyString arg) {

super(TYPE);

init(arg, (String)null, (String)null);

}

/**

public PyByteArray(byte[] storage) {

super(TYPE);

setStorage(storage);

}

/**

public PyByteArray(byte[] storage, int size) {

super(TYPE);

setStorage(storage, size);

}

/**

public PyByteArray(PyObject arg) throws PyException {

super(TYPE);

init(arg);

}

/*

/**

private WeakReference<BaseBuffer> export;

/**

@Override

public synchronized PyBuffer getBuffer(int flags) {

// If we have already exported a buffer it may still be available for re-use

BaseBuffer pybuf = getExistingBuffer(flags);

if (pybuf == null) {

// No existing export we can re-use: create a new one

pybuf = new SimpleWritableBuffer(flags, this, storage, offset, size);

// Hold a reference for possible re-use

export = new WeakReference<BaseBuffer>(pybuf);

}

return pybuf;

}

/**

private BaseBuffer getExistingBuffer(int flags) throws PyException {

BaseBuffer pybuf = null;

if (export != null) {

// A buffer was exported at some time.

pybuf = export.get();

if (pybuf != null) {

/*

pybuf = pybuf.getBufferAgain(flags);

}

}

return pybuf;

}

/**

protected void resizeCheck() throws PyException {

if (export != null) {

// A buffer was exported at some time and we have not explicitly discarded it.

PyBuffer pybuf = export.get();

if (pybuf != null && !pybuf.isReleased()) {

// A consumer still has the exported buffer

throw Py.BufferError("Existing exports of data: object cannot be re-sized");

} else {

/*

export = null;

}

}

}

/*

/**

@Override

protected synchronized PyByteArray getslice(int start, int stop, int step) {

if (step == 1) {

// Efficiently copy contiguous slice

return this.getslice(start, stop);

} else {

int n = sliceLength(start, stop, step);

PyByteArray ret = new PyByteArray(n);

n += ret.offset;

byte[] dst = ret.storage;

for (int io = start + offset, jo = ret.offset; jo < n; io += step, jo++) {

dst[jo] = storage[io];

}

return ret;

}

}

/**

@Override

protected synchronized PyByteArray getslice(int start, int stop) {

// If this were immutable, start==0 and end==size we would return (this).

// Efficiently copy contiguous slice

int n = stop - start;

if (n <= 0) {

return new PyByteArray();

} else {

PyByteArray ret = new PyByteArray(n);

System.arraycopy(storage, offset + start, ret.storage, ret.offset, n);

return ret;

}

}

/**

@Override

protected synchronized PyByteArray repeat(int count) {

Builder builder = new Builder(size * (long) count);

builder.repeat(this, count);

return getResult(builder);

}

/**

protected synchronized void irepeat(int count) {

// There are several special cases

if (size == 0 || count == 1) {

// No resize, so no check (consistent with CPython)

// Value is unchanged.

} else if (count <= 0) {

// Treat as if count == 0.

resizeCheck();

this.setStorage(emptyStorage);

} else {

// Open up space (remembering the original size)

int orginalSize = size;

storageExtend(orginalSize * (count - 1));

if (orginalSize == 1) {

// Do it efficiently for single bytes

byte b = storage[offset];

for (int i = 1, p = offset + 1; i < count; i++) {

storage[p++] = b;

}

} else {

// General case

for (int i = 1, p = offset + orginalSize; i < count; i++, p += orginalSize) {

System.arraycopy(storage, offset, storage, p, orginalSize);

}

}

}

}

/**

@Override

public synchronized void pyset(int index, PyObject value) throws PyException {

storage[index + offset] = byteCheck(value);

}

/**

@Override

public synchronized void pyinsert(int index, PyObject element) {

// Open a space at the right location.

storageReplace(index, 0, 1);

storage[offset + index] = byteCheck(element);

}

/**

@Override

protected synchronized void setslice(int start, int stop, int step, PyObject value) {

if (step == 1 && stop < start) {

// Because "b[5:2] = v" means insert v just before 5 not 2.

// ... although "b[5:2:-1] = v means b[5]=v[0], b[4]=v[1], b[3]=v[2]

stop = start;

}

/*

if (value instanceof PyString) {

/*

setslice(start, stop, step, (PyString)value);

} else if (value.isIndex()) {

/*

setslice(start, stop, step, value.asIndex(Py.OverflowError));

} else if (value instanceof BaseBytes) {

/*

setslice(start, stop, step, (BaseBytes)value);

} else if (setsliceFromBuffer(start, stop, step, value)) {

// Value supports Jython buffer API. (We're done.)

} else {

/*

setslice(start, stop, step, value.asIterable());

}

}

/**

private void setslice(int start, int stop, int step, int len) throws PyException {

if (step == 1) {

// Delete this[start:stop] and open a space of the right size = len

storageReplace(start, stop - start, len);

Arrays.fill(storage, start + offset, (start + offset) + len, (byte)0);

} else {

// This is an extended slice which means we are replacing elements

int n = sliceLength(start, stop, step);

if (n != len) {

throw SliceSizeError("bytes", len, n);

}

for (int io = start + offset; n > 0; io += step, --n) {

storage[io] = 0;

}

}

}

/**

private void setslice(int start, int stop, int step, PyString value) throws PyException {

if (value instanceof PyUnicode) {

// Has to be 8-bit PyString

throw Py.TypeError("can't set bytearray slice from unicode");

} else {

// Assignment is from 8-bit data

String v = value.asString();

int len = v.length();

if (step == 1) {

// Delete this[start:stop] and open a space of the right size

storageReplace(start, stop - start, len);

setBytes(start, v);

} else {

// This is an extended slice which means we are replacing elements

int n = sliceLength(start, stop, step);

if (n != len) {

throw SliceSizeError("bytes", len, n);

}

setBytes(start, step, v);

}

}

}

/**

private void setslice(int start, int stop, int step, BufferProtocol value) throws PyException, ClassCastException {

try (PyBuffer view = value.getBuffer(PyBUF.SIMPLE)) {

int len = view.getLen();

if (step == 1) {

// Delete this[start:stop] and open a space of the right size

storageReplace(start, stop - start, len);

view.copyTo(storage, start + offset);

} else {

// This is an extended slice which means we are replacing elements

int n = sliceLength(start, stop, step);

if (n != len) {

throw SliceSizeError("bytes", len, n);

}

for (int io = start + offset, j = 0; j < n; io += step, j++) {

storage[io] = view.byteAt(j); // Assign this[i] = value[j]

}

}

}

}

/**

private boolean setsliceFromBuffer(int start, int stop, int step, PyObject value)

throws PyException {

if (value instanceof BufferProtocol) {

try {

setslice(start, stop, step, (BufferProtocol) value);

return true;

} catch (ClassCastException e) { /* fall through to false */ }

}

return false;

}

/**

private void setslice(int start, int stop, int step, BaseBytes value) throws PyException {

if (value == this) { // Must work with a copy

value = new PyByteArray(value);

}

int len = value.size;

if (step == 1) {

// Delete this[start:stop] and open a space of the right size

storageReplace(start, stop - start, len);

System.arraycopy(value.storage, value.offset, storage, start + offset, len);

} else {

// This is an extended slice which means we are replacing elements

int n = sliceLength(start, stop, step);

if (n != len) {

throw SliceSizeError("bytes", len, n);

}

int no = n + value.offset;

for (int io = start + offset, jo = value.offset; jo < no; io += step, jo++) {

storage[io] = value.storage[jo]; // Assign this[i] = value[j]

}

}

}

/**

private void setslice(int start, int stop, int step, Iterable<? extends PyObject> iter) {

/*

FragmentList fragList = new BaseBytes.FragmentList();

fragList.loadFrom(iter);

if (step == 1) {

// Delete this[start:stop] and open a space of the right size

storageReplace(start, stop - start, fragList.totalCount);

if (fragList.totalCount > 0) {

// Stitch the fragments together in the space we made

fragList.emptyInto(storage, start + offset);

}

} else {

// This is an extended slice which means we are replacing elements

int n = sliceLength(start, stop, step);

if (n != fragList.totalCount) {

throw SliceSizeError("bytes", fragList.totalCount, n);

}

fragList.emptyInto(storage, start + offset, step);

}

}

@Override

protected synchronized void del(int index) {

storageDelete(index, 1);

}

@Override

protected synchronized void delRange(int start, int stop) {

storageDelete(start, stop - start);

}

@Override

protected synchronized void delslice(int start, int stop, int step, int n) {

// This will not be possible if this object has buffer exports

resizeCheck();

if (step == 1) {

// Delete this[start:stop] and close up the space.

storageDelete(start, n);

} else if (step == -1) {

// Also a contiguous case, but start > stop.

storageDelete(stop + 1, n);

} else {

// This is an extended slice. We will be deleting n isolated elements.

int p, m;

// We delete by copying from high to low memory, whatever the sign of step.

if (step > 1) {

// The lowest numbered element to delete is x[start]

p = start;

m = step - 1;

} else {

// The lowest numbered element to delete is x[start+(n-1)*step]]

p = start + (n - 1) * step;

m = -1 - step;

}

// Offset p to be a storage index.

p += offset;

// Copy n-1 blocks blocks of m bytes, each time skipping the byte to be deleted.

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

// Skip q over the one we are deleting

int q = p + i;

// Now copy the m elements that follow.

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

storage[p++] = storage[q++];

}

}

// Close up the gap. Note that for the copy, p was adjusted by the storage offset.

storageDelete(p - offset, n);

}

}

/**

public static PyException SliceSizeError(String valueType, int valueSize, int sliceSize) {

String fmt = "attempt to assign %s of size %d to extended slice of size %d";

return Py.ValueError(String.format(fmt, valueType, valueSize, sliceSize));

// XXX consider moving to SequenceIndexDelegate.java or somewhere else generic, even Py

}

/**

@ExposedNew

@ExposedMethod(doc = BuiltinDocs.bytearray___init___doc)

final synchronized void bytearray___init__(PyObject[] args, String[] kwds) {

ArgParser ap = new ArgParser("bytearray", args, kwds, "source", "encoding", "errors");

PyObject arg = ap.getPyObject(0, null);

// If not null, encoding and errors must be PyString (or PyUnicode)

PyObject encoding = ap.getPyObjectByType(1, PyBaseString.TYPE, null);

PyObject errors = ap.getPyObjectByType(2, PyBaseString.TYPE, null);

/*

if (encoding != null || errors != null) {

/*

if (arg == null || !(arg instanceof PyString)) {

throw Py.TypeError("encoding or errors without sequence argument");

}

init((PyString)arg, encoding, errors);

} else {

// Now construct from arbitrary object (or null)

init(arg);

}

}

/*

@Override

protected PyByteArray getResult(Builder b) {

return new PyByteArray(b.getStorage(), b.getSize());

}

/*

@Override

public PyObject __eq__(PyObject other) {

return basebytes___eq__(other);

}

@Override

public PyObject __ne__(PyObject other) {

return basebytes___ne__(other);

}

@Override

public PyObject __lt__(PyObject other) {

return basebytes___lt__(other);

}

@Override

public PyObject __le__(PyObject other) {

return basebytes___le__(other);

}

@Override

public PyObject __ge__(PyObject other) {

return basebytes___ge__(other);

}

@Override

public PyObject __gt__(PyObject other) {

return basebytes___gt__(other);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___eq___doc)

final synchronized PyObject bytearray___eq__(PyObject other) {

return basebytes___eq__(other);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___ne___doc)

final synchronized PyObject bytearray___ne__(PyObject other) {

return basebytes___ne__(other);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___lt___doc)

final synchronized PyObject bytearray___lt__(PyObject other) {

return basebytes___lt__(other);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___le___doc)

final synchronized PyObject bytearray___le__(PyObject other) {

return basebytes___le__(other);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___ge___doc)

final synchronized PyObject bytearray___ge__(PyObject other) {

return basebytes___ge__(other);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___gt___doc)

final synchronized PyObject bytearray___gt__(PyObject other) {

return basebytes___gt__(other);

}

@Override

public PyObject __add__(PyObject o) {

return bytearray___add__(o);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___add___doc)

final synchronized PyObject bytearray___add__(PyObject o) {

// Duplicate this buffer, but size it large enough to hold the sum

byte[] copy = new byte[size + o.__len__()];

System.arraycopy(storage, offset, copy, 0, size);

PyByteArray sum = new PyByteArray(copy, size);

// Concatenate the other buffer

return sum.bytearray___iadd__(o);

}

/**

public int __alloc__() {

return bytearray___alloc__();

}

@ExposedMethod(doc = BuiltinDocs.bytearray___alloc___doc)

final int bytearray___alloc__() {

return storage.length;

}

/**

@Override

public PyObject __imul__(PyObject n) {

return bytearray___imul__(n);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___imul___doc)

final PyObject bytearray___imul__(PyObject n) {

if (!n.isIndex()) {

return null;

}

irepeat(n.asIndex(Py.OverflowError));

return this;

}

/**

@Override

public PyObject __mul__(PyObject n) {

return bytearray___mul__(n);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___mul___doc)

final PyObject bytearray___mul__(PyObject n) {

if (!n.isIndex()) {

return null;

}

return repeat(n.asIndex(Py.OverflowError));

}

/**

@Override

public PyObject __rmul__(PyObject n) {

return bytearray___rmul__(n);

}

@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.bytearray___rmul___doc)

final PyObject bytearray___rmul__(PyObject n) {

if (!n.isIndex()) {

return null;

}

return repeat(n.asIndex(Py.OverflowError));

}

/**

public void append(byte element) {

// Open a space at the end.

storageExtend(1);