/// <summary> /// Resets the Buffer Writer, returning its buffers to the pool /// </summary> /// <remarks>The Buffer Writer can be reused after disposal</remarks> public void Reset(bool clearBuffers) { ReadOnlySequenceSegment <T>?Segment = _HeadSegment; while (Segment != null) { if (MemoryMarshal.TryGetArray(Segment.Memory, out var MyBuffer)) { _Pool.Return(MyBuffer.Array !, clearBuffers); } Segment = Segment.Next; } if (!_CurrentBuffer.IsEmpty) { if (MemoryMarshal.TryGetArray <T>(_CurrentBuffer, out var MyBuffer)) { _Pool.Return(MyBuffer.Array !, clearBuffers); } } _CurrentBuffer = Memory <T> .Empty; _CurrentOffset = 0; _TailSegment = _HeadSegment = null; }
public ReadWriteBytes(ReadOnlySequenceSegment <byte> first, ReadOnlySequenceSegment <byte> last) { _start = first; _startIndex = 0; _end = last; _endIndex = last.Memory.Length; Validate(); }
/// <summary> /// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="ReadOnlyMemory{T}"/>. /// Consumer is expected to manage lifetime of memory until <see cref="ReadOnlySequence{T}"/> is not used anymore. /// </summary> public ReadOnlySequence(ReadOnlyMemory <T> readOnlyMemory) { ReadOnlySequenceSegment segment = new ReadOnlySequenceSegment { Memory = MemoryMarshal.AsMemory(readOnlyMemory) }; _sequenceStart = new SequencePosition(segment, 0 | MemoryListStartMask); _sequenceEnd = new SequencePosition(segment, readOnlyMemory.Length | MemoryListEndMask); }
public static SequencePosition?PositionOf(this ReadOnlySequenceSegment <byte> list, byte value) { while (list != null) { var current = list.Memory.Span; var index = current.IndexOf(value); if (index != -1) { return(new SequencePosition(list, index)); } list = list.Next; } return(null); }
static internal void GetFirstSpan <T>(this ReadOnlySequence <T> sequence, out ReadOnlySpan <T> first, out SequencePosition next) { first = default; next = default; SequencePosition start = sequence.Start; int startIndex = start.GetInteger(); object startObject = start.GetObject(); if (startObject != null) { SequencePosition end = sequence.End; int endIndex = end.GetInteger(); bool hasMultipleSegments = startObject != end.GetObject(); if (startIndex >= 0) { if (endIndex >= 0) { // Positive start and end index == ReadOnlySequenceSegment<T> ReadOnlySequenceSegment <T> segment = (ReadOnlySequenceSegment <T>)startObject; next = new SequencePosition(segment.Next, 0); first = segment.Memory.Span; if (hasMultipleSegments) { first = first.Slice(startIndex); } else { first = first.Slice(startIndex, endIndex - startIndex); } } else { // Positive start and negative end index == T[] if (hasMultipleSegments) { ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached(); } first = new ReadOnlySpan <T>((T[])startObject, startIndex, (endIndex & ReadOnlySequence.IndexBitMask) - startIndex); } } else { first = GetFirstSpanSlow <T>(startObject, startIndex, endIndex, hasMultipleSegments); } } }
public static long IndexOf(this ReadOnlySequenceSegment <byte> list, ReadOnlySpan <byte> value) { var first = list.Memory.Span; var index = first.IndexOf(value); if (index != -1) { return(index); } var rest = list.Next; if (rest == null) { return(-1); } return(IndexOfStraddling(first, list.Next, value)); }
public override void CopyTo(Span <T> destination) { var dest = destination; ReadOnlySequenceSegment <T> segment = _start; while (segment.Next != null) { var memory = segment.Memory; memory.Span.CopyTo(dest); dest = dest.Slice(memory.Length); segment = segment.Next; } var temp = _array.Length - _available; Debug.Assert(dest.Length == temp); if (temp > 0) { _array.AsSpan(0, temp).CopyTo(dest); } }
public static int CopyTo(this ReadOnlySequenceSegment <byte> list, Span <byte> destination) { var current = list.Memory.Span; int copied = 0; while (destination.Length > 0) { if (current.Length >= destination.Length) { current.Slice(0, destination.Length).CopyTo(destination); copied += destination.Length; return(copied); } else { current.CopyTo(destination); copied += current.Length; destination = destination.Slice(current.Length); } } return(copied); }
public void SetNext(ReadOnlySequenceSegment <T> next) => Next = next;