// _bytes is readonly to ensure proper size locking during buffer exports

private readonly ArrayData<byte> _bytes;

public ByteArray() {

_bytes = new ArrayData<byte>(0);

}

private ByteArray(ArrayData<byte> bytes) {

_bytes = bytes;

}

private ByteArray(ReadOnlySpan<byte> bytes) {

_bytes = new ArrayData<byte>(bytes);

}

internal ByteArray(IEnumerable<byte> bytes) {

_bytes = new ArrayData<byte>(bytes);

}

public void __init__() {

lock (this) {

_bytes.Clear();

}

}

public void __init__(int source) {

lock (this) {

if (source < 0) throw PythonOps.ValueError("negative count");

_bytes.Clear();

if (source > 0) {

_bytes.Add(0);

_bytes.InPlaceMultiply(source);

}

}

}

public void __init__([NotNone] IBufferProtocol source) {

if (Converter.TryConvertToIndex(source, out int size, throwNonInt: false)) {

__init__(size);

} else {

lock (this) {

_bytes.Clear();

using IPythonBuffer buffer = source.GetBuffer(BufferFlags.FullRO);

_bytes.AddRange(buffer);

}

}

}

public void __init__(CodeContext context, object? source) {

if (Converter.TryConvertToIndex(source, out int size, throwNonInt: false)) {

__init__(size);

} else if (source is IEnumerable<byte> en) {

lock (this) {

_bytes.Clear();

_bytes.AddRange(en);

}

} else {

lock (this) {

_bytes.Clear();

}

IEnumerator ie = PythonOps.GetEnumerator(context, source);

while (ie.MoveNext()) {

Add(ByteOps.GetByte(ie.Current));

}

}

}

public void __init__([NotNone] string @string) {

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

}

public void __init__(CodeContext context, [NotNone] string source, [NotNone] string encoding, [NotNone] string errors = "strict") {

lock (this) {

_bytes.Clear();

_bytes.AddRange(StringOps.encode(context, source, encoding, errors));

}

}

[PythonHidden]

internal ArrayData<byte> UnsafeByteList {

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(ByteOps.GetByte(item));

}

}

public void extend([NotNone] 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(CodeContext context, 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.

extend(ByteOps.GetBytes(seq, useHint: true, context));

}

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(ByteOps.GetByte(value));

}

}

public void reverse() {

lock (this) {

_bytes.Reverse();

}

}

[SpecialName]

public ByteArray InPlaceAdd([NotNone] ByteArray other) {

using (new OrderedLocker(this, other)) {

_bytes.AddRange(other._bytes);

return this;

}

}

[SpecialName]

public ByteArray InPlaceAdd([NotNone] IBufferProtocol other) {

lock (this) {

using var buf = other.GetBufferNoThrow();

if (buf is null) throw TypeErrorForConcat(this, other);

_bytes.AddRange(buf);

return this;

}

}

[SpecialName]

public ByteArray InPlaceMultiply(int len) {

lock (this) {

_bytes.InPlaceMultiply(len);

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, [BytesLike, NotNone] IList<byte> fillchar)

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

private ByteArray center(int width, byte fillchar) {

lock (this) {

var res = _bytes.TryCenter(width, fillchar);

return res == null ? CopyThis() : new ByteArray(res);

}

}

public void clear() => Clear();

public ByteArray copy() => CopyThis();

public int count([BytesLike, NotNone] IList<byte> sub) {

lock (this) {

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

}

}

public int count([BytesLike, NotNone] IList<byte> sub, int start) {

lock (this) {

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

}

}

public int count([BytesLike, NotNone] IList<byte> sub, int start, int end) {

lock (this) {

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

}

}

public int count([BytesLike, NotNone] IList<byte> sub, object? start)

=> count(sub, start, null);

public int count([BytesLike, NotNone] IList<byte> sub, object? start, object? end) {

int istart = start != null ? Converter.ConvertToIndex(start) : 0;

lock (this) {

int iend = end != null ? Converter.ConvertToIndex(end) : _bytes.Count;

return _bytes.CountOf(sub, istart, iend);

}

}

public int count(BigInteger @byte)

=> count(Bytes.FromByte(@byte.ToByteChecked()));

public int count(BigInteger @byte, int start)

=> count(Bytes.FromByte(@byte.ToByteChecked()), start);

public int count(BigInteger @byte, int start, int end)

=> count(Bytes.FromByte(@byte.ToByteChecked()), start, end);

public int count(BigInteger @byte, object? start)

=> count(Bytes.FromByte(@byte.ToByteChecked()), start);

public int count(BigInteger @byte, object? start, object? end)

=> count(Bytes.FromByte(@byte.ToByteChecked()), start, end);

public string decode(CodeContext context, [NotNone] string encoding = "utf-8", [NotNone] string errors = "strict") {

lock (this) {

using var mv = new MemoryView(this, readOnly: true);

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

}

}

public string decode(CodeContext context, [NotNone] Encoding encoding, [NotNone] string errors = "strict") {

lock (this) {

using var bufer = ((IBufferProtocol)this).GetBuffer();

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

}

}

public bool endswith([BytesLike, NotNone] IList<byte> suffix) {

lock (this) {

return _bytes.EndsWith(suffix);

}

}

public bool endswith([BytesLike, NotNone] IList<byte> suffix, int start) {

lock (this) {

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

}

}

public bool endswith([BytesLike, NotNone] IList<byte> suffix, int start, int end) {

lock (this) {

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

}

}

public bool endswith([BytesLike, NotNone] IList<byte> suffix, object? start) {

return endswith(suffix, start, null);

}

public bool endswith([BytesLike, NotNone] IList<byte> suffix, object? start, object? end) {

int istart = start != null ? Converter.ConvertToIndex(start) : 0;

lock (this) {

int iend = end != null ? Converter.ConvertToIndex(end) : _bytes.Count;

return _bytes.EndsWith(suffix, istart, iend);

}

}

public bool endswith([NotNone] PythonTuple suffix) {

lock (this) {

return _bytes.EndsWith(suffix);

}

}

public bool endswith([NotNone] PythonTuple suffix, int start) {

lock (this) {

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

}

}

public bool endswith([NotNone] PythonTuple suffix, int start, int end) {

lock (this) {

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

}

}

public bool endswith([NotNone] PythonTuple suffix, object? start) {

return endswith(suffix, start, null);

}

public bool endswith([NotNone] PythonTuple suffix, object? start, object? end) {

int istart = start != null ? Converter.ConvertToIndex(start) : 0;

lock (this) {

int iend = end != null ? Converter.ConvertToIndex(end) : _bytes.Count;

return _bytes.EndsWith(suffix, istart, iend);

}

}

[Documentation("\n" + // hidden overload

"Return True if self ends with the specified suffix, False otherwise.\n" +

"With optional start, test self beginning at that position.\n" +

"With optional end, stop comparing self at that position.\n" +

"suffix can also be a tuple of bytes-like objects to try.")]

public bool endswith(object? suffix, object? start = null, object? end = null) {

if (suffix is IList<byte> blist) return endswith(blist, start, end);

if (suffix is PythonTuple tuple) return endswith(tuple, start, end);

throw PythonOps.TypeError("{0} first arg must be a bytes-like object or a tuple of bytes-like objects, not {1}", nameof(endswith), PythonOps.GetPythonTypeName(suffix));

}

public ByteArray expandtabs() {

return expandtabs(8);

}

public ByteArray expandtabs(int tabsize) {

lock (this) {

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

}

}

public int find([BytesLike, NotNone] IList<byte> sub) {

lock (this) {

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

}

}

public int find([BytesLike, NotNone] IList<byte> sub, int start) {

lock (this) {

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

}

}

public int find([BytesLike, NotNone] IList<byte> sub, int start, int end) {

lock (this) {

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

}

}

public int find([BytesLike, NotNone] IList<byte> sub, object? start)

=> find(sub, start, null);

public int find([BytesLike, NotNone] IList<byte> sub, object? start, object? end) {

int istart = start != null ? Converter.ConvertToIndex(start) : 0;

lock (this) {

int iend = end != null ? Converter.ConvertToIndex(end) : _bytes.Count;

return _bytes.Find(sub, istart, iend);

}

}

public int find(BigInteger @byte) {

lock (this) {

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

}

}

public int find(BigInteger @byte, int start) {

lock (this) {

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

}

}

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

lock (this) {

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

}

}

public int find(BigInteger @byte, object? start)

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

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

int istart = start != null ? Converter.ConvertToIndex(start) : 0;

lock (this) {

int iend = end != null ? Converter.ConvertToIndex(end) : _bytes.Count;

return _bytes.IndexOfByte(@byte.ToByteChecked(), istart, iend);

}

}

public static ByteArray fromhex([NotNone] string @string) {

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

}

public string hex() => Bytes.ToHex(_bytes.AsByteSpan()); // new in CPython 3.5

public int index([BytesLike, NotNone] IList<byte> sub) {

lock (this) {

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

}

}

public int index([BytesLike, NotNone] IList<byte> sub, int start) {

lock (this) {

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

}

}

public int index([BytesLike, NotNone] 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([BytesLike, NotNone] IList<byte> sub, object? start)

=> index(sub, start, null);

public int index([BytesLike, NotNone] IList<byte> sub, object? start, object? end) {

int istart = start != null ? Converter.ConvertToIndex(start) : 0;

lock (this) {

int iend = end != null ? Converter.ConvertToIndex(end) : _bytes.Count;

return index(sub, istart, iend);

}

}

public int index(BigInteger @byte)

=> index(Bytes.FromByte(@byte.ToByteChecked()));

public int index(BigInteger @byte, int start)

=> index(Bytes.FromByte(@byte.ToByteChecked()), start);

public int index(BigInteger @byte, int start, int end)

=> index(Bytes.FromByte(@byte.ToByteChecked()), start, end);

public int index(BigInteger @byte, object? start)

=> index(Bytes.FromByte(@byte.ToByteChecked()), start, null);

public int index(BigInteger @byte, object? start, object? end)

=> index(Bytes.FromByte(@byte.ToByteChecked()), start, end);

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([NotNone] 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, [BytesLike, NotNone] IList<byte> fillchar) {

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

}

private ByteArray ljust(int width, byte fillchar) {

lock (this) {

int spaces = width - _bytes.Count;

if (spaces <= 0) {

return CopyThis();

}

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

var res = _bytes.LeftStrip();

return res == null ? CopyThis() : new ByteArray(res);

}

}

public ByteArray lstrip([BytesLike]IList<byte>? chars) {

if (chars == null) return lstrip();

lock (this) {

var res = _bytes.LeftStrip(chars);

return res == null ? CopyThis() : new ByteArray(res);

}

}

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

=> Bytes.maketrans(from, to);

[return: SequenceTypeInfo(typeof(ByteArray))]

public PythonTuple partition([BytesLike, NotNone] IList<byte> sep) {

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 PythonTuple.MakeTuple(obj);

}

public ByteArray replace([BytesLike, NotNone] IList<byte> old, [BytesLike, NotNone] IList<byte> @new)

=> replace(old, @new, -1);

public ByteArray replace([BytesLike, NotNone] IList<byte> old, [BytesLike, NotNone] IList<byte> @new, int count) {

if (count == 0) {

return CopyThis();

}

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

}

public int rfind([BytesLike, NotNone] IList<byte> sub) {

lock (this) {

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

}

}

public int rfind([BytesLike, NotNone] IList<byte> sub, int start) {