{

internal List<byte>/*!*/ _bytes;

public ByteArray() {

_bytes = new List<byte>(0);

}

internal ByteArray(List<byte> bytes) {

_bytes = bytes;

}

internal ByteArray (byte[] bytes) {

_bytes = new List<byte>(bytes);

}

public void __init__() {

_bytes = new List<byte>();

}

public void __init__(int source) {

_bytes = new List<byte>(source);

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

_bytes.Add(0);

}

}

public void __init__(BigInteger source) {

__init__((int)source);

}

public void __init__([NotNull]IList<byte>/*!*/ source) {

_bytes = new List<byte>(source);

}

public void __init__(object source) {

__init__(GetBytes(source));

}

public void __init__(CodeContext/*!*/ context, string source, string encoding, [DefaultParameterValue("strict")]string errors) {

_bytes = new List<byte>(StringOps.encode(context, source, encoding, errors).MakeByteArray());

}

#region Public Mutable Sequence API

public void append(int item) {

lock (this) {

_bytes.Add(item.ToByteChecked());

}

}

public void append(object item) {

lock(this) {

_bytes.Add(GetByte(item));

}

}

public void extend([NotNull]IEnumerable<byte>/*!*/ seq) {

using (new OrderedLocker(this, seq)) {

// use the original count for if we're extending this w/ this

_bytes.AddRange(seq);

}

}

public void extend(object seq) {

extend(GetBytes(seq));

}

public void insert(int index, int value) {

lock (this) {

if (index >= Count) {

append(value);

return;

}

index = PythonOps.FixSliceIndex(index, Count);

_bytes.Insert(index, value.ToByteChecked());

}

}

public void insert(int index, object value) {

insert(index, Converter.ConvertToIndex(value));

}

public int pop() {

lock (this) {

if (Count == 0) {

throw PythonOps.IndexError("pop off of empty bytearray");

}

int res = _bytes[_bytes.Count - 1];

_bytes.RemoveAt(_bytes.Count - 1);

return res;

}

}

public int pop(int index) {

lock (this) {

if (Count == 0) {

throw PythonOps.IndexError("pop off of empty bytearray");

}

index = PythonOps.FixIndex(index, Count);

int ret = _bytes[index];

_bytes.RemoveAt(index);

return ret;

}

}

public void remove(int value) {

lock (this) {

_bytes.RemoveAt(_bytes.IndexOfByte(value.ToByteChecked(), 0, _bytes.Count));

}

}

public void remove(object value) {

lock (this) {

if (value is ByteArray) {

throw PythonOps.TypeError("an integer or string of size 1 is required");

}

_bytes.RemoveAt(_bytes.IndexOfByte(GetByte(value), 0, _bytes.Count));

}

}

public void reverse() {

lock (this) {

List<byte> reversed = new List<byte>();

for (int i = _bytes.Count - 1; i >= 0; i--) {

reversed.Add(_bytes[i]);

}

_bytes = reversed;

}

}

[SpecialName]

public ByteArray InPlaceAdd(ByteArray other) {

using (new OrderedLocker(this, other)) {

_bytes.AddRange(other._bytes);

return this;

}

}

[SpecialName]

public ByteArray InPlaceAdd(Bytes other) {

lock (this) {

_bytes.AddRange(other);

return this;

}

}

[SpecialName]

public ByteArray InPlaceMultiply(int len) {

lock (this) {

_bytes = (this * len)._bytes;

return this;

}

}

#endregion

#region Public Python API surface

public ByteArray/*!*/ capitalize() {

lock (this) {

return new ByteArray(_bytes.Capitalize());

}

}

public ByteArray/*!*/ center(int width) {

return center(width, " ");

}

public ByteArray/*!*/ center(int width, [NotNull]string fillchar) {

lock (this) {

List<byte> res = _bytes.TryCenter(width, fillchar.ToByte("center", 2));

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public ByteArray/*!*/ center(int width, [BytesConversion]IList<byte> fillchar) {

lock (this) {

List<byte> res = _bytes.TryCenter(width, fillchar.ToByte("center", 2));

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public int count([BytesConversion]IList<byte>/*!*/ sub) {

return count(sub, 0, _bytes.Count);

}

public int count([BytesConversion]IList<byte>/*!*/ sub, int start) {

return count(sub, start, _bytes.Count);

}

public int count([BytesConversion]IList<byte>/*!*/ ssub, int start, int end) {

lock (this) {

return _bytes.CountOf(ssub, start, end);

}

}

public string decode(CodeContext/*!*/ context, [Optional]object encoding, [DefaultParameterValue("strict")]string errors) {

return StringOps.decode(context, _bytes.MakeString(), encoding, errors);

}

public bool endswith([BytesConversion]IList<byte>/*!*/ suffix) {

lock (this) {

return _bytes.EndsWith(suffix);

}

}

public bool endswith([BytesConversion]IList<byte>/*!*/ suffix, int start) {

lock (this) {

return _bytes.EndsWith(suffix, start);

}

}

public bool endswith([BytesConversion]IList<byte>/*!*/ suffix, int start, int end) {

lock (this) {

return _bytes.EndsWith(suffix, start, end);

}

}

public bool endswith(PythonTuple/*!*/ suffix) {

lock (this) {

return _bytes.EndsWith(suffix);

}

}

public bool endswith(PythonTuple/*!*/ suffix, int start) {

lock (this) {

return _bytes.EndsWith(suffix, start);

}

}

public bool endswith(PythonTuple/*!*/ suffix, int start, int end) {

lock (this) {

return _bytes.EndsWith(suffix, start, end);

}

}

public ByteArray/*!*/ expandtabs() {

return expandtabs(8);

}

public ByteArray/*!*/ expandtabs(int tabsize) {

lock (this) {

return new ByteArray(_bytes.ExpandTabs(tabsize));

}

}

public int find([BytesConversion]IList<byte>/*!*/ sub) {

lock (this) {

return _bytes.Find(sub);

}

}

public int find([BytesConversion]IList<byte>/*!*/ sub, int start) {

lock (this) {

return _bytes.Find(sub, start);

}

}

public int find([BytesConversion]IList<byte>/*!*/ sub, int start, int end) {

lock (this) {

return _bytes.Find(sub, start, end);

}

}

public static ByteArray/*!*/ fromhex(string/*!*/ @string) {

return new ByteArray(IListOfByteOps.FromHex(@string));

}

public int index([BytesConversion]IList<byte>/*!*/ item) {

return index(item, 0, _bytes.Count);

}

public int index([BytesConversion]IList<byte>/*!*/ item, int start) {

return index(item, start, _bytes.Count);

}

public int index([BytesConversion]IList<byte>/*!*/ item, int start, int stop) {

lock (this) {

int res = find(item, start, stop);

if (res == -1) {

throw PythonOps.ValueError("bytearray.index(item): item not in bytearray");

}

return res;

}

}

public bool isalnum() {

lock (this) {

return _bytes.IsAlphaNumeric();

}

}

public bool isalpha() {

lock (this) {

return _bytes.IsLetter();

}

}

public bool isdigit() {

lock (this) {

return _bytes.IsDigit();

}

}

public bool islower() {

lock (this) {

return _bytes.IsLower();

}

}

public bool isspace() {

lock (this) {

return _bytes.IsWhiteSpace();

}

}

/// <summary>

/// return true if self is a titlecased string and there is at least one

/// character in self; also, uppercase characters may only follow uncased

/// characters (e.g. whitespace) and lowercase characters only cased ones.

/// return false otherwise.

/// </summary>

public bool istitle() {

lock (this) {

return _bytes.IsTitle();

}

}

public bool isupper() {

lock (this) {

return _bytes.IsUpper();

}

}

/// <summary>

/// Return a string which is the concatenation of the strings

/// in the sequence seq. The separator between elements is the

/// string providing this method

/// </summary>

public ByteArray/*!*/ join(object/*!*/ sequence) {

IEnumerator seq = PythonOps.GetEnumerator(sequence);

if (!seq.MoveNext()) {

return new ByteArray();

}

// check if we have just a sequnce of just one value - if so just

// return that value.

object curVal = seq.Current;

if (!seq.MoveNext()) {

return JoinOne(curVal);

}

List<byte> ret = new List<byte>();

ByteOps.AppendJoin(curVal, 0, ret);

int index = 1;

do {

ret.AddRange(this);

ByteOps.AppendJoin(seq.Current, index, ret);

index++;

} while (seq.MoveNext());

return new ByteArray(ret);

}

public ByteArray/*!*/ join([NotNull]List/*!*/ sequence) {

if (sequence.__len__() == 0) {

return new ByteArray();

}

lock (this) {

if (sequence.__len__() == 1) {

return JoinOne(sequence[0]);

}

List<byte> ret = new List<byte>();

ByteOps.AppendJoin(sequence._data[0], 0, ret);

for (int i = 1; i < sequence._size; i++) {

ret.AddRange(this);

ByteOps.AppendJoin(sequence._data[i], i, ret);

}

return new ByteArray(ret);

}

}

public ByteArray/*!*/ ljust(int width) {

return ljust(width, (byte)' ');

}

public ByteArray/*!*/ ljust(int width, [NotNull]string/*!*/ fillchar) {

return ljust(width, fillchar.ToByte("ljust", 2));

}

public ByteArray/*!*/ ljust(int width, IList<byte>/*!*/ fillchar) {

return ljust(width, fillchar.ToByte("ljust", 2));

}

private ByteArray/*!*/ ljust(int width, byte fillchar) {

lock (this) {

int spaces = width - _bytes.Count;

List<byte> ret = new List<byte>(width);

ret.AddRange(_bytes);

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

ret.Add(fillchar);

}

return new ByteArray(ret);

}

}

public ByteArray/*!*/ lower() {

lock (this) {

return new ByteArray(_bytes.ToLower());

}

}

public ByteArray/*!*/ lstrip() {

lock (this) {

List<byte> res = _bytes.LeftStrip();

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public ByteArray/*!*/ lstrip([BytesConversionNoString]IList<byte> bytes) {

lock (this) {

List<byte> res = _bytes.LeftStrip(bytes);

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public PythonTuple/*!*/ partition(IList<byte>/*!*/ sep) {

if (sep == null) {

throw PythonOps.TypeError("expected string, got NoneType");

} else if (sep.Count == 0) {

throw PythonOps.ValueError("empty separator");

}

object[] obj = new object[3] { new ByteArray(), new ByteArray(), new ByteArray() };

if (_bytes.Count != 0) {

int index = find(sep);

if (index == -1) {

obj[0] = CopyThis();

} else {

obj[0] = new ByteArray(_bytes.Substring(0, index));

obj[1] = sep;

obj[2] = new ByteArray(_bytes.Substring(index + sep.Count, _bytes.Count - index - sep.Count));

}

}

return new PythonTuple(obj);

}

public PythonTuple/*!*/ partition([NotNull]List/*!*/ sep) {

return partition(GetBytes(sep));

}

public ByteArray/*!*/ replace([BytesConversion]IList<byte>/*!*/ old, [BytesConversion]IList<byte> @new) {

if (old == null) {

throw PythonOps.TypeError("expected bytes or bytearray, got NoneType");

}

return replace(old, @new, _bytes.Count);

}

public ByteArray/*!*/ replace([BytesConversion]IList<byte>/*!*/ old, [BytesConversion]IList<byte>/*!*/ @new, int count) {

if (old == null) {

throw PythonOps.TypeError("expected bytes or bytearray, got NoneType");

} else if (count == 0) {

return CopyThis();

}

return new ByteArray(_bytes.Replace(old, @new, count));

}

public int rfind([BytesConversion]IList<byte>/*!*/ sub) {

return rfind(sub, 0, _bytes.Count);

}

public int rfind([BytesConversion]IList<byte>/*!*/ sub, int start) {

return rfind(sub, start, _bytes.Count);

}

public int rfind([BytesConversion]IList<byte>/*!*/ sub, int start, int end) {

lock (this) {

return _bytes.ReverseFind(sub, start, end);

}

}

public int rindex([BytesConversion]IList<byte>/*!*/ sub) {

return rindex(sub, 0, _bytes.Count);

}

public int rindex([BytesConversion]IList<byte>/*!*/ sub, int start) {

return rindex(sub, start, _bytes.Count);

}

public int rindex([BytesConversion]IList<byte>/*!*/ sub, int start, int end) {

int ret = rfind(sub, start, end);

if (ret == -1) {

throw PythonOps.ValueError("substring {0} not found in {1}", sub, this);

}

return ret;

}

public ByteArray/*!*/ rjust(int width) {

return rjust(width, (byte)' ');

}

public ByteArray/*!*/ rjust(int width, [NotNull]string/*!*/ fillchar) {

return rjust(width, fillchar.ToByte("rjust", 2));

}

public ByteArray/*!*/ rjust(int width, [BytesConversion]IList<byte>/*!*/ fillchar) {

return rjust(width, fillchar.ToByte("rjust", 2));

}

private ByteArray/*!*/ rjust(int width, int fillchar) {

byte fill = fillchar.ToByteChecked();

lock (this) {

int spaces = width - _bytes.Count;

if (spaces <= 0) {

return CopyThis();

}

List<byte> ret = new List<byte>(width);

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

ret.Add(fill);

}

ret.AddRange(_bytes);

return new ByteArray(ret);

}

}

public PythonTuple/*!*/ rpartition(IList<byte>/*!*/ sep) {

if (sep == null) {

throw PythonOps.TypeError("expected string, got NoneType");

} else if (sep.Count == 0) {

throw PythonOps.ValueError("empty separator");

}

lock (this) {

object[] obj = new object[3] { new ByteArray(), new ByteArray(), new ByteArray() };

if (_bytes.Count != 0) {

int index = rfind(sep);

if (index == -1) {

obj[2] = CopyThis();

} else {

obj[0] = new ByteArray(_bytes.Substring(0, index));

obj[1] = new ByteArray(new List<byte>(sep));

obj[2] = new ByteArray(_bytes.Substring(index + sep.Count, Count - index - sep.Count));

}

}

return new PythonTuple(obj);

}

}

public PythonTuple/*!*/ rpartition([NotNull]List/*!*/ sep) {

return rpartition(GetBytes(sep));

}

public List/*!*/ rsplit() {

lock (this) {

return _bytes.SplitInternal((byte[])null, -1, x => new ByteArray(x));

}

}

public List/*!*/ rsplit([BytesConversionNoString]IList<byte>/*!*/ sep) {

return rsplit(sep, -1);

}

public List/*!*/ rsplit([BytesConversionNoString]IList<byte>/*!*/ sep, int maxsplit) {

return _bytes.RightSplit(sep, maxsplit, x => new ByteArray(new List<byte>(x)));

}

public ByteArray/*!*/ rstrip() {

lock (this) {

List<byte> res = _bytes.RightStrip();

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public ByteArray/*!*/ rstrip([BytesConversionNoString]IList<byte> bytes) {

lock (this) {

List<byte> res = _bytes.RightStrip(bytes);

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public List/*!*/ split() {

lock (this) {

return _bytes.SplitInternal((byte[])null, -1, x => new ByteArray(x));

}

}

public List/*!*/ split([BytesConversionNoString]IList<byte> sep) {

return split(sep, -1);

}

public List/*!*/ split([BytesConversionNoString]IList<byte> sep, int maxsplit) {

lock (this) {

return _bytes.Split(sep, maxsplit, x => new ByteArray(x));

}

}

public List/*!*/ splitlines() {

return splitlines(false);

}

public List/*!*/ splitlines(bool keepends) {

lock (this) {

return _bytes.SplitLines(keepends, x => new ByteArray(x));

}

}

public bool startswith([BytesConversion]IList<byte>/*!*/ prefix) {

lock (this) {

return _bytes.StartsWith(prefix);

}

}

public bool startswith([BytesConversion]IList<byte>/*!*/ prefix, int start) {

lock (this) {

int len = Count;

if (start > len) {

return false;

} else if (start < 0) {

start += len;

if (start < 0) start = 0;

}

return _bytes.Substring(start).StartsWith(prefix);

}

}

public bool startswith([BytesConversion]IList<byte>/*!*/ prefix, int start, int end) {

lock (this) {

return _bytes.StartsWith(prefix, start, end);

}

}

public bool startswith(PythonTuple/*!*/ prefix) {

lock (this) {

return _bytes.StartsWith(prefix);

}

}

public bool startswith(PythonTuple/*!*/ prefix, int start) {

lock (this) {

return _bytes.StartsWith(prefix, start);

}

}

public bool startswith(PythonTuple/*!*/ prefix, int start, int end) {

lock (this) {

return _bytes.StartsWith(prefix, start, end);

}

}

public ByteArray/*!*/ strip() {

lock (this) {

List<byte> res = _bytes.Strip();

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public ByteArray/*!*/ strip([BytesConversionNoString]IList<byte> chars) {

lock (this) {

List<byte> res = _bytes.Strip(chars);

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public ByteArray/*!*/ swapcase() {

lock (this) {

return new ByteArray(_bytes.SwapCase());

}

}

public ByteArray/*!*/ title() {

lock (this) {

List<byte> res = _bytes.Title();

if (res == null) {

return CopyThis();

}