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

public ByteArray() {

_bytes = new List<byte>(0);

}

private ByteArray(List<byte> bytes) {

_bytes = bytes;

}

internal ByteArray(IEnumerable<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__([NotNull]string @string) {

throw PythonOps.TypeError("string argument without an encoding");

}

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

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

}

internal static ByteArray Make(List<byte> bytes) {

return new ByteArray(bytes);

}

internal List<byte> UnsafeByteList {

[PythonHidden]

get => _bytes;

}

#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) {

// We don't make use of the length hint when extending the byte array.

// However, in order to match CPython behavior with invalid length hints we

// we need to go through the motions and get the length hint and attempt

// to convert it to an int.

PythonOps.TryInvokeLengthHint(DefaultContext.Default, seq, out int len);

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;

}

}

private void RemoveByte(byte value) {

var idx = _bytes.IndexOfByte(value, 0, _bytes.Count);

if (idx == -1)

throw PythonOps.ValueError("value not found in bytearray");

_bytes.RemoveAt(idx);

}

public void remove(int value) {

lock (this) {

RemoveByte(value.ToByteChecked());

}

}

public void remove(object value) {

lock (this) {

RemoveByte(GetByte(value));

}

}

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 InPlaceAdd(MemoryView other) {

lock (this) {

_bytes.AddRange(other.tobytes());

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) => center(width, (byte)' ');

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

=> center(width, fillchar.ToByte("center", 2));

private ByteArray center(int width, byte fillchar) {

lock (this) {

List<byte> res = _bytes.TryCenter(width, fillchar);

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public void clear() => Clear();

public ByteArray copy() => CopyThis();

public int count([BytesConversion]IList<byte>/*!*/ sub) => count(sub, null, null);

public int count([BytesConversion]IList<byte>/*!*/ sub, int? start) => count(sub, start, null);

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

lock (this) {

return _bytes.CountOf(sub, start ?? 0, end ?? _bytes.Count);

}

}

public int count(int @byte) => count(@byte, null, null);

public int count(int @byte, int? start) => count(@byte, start, null);

public int count(int @byte, int? start, int? end) => count(new[] { @byte.ToByteChecked() }, start, end);

public string decode(CodeContext/*!*/ context, [NotNull]string encoding = "utf-8", [NotNull]string errors = "strict") {

lock (this) {

return StringOps.RawDecode(context, _bytes, encoding, errors);

}

}

public string decode(CodeContext/*!*/ context, [NotNull]Encoding encoding, [NotNull]string errors = "strict") {

lock (this) {

return StringOps.DoDecode(context, _bytes, errors, StringOps.GetEncodingName(encoding, normalize: false), encoding);

}

}

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) => find(sub, null, null);

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

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

lock (this) {

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

}

}

public int find(int @byte) => find(@byte, null, null);

public int find(int @byte, int start) => find(@byte, start, null);

public int find(int @byte, int? start, int? end) {

lock (this) {

return _bytes.IndexOfByte(@byte.ToByteChecked(), start ?? 0, end ?? _bytes.Count);

}

}

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

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

}

public int index([BytesConversion]IList<byte>/*!*/ sub) => index(sub, null, null);

public int index([BytesConversion]IList<byte>/*!*/ sub, int? start) => index(sub, start, null);

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

lock (this) {

int res = find(sub, start, end);

if (res == -1) {

throw PythonOps.ValueError("subsection not found");

}

return res;

}

}

public int index(int @byte) => index(@byte, null, null);

public int index(int @byte, int? start) => index(@byte, start, null);

public int index(int @byte, int? start, int? end) {

lock (this) {

int res = find(@byte.ToByteChecked(), start, end);

if (res == -1) {

throw PythonOps.ValueError("subsection not found");

}

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]PythonList/*!*/ 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, 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([BytesConversion]IList<byte> bytes) {

lock (this) {

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

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public static Bytes maketrans([BytesConversion]IList<byte> from, [BytesConversion]IList<byte> to)

=> Bytes.maketrans(from, to);

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] = new ByteArray(new List<byte>(sep));

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

}

}

return new PythonTuple(obj);

}

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

return partition(GetBytes(sep));

}

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

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) => rfind(sub, null, null);

public int rfind([BytesConversion]IList<byte>/*!*/ sub, int? start) => rfind(sub, start, null);

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

lock (this) {

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

}

}

public int rfind(int @byte) => rfind(@byte, null, null);

public int rfind(int @byte, int? start) => rfind(@byte, start, null);

public int rfind(int @byte, int? start, int? end) => rfind(new[] { @byte.ToByteChecked() }, start, end);

public int rindex([BytesConversion]IList<byte>/*!*/ sub) => rindex(sub, null, null);

public int rindex([BytesConversion]IList<byte>/*!*/ sub, int? start) => rindex(sub, start, null);

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

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

if (ret == -1) {

throw PythonOps.ValueError("subsection not found");

}

return ret;

}

public int rindex(int @byte) => rindex(@byte, null, null);

public int rindex(int @byte, int? start) => rindex(@byte, start, null);

public int rindex(int @byte, int? start, int? end) => rindex(new[] { @byte.ToByteChecked() }, start, end);

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

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

}

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]PythonList/*!*/ sep) {

return rpartition(GetBytes(sep));

}

public PythonList/*!*/ rsplit() {

lock (this) {

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

}

}

public PythonList/*!*/ rsplit([BytesConversion]IList<byte>/*!*/ sep) {

return rsplit(sep, -1);

}

public PythonList/*!*/ rsplit([BytesConversion]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([BytesConversion]IList<byte> bytes) {

lock (this) {

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

if (res == null) {

return CopyThis();

}

return new ByteArray(res);

}

}

public PythonList/*!*/ split() {

lock (this) {

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

}

}

public PythonList/*!*/ split([BytesConversion]IList<byte> sep) {

return split(sep, -1);

}

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

lock (this) {

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

}

}

public PythonList/*!*/ splitlines() {

return splitlines(false);

}

public PythonList/*!*/ 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) {