public static bool TryParse(ReadOnlySequence <byte> sequence, out int value, out int consumed)
{
var position = sequence.Start;
if (sequence.TryGet(ref position, out ReadOnlyMemory <byte> memory))
{
var span = memory.Span;
if (Utf8Parser.TryParse(span, out value, out consumed) && consumed < span.Length)
{
return(true);
}
Span <byte> temp = stackalloc byte[11]; // TODO: it would be good to have APIs to return constants related to sizes of needed buffers
var copied = Copy(sequence, temp);
// we need to slice temp, as we might stop zeroing stack allocated buffers
if (Utf8Parser.TryParse(temp.Slice(0, copied), out value, out consumed))
{
return(true);
}
}
value = default;
consumed = default;
return(false);
}
/// <summary>
/// Moves to the next <see cref="ReadOnlyMemory{T}"/> in the <see cref="ReadOnlySequence{T}"/>
/// </summary>
/// <returns></returns>
public bool MoveNext()
{
if (_next.Segment == null)
{
return(false);
}
return(_sequence.TryGet(ref _next, out _currentMemory));
}
public static ReadOnlySpan <byte> ToSpan(this ReadOnlySequence <byte> sequence)
{
SequencePosition position = sequence.Start;
ResizableArray <byte> array = new ResizableArray <byte>(1024);
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> buffer))
{
array.AddAll(buffer.Span);
}
return(array.Span);
}
public static ReadOnlySpan <byte> ToSpan(this ReadOnlySequence <byte> sequence)
{
SequencePosition position = sequence.Start;
int capacity = 0;
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> buffer))
{
capacity += buffer.Length;
}
position = sequence.Start;
var count = 0;
byte[] array = new byte[capacity];
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> buffer))
{
buffer.Span.CopyTo(array.AsSpan(count));
count += buffer.Length;
}
return(array.AsSpan());
}
// TODO: this cannot be an extension method (as I would like it to be).
// If I make it an extensions method, the compiler complains Span<T> cannot
// be used as a type parameter.
public static long IndexOf(ReadOnlySequence <byte> sequence, byte value)
{
SequencePosition position = sequence.Start;
int totalIndex = 0;
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> memory))
{
var index = memory.Span.IndexOf(value);
if (index != -1)
{
return(index + totalIndex);
}
totalIndex += memory.Length;
}
return(-1);
}
public static SequencePosition?PositionOf(this ReadOnlySequence <byte> sequence, byte value)
{
SequencePosition position = sequence.Start;
SequencePosition result = position;
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> memory))
{
var index = MemoryExtensions.IndexOf(memory.Span, value);
if (index != -1)
{
result = sequence.GetPosition(index, result);
return(result);
}
result = position;
}
return(null);
}
public static int Copy(ReadOnlySequence <byte> sequence, SequencePosition from, Span <byte> buffer)
{
int copied = 0;
while (sequence.TryGet(ref from, out ReadOnlyMemory <byte> memory, true))
{
var span = memory.Span;
var toCopy = Math.Min(span.Length, buffer.Length - copied);
span.Slice(0, toCopy).CopyTo(buffer.Slice(copied));
copied += toCopy;
if (copied >= buffer.Length)
{
break;
}
}
return(copied);
}
public static SequencePosition?PositionAt(this ReadOnlySequence <byte> sequence, long index)
{
SequencePosition position = sequence.Start;
SequencePosition result = position;
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> memory))
{
var span = memory.Span;
if (span.Length > index)
{
result = sequence.GetPosition(index, result);
return(result);
}
index -= span.Length;
result = position;
}
return(null);
}
public static long IndexOf(ReadOnlySequence <byte> sequence, byte v1, byte v2)
{
SequencePosition position = sequence.Start;
int totalIndex = 0;
while (sequence.TryGet(ref position, out ReadOnlyMemory <byte> memory))
{
var span = memory.Span;
var index = span.IndexOf(v1);
if (index != -1)
{
if (span.Length > index + 1)
{
if (span[index + 1] == v2)
{
return(index + totalIndex);
}
else
{
throw new NotImplementedException(); // need to check farther in the span
}
}
else
{
if (sequence.TryGet(ref position, out var next, false))
{
var nextSpan = next.Span;
if (nextSpan.Length > 0)
{
if (next.Span[0] == v2)
{
return(totalIndex + index);
}
}
}
}
}
totalIndex += memory.Length;
}
return(-1);
}
