public ReadOnlyBytes(ReadOnlyBuffer <byte> first, IReadOnlyBufferList <byte> rest, int length)
{
Debug.Assert(rest != null || length <= first.Length);
_rest = rest;
_first = first;
_totalLength = length;
}
public static int IndexOf(this IReadOnlyBufferList <byte> sequence, byte value)
{
var first = sequence.First.Span;
var index = first.IndexOf(value);
if (index != -1)
{
return(index);
}
var rest = sequence.Rest;
if (rest == null)
{
return(-1);
}
index = rest.IndexOf(value);
if (index != -1)
{
return(first.Length + index);
}
return(-1);
}
private ReadOnlyBytes(ReadOnlyMemory <byte> first, IReadOnlyBufferList <byte> all, long length)
{
// TODO: add assert that first overlaps all (once we have Overlap on Span)
_first = first;
_all = all;
_totalLength = length;
}
public static int IndexOf(this IReadOnlyBufferList <byte> sequence, ReadOnlySpan <byte> value)
{
var first = sequence.First.Span;
var index = first.IndexOf(value);
if (index != -1)
{
return(index);
}
var rest = sequence.Rest;
if (rest == null)
{
return(-1);
}
return(IndexOfStraddling(first, sequence.Rest, value));
}
int IndexOf(IReadOnlyBufferList <byte> sequence, byte value)
{
if (sequence == null)
{
return(-1);
}
var first = sequence.First;
var index = first.Span.IndexOf(value);
if (index > -1)
{
return(index);
}
var indexOfRest = IndexOf(sequence.Rest, value);
if (indexOfRest < 0)
{
return(-1);
}
return(first.Length + indexOfRest);
}
// TODO (pri 3): I am pretty sure this whole routine can be written much better
// searches values that potentially straddle between first and rest
internal static int IndexOfStraddling(this ReadOnlySpan <byte> first, IReadOnlyBufferList <byte> rest, ReadOnlySpan <byte> value)
{
Debug.Assert(first.IndexOf(value) == -1);
if (rest == null)
{
return(-1);
}
// we only need to search the end of the first buffer. More precisely, only up to value.Length - 1 bytes in the first buffer
// The other bytes in first, were already search and presumably did not match
int bytesToSkipFromFirst = 0;
if (first.Length > value.Length - 1)
{
bytesToSkipFromFirst = first.Length - value.Length - 1;
}
// now that we know how many bytes we need to skip, create slice of first buffer with bytes that need to be searched.
ReadOnlySpan <byte> bytesToSearchAgain;
if (bytesToSkipFromFirst > 0)
{
bytesToSearchAgain = first.Slice(bytesToSkipFromFirst);
}
else
{
bytesToSearchAgain = first;
}
int index;
// now combine the bytes from the end of the first buffer with bytes in the rest, and serarch the combined buffer
// this check is a small optimization: if the first byte from the value does not exist in the bytesToSearchAgain, there is no reason to combine
if (bytesToSearchAgain.IndexOf(value[0]) != -1)
{
var combinedBufferLength = value.Length << 1;
var combined = combinedBufferLength < 128 ?
stackalloc byte[combinedBufferLength] :
// TODO (pri 3): I think this could be eliminated by chunking values
new byte[combinedBufferLength];
bytesToSearchAgain.CopyTo(combined);
int combinedLength = bytesToSearchAgain.Length + rest.CopyTo(combined.Slice(bytesToSearchAgain.Length));
combined = combined.Slice(0, combinedLength);
if (combined.Length < value.Length)
{
return(-1);
}
index = combined.IndexOf(value);
if (index != -1)
{
return(index + bytesToSkipFromFirst);
}
}
// try to find the bytes in _rest
index = rest.IndexOf(value);
if (index != -1)
{
return(first.Length + index);
}
return(-1);
}
private static unsafe void ReadNextTwoChars(byte *pBuffer, int remaining, int index, out int ch1, out int ch2, IReadOnlyBufferList <byte> rest)
{
if (remaining == 1)
{
ch1 = pBuffer[index];
if (rest == null)
{
ch2 = -1;
}
else
{
ch2 = rest.First.Span[0];
}
}
else
{
ch1 = -1;
ch2 = -1;
if (rest != null)
{
var nextSpan = rest.First.Span;
if (nextSpan.Length > 0)
{
ch1 = nextSpan[0];
if (nextSpan.Length > 1)
{
ch2 = nextSpan[1];
}
else
{
ch2 = -1;
}
}
else
{
ch2 = -1;
}
}
}
}
public BytesReader(IReadOnlyBufferList <byte> bytes, SymbolTable encoder) : this(new ReadOnlyBytes(bytes))
{
}
public BytesReader(IReadOnlyBufferList <byte> bytes) : this(bytes, SymbolTable.InvariantUtf8)
{
}
public ReadOnlyBytes(IReadOnlyBufferList <byte> segments) :
this(segments.First, segments.Rest, Unspecified)
{
}
public ReadOnlyBytes(IReadOnlyBufferList <byte> segments, int length) :
this(segments.First, segments.Rest, length)
{
}
public ReadOnlyBytes(ReadOnlyBuffer <byte> first, IReadOnlyBufferList <byte> rest) :
this(first, rest, rest == null?first.Length:Unspecified)
{
}
public ReadOnlyBytes(IReadOnlyBufferList <byte> segments, long length)
{
_first = segments.First;
_all = segments;
_totalLength = length;
}
public ReadOnlyBytes(ReadOnlyMemory <byte> buffer)
{
_first = buffer;
_all = null;
_totalLength = _first.Length;
}
public BytesReader(IReadOnlyBufferList <byte> bytes, TextEncoder encoder) : this(new ReadOnlyBytes(bytes))
{
}
public BytesReader(IReadOnlyBufferList <byte> bytes) : this(bytes, TextEncoder.Utf8)
{
}
