Summary

Class:	System.Buffers.ReadOnlySequence`1
Assembly:	System.Memory
File(s):	C:\GitHub\corefx\src\System.Memory\src\System\Buffers\ReadOnlySequence.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\ReadOnlySequence_helpers.cs
Covered lines:	455
Uncovered lines:	33
Coverable lines:	488
Total lines:	953
Line coverage:	93.2%
Branch coverage:	86.8%

Metrics

Method	Cyclomatic complexity	NPath complexity	Sequence coverage	Branch coverage
.ctor(...)	1	0	100	100
.ctor(...)	8	2	100	100
.ctor(...)	2	2	83.33	66.67
.ctor(...)	4	2	100	100
.ctor(...)	5	16	61.54	66.67
.ctor(...)	2	2	83.33	66.67
.ctor(...)	4	2	100	100
Slice(...)	1	0	100	100
Slice(...)	2	2	100	100
Slice(...)	1	0	100	100
Slice(...)	1	0	100	100
Slice(...)	2	2	100	100
Slice(...)	1	0	100	100
Slice(...)	1	0	100	100
Slice(...)	1	0	100	100
Slice(...)	2	2	100	100
ToString()	1	0	100	100
GetEnumerator()	1	0	100	100
GetPosition(...)	1	0	100	100
GetPosition(...)	2	2	100	100
TryGet(...)	2	2	100	66.67
SliceImpl(...)	1	0	100	100
GetTypeAndIndices(...)	2	0	100	100
.cctor()	1	0	100	100
.ctor(...)	1	0	100	100
MoveNext()	2	2	100	100
TryGetBuffer(...)	11	128	72.34	73.33
GetFirstBuffer(...)	11	128	86.36	80
GetBufferCrossSegment(...)	9	32	96.15	90.91
Seek(...)	5	8	100	100
Seek(...)	5	8	100	100
SeekMultiSegment(...)	8	16	100	100
CheckEndReachable(...)	3	4	92.86	80
GetLength(...)	3	2	100	100
BoundsCheck(...)	5	8	100	100
TryGetReadOnlySequenceSegment(...)	2	2	100	100
TryGetArray(...)	2	2	100	100
TryGetOwnedMemory(...)	2	2	100	100
TryGetReadOnlyMemory(...)	6	16	100	100

File(s)

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\ReadOnlySequence.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7		using System.Runtime.InteropServices;
		8
		9		namespace System.Buffers
		10		{
		11		/// <summary>
		12		/// Represents a sequence that can read a sequential series of <typeparam name="T" />.
		13		/// </summary>
		14		public readonly partial struct ReadOnlySequence<T>
		15		{
		16		private readonly SequencePosition _sequenceStart;
		17		private readonly SequencePosition _sequenceEnd;
		18
		19		/// <summary>
		20		/// Returns empty <see cref="ReadOnlySequence{T}"/>
		21		/// </summary>
		22		#if FEATURE_PORTABLE_SPAN
		23		public static readonly ReadOnlySequence<T> Empty = new ReadOnlySequence<T>(SpanHelpers.PerTypeValues<T>.EmptyArr
		24		#else
	1	25		public static readonly ReadOnlySequence<T> Empty = new ReadOnlySequence<T>(Array.Empty<T>());
		26		#endif // FEATURE_PORTABLE_SPAN
		27		/// <summary>
		28		/// Length of the <see cref="ReadOnlySequence{T}"/>.
		29		/// </summary>
	1	30		public long Length => GetLength(_sequenceStart, _sequenceEnd);
		31
		32		/// <summary>
		33		/// Determines if the <see cref="ReadOnlySequence{T}"/> is empty.
		34		/// </summary>
	1	35		public bool IsEmpty => Length == 0;
		36
		37		/// <summary>
		38		/// Determines if the <see cref="ReadOnlySequence{T}"/> contains a single <see cref="ReadOnlyMemory{T}"/> segmen
		39		/// </summary>
		40		public bool IsSingleSegment
		41		{
		42		[MethodImpl(MethodImplOptions.AggressiveInlining)]
	1	43		get => _sequenceStart.GetObject() == _sequenceEnd.GetObject();
		44		}
		45
		46		/// <summary>
		47		/// Gets <see cref="ReadOnlyMemory{T}"/> from the first segment.
		48		/// </summary>
	1	49		public ReadOnlyMemory<T> First => GetFirstBuffer(_sequenceStart, _sequenceEnd);
		50
		51		/// <summary>
		52		/// A position to the start of the <see cref="ReadOnlySequence{T}"/>.
		53		/// </summary>
	1	54		public SequencePosition Start => _sequenceStart;
		55
		56		/// <summary>
		57		/// A position to the end of the <see cref="ReadOnlySequence{T}"/>
		58		/// </summary>
	1	59		public SequencePosition End => _sequenceEnd;
		60
		61		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		62		private ReadOnlySequence(object startSegment, int startIndexAndFlags, object endSegment, int endIndexAndFlags)
	1	63		{
		64		// Used by SliceImpl to create new ReadOnlySequence
	1	65		Debug.Assert(startSegment != null);
	1	66		Debug.Assert(endSegment != null);
		67
	1	68		_sequenceStart = new SequencePosition(startSegment, startIndexAndFlags);
	1	69		_sequenceEnd = new SequencePosition(endSegment, endIndexAndFlags);
	1	70		}
		71
		72		/// <summary>
		73		/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from linked memory list represented by start and en
		74		/// and corresponding indexes in them.
		75		/// </summary>
		76		public ReadOnlySequence(ReadOnlySequenceSegment<T> startSegment, int startIndex, ReadOnlySequenceSegment<T> endS
	1	77		{
	1	78		if (startSegment == null ||
	1	79		endSegment == null ||
	1	80		(uint)startSegment.Memory.Length < (uint)startIndex ||
	1	81		(uint)endSegment.Memory.Length < (uint)endIndex ||
	1	82		(startSegment == endSegment && endIndex < startIndex))
	1	83		ThrowHelper.ThrowArgumentValidationException(startSegment, startIndex, endSegment);
		84
	1	85		_sequenceStart = new SequencePosition(startSegment, ReadOnlySequence.SegmentToSequenceStart(startIndex));
	1	86		_sequenceEnd = new SequencePosition(endSegment, ReadOnlySequence.SegmentToSequenceEnd(endIndex));
	1	87		}
		88
		89		/// <summary>
		90		/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="T:T[]"/>.
		91		/// </summary>
		92		public ReadOnlySequence(T[] array)
	1	93		{
	1	94		if (array == null)
	0	95		ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
		96
	1	97		_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(0));
	1	98		_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(array.Length));
	1	99		}
		100
		101		/// <summary>
		102		/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="T:T[]"/>, start and index.
		103		/// </summary>
		104		public ReadOnlySequence(T[] array, int start, int length)
	1	105		{
	1	106		if (array == null ||
	1	107		(uint)start > (uint)array.Length ||
	1	108		(uint)length > (uint)(array.Length - start))
	1	109		ThrowHelper.ThrowArgumentValidationException(array, start);
		110
	1	111		_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(start));
	1	112		_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(start + length));
	1	113		}
		114
		115		/// <summary>
		116		/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="ReadOnlyMemory{T}"/>.
		117		/// Consumer is expected to manage lifetime of memory until <see cref="ReadOnlySequence{T}"/> is not used anymor
		118		/// </summary>
		119		public ReadOnlySequence(ReadOnlyMemory<T> readOnlyMemory)
	1	120		{
	1	121		if (MemoryMarshal.TryGetOwnedMemory(readOnlyMemory, out OwnedMemory<T> ownedMemory, out int index, out int l
	0	122		{
	0	123		_sequenceStart = new SequencePosition(ownedMemory, ReadOnlySequence.OwnedMemoryToSequenceStart(index));
	0	124		_sequenceEnd = new SequencePosition(ownedMemory, ReadOnlySequence.OwnedMemoryToSequenceEnd(length));
	0	125		}
	1	126		else if (MemoryMarshal.TryGetArray(readOnlyMemory, out ArraySegment<T> arraySegment))
	1	127		{
	1	128		T[] array = arraySegment.Array;
	1	129		int start = arraySegment.Offset;
	1	130		_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(start));
	1	131		_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(start + arraySegment.Coun
	1	132		}
	1	133		else if (typeof(T) == typeof(char))
	1	134		{
	1	135		if (!MemoryMarshal.TryGetString(((ReadOnlyMemory<char>)(object)readOnlyMemory), out string text, out int
	0	136		ThrowHelper.ThrowInvalidOperationException();
		137
	1	138		_sequenceStart = new SequencePosition(text, ReadOnlySequence.StringToSequenceStart(start));
	1	139		_sequenceEnd = new SequencePosition(text, ReadOnlySequence.StringToSequenceEnd(start + length));
	1	140		}
		141		else
	0	142		{
		143		// Should never be reached
	0	144		ThrowHelper.ThrowInvalidOperationException();
	0	145		_sequenceStart = default;
	0	146		_sequenceEnd = default;
	0	147		}
	1	148		}
		149
		150		/// <summary>
		151		/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="OwnedMemory{T}"/>.
		152		/// Consumer is expected to manage lifetime of memory until <see cref="ReadOnlySequence{T}"/> is not used anymor
		153		/// </summary>
		154		public ReadOnlySequence(OwnedMemory<T> ownedMemory)
	1	155		{
	1	156		if (ownedMemory == null)
	0	157		ThrowHelper.ThrowArgumentNullException(ExceptionArgument.ownedMemory);
		158
	1	159		_sequenceStart = new SequencePosition(ownedMemory, ReadOnlySequence.OwnedMemoryToSequenceStart(0));
	1	160		_sequenceEnd = new SequencePosition(ownedMemory, ReadOnlySequence.OwnedMemoryToSequenceEnd(ownedMemory.Lengt
	1	161		}
		162
		163		/// <summary>
		164		/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="OwnedMemory{T}"/>, start and le
		165		/// Consumer is expected to manage lifetime of memory until <see cref="ReadOnlySequence{T}"/> is not used anymor
		166		/// </summary>
		167		public ReadOnlySequence(OwnedMemory<T> ownedMemory, int start, int length)
	1	168		{
	1	169		if (ownedMemory == null ||
	1	170		(uint)start > (uint)ownedMemory.Length ||
	1	171		(uint)length > (uint)(ownedMemory.Length - start))
	1	172		ThrowHelper.ThrowArgumentValidationException(ownedMemory, start);
		173
	1	174		_sequenceStart = new SequencePosition(ownedMemory, ReadOnlySequence.OwnedMemoryToSequenceStart(start));
	1	175		_sequenceEnd = new SequencePosition(ownedMemory, ReadOnlySequence.OwnedMemoryToSequenceEnd(start + length));
	1	176		}
		177
		178		/// <summary>
		179		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, wit
		180		/// </summary>
		181		/// <param name="start">The index at which to begin this slice.</param>
		182		/// <param name="length">The length of the slice</param>
		183		public ReadOnlySequence<T> Slice(long start, long length)
	1	184		{
	1	185		SequencePosition begin = Seek(_sequenceStart, _sequenceEnd, start);
	2	186		SequencePosition end = Seek(begin, _sequenceEnd, length);
	1	187		return SliceImpl(begin, end);
	1	188		}
		189
		190		/// <summary>
		191		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, end
		192		/// </summary>
		193		/// <param name="start">The index at which to begin this slice.</param>
		194		/// <param name="end">The end (inclusive) of the slice</param>
		195		public ReadOnlySequence<T> Slice(long start, SequencePosition end)
	1	196		{
	1	197		BoundsCheck(end, _sequenceEnd);
		198
	1	199		SequencePosition begin = Seek(_sequenceStart, end, start);
	1	200		object beginObject = begin.GetObject();
	1	201		object endObject = end.GetObject();
	1	202		if (beginObject != endObject)
	1	203		{
	1	204		CheckEndReachable(beginObject, endObject);
	1	205		}
	1	206		return SliceImpl(begin, end);
	1	207		}
		208
		209		/// <summary>
		210		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, wit
		211		/// </summary>
		212		/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</p
		213		/// <param name="length">The length of the slice</param>
		214		public ReadOnlySequence<T> Slice(SequencePosition start, long length)
	1	215		{
	1	216		BoundsCheck(start, _sequenceEnd);
		217
	1	218		SequencePosition end = Seek(start, _sequenceEnd, length);
	1	219		return SliceImpl(start, end);
	1	220		}
		221
		222		/// <summary>
		223		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, wit
		224		/// </summary>
		225		/// <param name="start">The index at which to begin this slice.</param>
		226		/// <param name="length">The length of the slice</param>
		227		public ReadOnlySequence<T> Slice(int start, int length)
	1	228		{
	1	229		SequencePosition begin = Seek(_sequenceStart, _sequenceEnd, start);
	1	230		SequencePosition end = Seek(begin, _sequenceEnd, length);
	1	231		return SliceImpl(begin, end);
	1	232		}
		233
		234		/// <summary>
		235		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, end
		236		/// </summary>
		237		/// <param name="start">The index at which to begin this slice.</param>
		238		/// <param name="end">The end (inclusive) of the slice</param>
		239		public ReadOnlySequence<T> Slice(int start, SequencePosition end)
	1	240		{
	1	241		BoundsCheck(end, _sequenceEnd);
		242
	1	243		SequencePosition begin = Seek(_sequenceStart, end, start);
	1	244		object beginObject = begin.GetObject();
	1	245		object endObject = end.GetObject();
	1	246		if (beginObject != endObject)
	1	247		{
	1	248		CheckEndReachable(beginObject, endObject);
	1	249		}
	1	250		return SliceImpl(begin, end);
	1	251		}
		252
		253		/// <summary>
		254		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at '<paramref name="start"/>, wi
		255		/// </summary>
		256		/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</p
		257		/// <param name="length">The length of the slice</param>
		258		public ReadOnlySequence<T> Slice(SequencePosition start, int length)
	1	259		{
	1	260		BoundsCheck(start, _sequenceEnd);
		261
	1	262		SequencePosition end = Seek(start, _sequenceEnd, length);
	1	263		return SliceImpl(start, end);
	1	264		}
		265
		266		/// <summary>
		267		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, end
		268		/// </summary>
		269		/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</p
		270		/// <param name="end">The ending (inclusive) <see cref="SequencePosition"/> of the slice</param>
		271		public ReadOnlySequence<T> Slice(SequencePosition start, SequencePosition end)
	1	272		{
	1	273		BoundsCheck(end, _sequenceEnd);
	1	274		BoundsCheck(start, end);
		275
	1	276		return SliceImpl(start, end);
	1	277		}
		278
		279		/// <summary>
		280		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, end
		281		/// </summary>
		282		/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</p
		283		public ReadOnlySequence<T> Slice(SequencePosition start)
	1	284		{
	1	285		BoundsCheck(start, _sequenceEnd);
		286
	1	287		return SliceImpl(start, _sequenceEnd);
	1	288		}
		289
		290		/// <summary>
		291		/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, end
		292		/// </summary>
		293		/// <param name="start">The start index at which to begin this slice.</param>
		294		public ReadOnlySequence<T> Slice(long start)
	1	295		{
	1	296		if (start == 0)
	1	297		{
	1	298		return this;
		299		}
		300
	1	301		SequencePosition begin = Seek(_sequenceStart, _sequenceEnd, start);
	1	302		return SliceImpl(begin, _sequenceEnd);
	1	303		}
		304
		305		/// <inheritdoc />
	1	306		public override string ToString() => string.Format("System.Buffers.ReadOnlySequence<{0}>[{1}]", typeof(T).Name,
		307
		308		/// <summary>
		309		/// Returns an enumerator over the <see cref="ReadOnlySequence{T}"/>
		310		/// </summary>
	1	311		public Enumerator GetEnumerator() => new Enumerator(this);
		312
		313		/// <summary>
		314		/// Returns a new <see cref="SequencePosition"/> at an <paramref name="offset"/> from the start of the sequence.
		315		/// </summary>
	1	316		public SequencePosition GetPosition(long offset) => GetPosition(offset, _sequenceStart);
		317
		318		/// <summary>
		319		/// Returns a new <see cref="SequencePosition"/> at an <paramref name="offset"/> from the <paramref name="origin
		320		/// </summary>
		321		public SequencePosition GetPosition(long offset, SequencePosition origin)
	1	322		{
	1	323		if (offset < 0)
	1	324		ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.offset);
		325
	1	326		return Seek(origin, _sequenceEnd, offset);
	1	327		}
		328
		329		/// <summary>
		330		/// Tries to retrieve next segment after <paramref name="position"/> and return its contents in <paramref name="
		331		/// Returns <code>false</code> if end of <see cref="ReadOnlySequence{T}"/> was reached otherwise <code>true</cod
		332		/// Sets <paramref name="position"/> to the beginning of next segment if <paramref name="advance"/> is set to <c
		333		/// </summary>
		334		public bool TryGet(ref SequencePosition position, out ReadOnlyMemory<T> data, bool advance = true)
	1	335		{
	1	336		bool result = TryGetBuffer(position, End, out data, out SequencePosition next);
	1	337		if (advance)
	1	338		{
	1	339		position = next;
	1	340		}
		341
	1	342		return result;
	1	343		}
		344
		345		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		346		private ReadOnlySequence<T> SliceImpl(in SequencePosition begin, in SequencePosition end)
	1	347		{
		348		// In this method we reset high order bits from indices
		349		// of positions that were passed in
		350		// and apply type bits specific for current ReadOnlySequence type
		351
	1	352		return new ReadOnlySequence<T>(
	1	353		begin.GetObject(),
	1	354		begin.GetInteger() & ReadOnlySequence.IndexBitMask | (Start.GetInteger() & ReadOnlySequence.FlagBitMask)
	1	355		end.GetObject(),
	1	356		end.GetInteger() & ReadOnlySequence.IndexBitMask | (End.GetInteger() & ReadOnlySequence.FlagBitMask)
	1	357		);
	1	358		}
		359
		360		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		361		private void GetTypeAndIndices(int start, int end, out SequenceType sequenceType, out int startIndex, out int en
	1	362		{
	1	363		startIndex = start & ReadOnlySequence.IndexBitMask;
	1	364		endIndex = end & ReadOnlySequence.IndexBitMask;
		365		// We take high order bits of two indexes index and move them
		366		// to a first and second position to convert to BufferType
		367		// Masking with 2 is required to only keep the second bit of Start.GetInteger()
	1	368		sequenceType = Start.GetObject() == null ? SequenceType.Empty : (SequenceType)((((uint)Start.GetInteger() >>
	1	369		}
		370
		371		/// <summary>
		372		/// An enumerator over the <see cref="ReadOnlySequence{T}"/>
		373		/// </summary>
		374		public struct Enumerator
		375		{
		376		private readonly ReadOnlySequence<T> _sequence;
		377		private SequencePosition _next;
		378		private ReadOnlyMemory<T> _currentMemory;
		379
		380		/// <summary>Initialize the enumerator.</summary>
		381		/// <param name="sequence">The <see cref="ReadOnlySequence{T}"/> to enumerate.</param>
		382		public Enumerator(in ReadOnlySequence<T> sequence)
	1	383		{
	1	384		_currentMemory = default;
	1	385		_next = sequence.Start;
	1	386		_sequence = sequence;
	1	387		}
		388
		389		/// <summary>
		390		/// The current <see cref="ReadOnlyMemory{T}"/>
		391		/// </summary>
	1	392		public ReadOnlyMemory<T> Current => _currentMemory;
		393
		394		/// <summary>
		395		/// Moves to the next <see cref="ReadOnlyMemory{T}"/> in the <see cref="ReadOnlySequence{T}"/>
		396		/// </summary>
		397		/// <returns></returns>
		398		public bool MoveNext()
	1	399		{
	1	400		if (_next.GetObject() == null)
	1	401		{
	1	402		return false;
		403		}
		404
	1	405		return _sequence.TryGet(ref _next, out _currentMemory);
	1	406		}
		407		}
		408
		409		private enum SequenceType
		410		{
		411		MultiSegment = 0x00,
		412		Array = 0x1,
		413		OwnedMemory = 0x2,
		414		String = 0x3,
		415		Empty = 0x4
		416		}
		417		}
		418
		419		internal static class ReadOnlySequence
		420		{
		421		public const int FlagBitMask = 1 << 31;
		422		public const int IndexBitMask = ~FlagBitMask;
		423
		424		public const int SegmentStartMask = 0;
		425		public const int SegmentEndMask = 0;
		426
		427		public const int ArrayStartMask = 0;
		428		public const int ArrayEndMask = FlagBitMask;
		429
		430		public const int OwnedMemoryStartMask = FlagBitMask;
		431		public const int OwnedMemoryEndMask = 0;
		432
		433		public const int StringStartMask = FlagBitMask;
		434		public const int StringEndMask = FlagBitMask;
		435
		436		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		437		public static int SegmentToSequenceStart(int startIndex) => startIndex | SegmentStartMask;
		438		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		439		public static int SegmentToSequenceEnd(int endIndex) => endIndex | SegmentEndMask;
		440		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		441		public static int ArrayToSequenceStart(int startIndex) => startIndex | ArrayStartMask;
		442		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		443		public static int ArrayToSequenceEnd(int endIndex) => endIndex | ArrayEndMask;
		444		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		445		public static int OwnedMemoryToSequenceStart(int startIndex) => startIndex | OwnedMemoryStartMask;
		446		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		447		public static int OwnedMemoryToSequenceEnd(int endIndex) => endIndex | OwnedMemoryEndMask;
		448		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		449		public static int StringToSequenceStart(int startIndex) => startIndex | StringStartMask;
		450		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		451		public static int StringToSequenceEnd(int endIndex) => endIndex | StringEndMask;
		452		}
		453		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\ReadOnlySequence_helpers.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7
		8		#if !netstandard
		9		using Internal.Runtime.CompilerServices;
		10		#endif
		11
		12		namespace System.Buffers
		13		{
		14		public readonly partial struct ReadOnlySequence<T>
		15		{
		16		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		17		internal bool TryGetBuffer(in SequencePosition start, in SequencePosition end, out ReadOnlyMemory<T> data, out S
	1	18		{
		19		SequenceType type;
	1	20		int startIndex = 0;
	1	21		int endIndex = 0;
	1	22		next = default;
	1	23		object startObject = start.GetObject();
	1	24		if (startObject != null)
	1	25		{
	1	26		GetTypeAndIndices(start.GetInteger(), end.GetInteger(), out type, out startIndex, out endIndex);
	1	27		}
		28		else
	1	29		{
	1	30		type = SequenceType.Empty;
	1	31		}
		32
	1	33		int length = endIndex - startIndex;
	1	34		object endObject = end.GetObject();
		35
	1	36		if (type != SequenceType.MultiSegment && type != SequenceType.Empty && startObject != endObject)
	0	37		ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
		38
	1	39		if (type == SequenceType.MultiSegment)
	1	40		{
	1	41		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
	1	42		ReadOnlySequenceSegment<T> startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject);
		43
	1	44		if (startSegment != endObject)
	1	45		{
	1	46		next = GetBufferCrossSegment(startIndex, endObject, ref startSegment, ref length);
	1	47		}
		48
	1	49		data = startSegment.Memory;
	1	50		}
	1	51		else if (type == SequenceType.Array)
	0	52		{
	0	53		Debug.Assert(startObject is T[]);
		54
	0	55		data = new ReadOnlyMemory<T>(Unsafe.As<T[]>(startObject));
	0	56		}
	1	57		else if (type == SequenceType.OwnedMemory)
	0	58		{
	0	59		Debug.Assert(startObject is OwnedMemory<T>);
		60
	0	61		data = (Unsafe.As<OwnedMemory<T>>(startObject)).Memory;
	0	62		}
	1	63		else if (typeof(T) == typeof(char) && type == SequenceType.String)
	0	64		{
	0	65		Debug.Assert(startObject is string);
		66
	0	67		data = (ReadOnlyMemory<T>)(object)(Unsafe.As<string>(startObject)).AsMemory();
	0	68		}
		69		else
	1	70		{
	1	71		data = default;
	1	72		return false;
		73		}
		74
	1	75		data = data.Slice(startIndex, length);
	1	76		return true;
	1	77		}
		78
		79		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		80		internal ReadOnlyMemory<T> GetFirstBuffer(in SequencePosition start, in SequencePosition end)
	1	81		{
		82		SequenceType type;
	1	83		int startIndex = 0;
	1	84		int endIndex = 0;
	1	85		object startObject = start.GetObject();
	1	86		if (startObject != null)
	1	87		{
	1	88		GetTypeAndIndices(start.GetInteger(), end.GetInteger(), out type, out startIndex, out endIndex);
	1	89		}
		90		else
	0	91		{
	0	92		type = SequenceType.Empty;
	0	93		}
		94
	1	95		int length = endIndex - startIndex;
	1	96		object endObject = end.GetObject();
		97
	1	98		if (type != SequenceType.MultiSegment && type != SequenceType.Empty && startObject != endObject)
	0	99		ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
		100
		101		ReadOnlyMemory<T> memory;
	1	102		if (type == SequenceType.MultiSegment)
	1	103		{
	1	104		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
	1	105		ReadOnlySequenceSegment<T> startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject);
	1	106		memory = startSegment.Memory;
	1	107		if (startObject != endObject)
	1	108		{
	1	109		length = memory.Length - startIndex;
	1	110		}
	1	111		}
	1	112		else if (type == SequenceType.Array)
	1	113		{
	1	114		Debug.Assert(startObject is T[]);
		115
	1	116		memory = new ReadOnlyMemory<T>(Unsafe.As<T[]>(startObject));
	1	117		}
	1	118		else if (type == SequenceType.OwnedMemory)
	1	119		{
	1	120		Debug.Assert(startObject is OwnedMemory<T>);
		121
	1	122		memory = (Unsafe.As<OwnedMemory<T>>(startObject)).Memory;
	1	123		}
	1	124		else if (typeof(T) == typeof(char) && type == SequenceType.String)
	1	125		{
	1	126		Debug.Assert(startObject is string);
		127
	1	128		memory = (ReadOnlyMemory<T>)(object)(Unsafe.As<string>(startObject)).AsMemory();
	1	129		}
		130		else
	0	131		{
	0	132		return default;
		133		}
		134
	1	135		return memory.Slice(startIndex, length);
	1	136		}
		137
		138		private static SequencePosition GetBufferCrossSegment(int startIndex, object endObject, ref ReadOnlySequenceSegm
	1	139		{
	1	140		Debug.Assert(startSegment != null);
		141
	1	142		ReadOnlySequenceSegment<T> nextSegment = startSegment.Next;
	1	143		int currentLength = startSegment.Memory.Length - startIndex;
		144
	1	145		while (currentLength == 0 && nextSegment != endObject && nextSegment != null)
	1	146		{
		147		// startSegment is at the end of a segment; move it to start of the next.
		148		// However, skip any empty segments, else the caller will immedately run out of data and call back
	1	149		startSegment = nextSegment;
	1	150		nextSegment = nextSegment.Next;
	1	151		currentLength = startSegment.Memory.Length;
	1	152		}
		153
	1	154		length = currentLength;
	1	155		while (nextSegment != null && nextSegment.Memory.Length == 0)
	1	156		{
		157		// nextSegment is an empty segment, skip until one is found with data.
	1	158		if (nextSegment == endObject)
	1	159		{
		160		// Reached the end and no segment with data found,
		161		// set nextSegment to null as if there were no following segments.
	1	162		endObject = nextSegment = null;
	1	163		break;
		164		}
		165
	1	166		nextSegment = nextSegment.Next;
	1	167		}
		168
	1	169		if (nextSegment != null)
	1	170		{
	1	171		return new SequencePosition(nextSegment, 0);
		172		}
	1	173		else if (endObject != null)
	0	174		ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
		175
	1	176		return default;
	1	177		}
		178
		179		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		180		internal SequencePosition Seek(in SequencePosition start, in SequencePosition end, int count)
	1	181		{
	1	182		GetTypeAndIndices(start.GetInteger(), end.GetInteger(), out SequenceType type, out int startIndex, out int e
		183
	1	184		object startObject = start.GetObject();
	1	185		object endObject = end.GetObject();
		186
	1	187		bool notInRange = endIndex - startIndex < count;
	1	188		if (type == SequenceType.MultiSegment && startObject != endObject)
	1	189		{
	1	190		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
	1	191		var startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject);
		192
	1	193		int currentLength = startSegment.Memory.Length - startIndex;
	1	194		if (currentLength > count)
	1	195		{
		196		// Position in start segment, defer to single segment seek
	1	197		notInRange = false;
	1	198		}
		199		else
	1	200		{
	1	201		return SeekMultiSegment(startSegment, startIndex, endObject, endIndex, count - currentLength);
		202		}
	1	203		}
		204		else
	1	205		{
	1	206		Debug.Assert(startObject == endObject);
	1	207		}
		208
	1	209		if (notInRange)
	1	210		ThrowHelper.ThrowArgumentOutOfRangeException_CountOutOfRange();
		211
		212		// Single segment Seek
	1	213		return new SequencePosition(startObject, startIndex + count);
	1	214		}
		215
		216		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		217		internal SequencePosition Seek(in SequencePosition start, in SequencePosition end, long count)
	1	218		{
	1	219		GetTypeAndIndices(start.GetInteger(), end.GetInteger(), out SequenceType type, out int startIndex, out int e
		220
	1	221		object startObject = start.GetObject();
	1	222		object endObject = end.GetObject();
		223
	1	224		bool notInRange = endIndex - startIndex < count;
	1	225		if (type == SequenceType.MultiSegment && startObject != endObject)
	1	226		{
	1	227		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
	1	228		var startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject);
		229
	1	230		int currentLength = startSegment.Memory.Length - startIndex;
	1	231		if (currentLength > count)
	1	232		{
		233		// Position in start segment, defer to single segment seek
	1	234		notInRange = false;
	1	235		}
		236		else
	1	237		{
	1	238		return SeekMultiSegment(startSegment, startIndex, endObject, endIndex, count - currentLength);
		239		}
	1	240		}
		241		else
	1	242		{
	1	243		Debug.Assert(startObject == endObject);
	1	244		}
		245
	1	246		if (notInRange)
	1	247		ThrowHelper.ThrowArgumentOutOfRangeException_CountOutOfRange();
		248
		249		// Single segment Seek
	1	250		return new SequencePosition(startObject, startIndex + (int)count);
	1	251		}
		252
		253		[MethodImpl(MethodImplOptions.NoInlining)]
		254		private static SequencePosition SeekMultiSegment(ReadOnlySequenceSegment<T> currentSegment, int startIndex, obje
	1	255		{
	1	256		Debug.Assert(currentSegment != null);
	1	257		Debug.Assert(currentSegment.Next != null);
	1	258		Debug.Assert(count >= 0);
		259
		260		// End of segment. Move to start of next.
	1	261		currentSegment = currentSegment.Next;
		262
	1	263		if (count > 0 || currentSegment.Memory.Length == 0)
	1	264		{
	1	265		while (currentSegment != null)
	1	266		{
	1	267		bool isCurrentAtEnd = currentSegment == endObject;
	1	268		int memoryLength = isCurrentAtEnd ? endPosition : currentSegment.Memory.Length;
		269
	1	270		if (memoryLength > count || (memoryLength == count && isCurrentAtEnd))
	1	271		{
		272		// Fully contained in this segment; or at end of segment but there isn't a next one to move to
	1	273		break;
		274		}
		275
		276		// Move to next
	1	277		count -= memoryLength;
	1	278		currentSegment = currentSegment.Next;
	1	279		}
	1	280		}
		281
		282		// Hit the end of the segments but didn't reach the count
	1	283		if (currentSegment == null)
	1	284		ThrowHelper.ThrowArgumentOutOfRangeException_CountOutOfRange();
		285
	1	286		return new SequencePosition(currentSegment, (int)count);
	1	287		}
		288
		289		private static void CheckEndReachable(object startSegment, object endSegment)
	1	290		{
	1	291		Debug.Assert(startSegment != null);
	1	292		Debug.Assert(startSegment is ReadOnlySequenceSegment<T>);
	1	293		Debug.Assert(endSegment != null);
		294
	1	295		var current = Unsafe.As<ReadOnlySequenceSegment<T>>(startSegment);
		296
	1	297		while (current.Next != null)
	1	298		{
	1	299		current = current.Next;
	1	300		if (current == endSegment)
	1	301		{
		302		// Found end
	1	303		return;
		304		}
	1	305		}
		306
	0	307		ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
	1	308		}
		309
		310		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		311		private long GetLength(in SequencePosition start, in SequencePosition end)
	1	312		{
	1	313		GetTypeAndIndices(start.GetInteger(), end.GetInteger(), out SequenceType type, out int startIndex, out int e
		314
	1	315		object startObject = start.GetObject();
	1	316		object endObject = end.GetObject();
	1	317		if (type == SequenceType.MultiSegment && startObject != endObject)
	1	318		{
	1	319		Debug.Assert(startObject != null);
	1	320		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
	1	321		Debug.Assert(endObject != null);
	1	322		Debug.Assert(endObject is ReadOnlySequenceSegment<T>);
		323
	1	324		var startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject);
	1	325		var endSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(endObject);
		326		// (end.RunningIndex + endIndex) - (start.RunningIndex + startIndex) // (End offset) - (start offset)
	1	327		return endSegment.RunningIndex - startSegment.RunningIndex - startIndex + endIndex; // Rearranged to avo
		328		}
		329
	1	330		Debug.Assert(startObject == endObject);
		331		// Single segment length
	1	332		return endIndex - startIndex;
	1	333		}
		334
		335		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		336		private void BoundsCheck(in SequencePosition start, in SequencePosition end)
	1	337		{
	1	338		GetTypeAndIndices(start.GetInteger(), end.GetInteger(), out SequenceType type, out int startIndex, out int e
		339
	1	340		object startObject = start.GetObject();
	1	341		object endObject = end.GetObject();
	1	342		if (type == SequenceType.MultiSegment && startObject != endObject)
	1	343		{
	1	344		Debug.Assert(startObject != null);
	1	345		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
	1	346		Debug.Assert(endObject != null);
	1	347		Debug.Assert(endObject is ReadOnlySequenceSegment<T>);
		348
	1	349		var startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject);
	1	350		var endSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(endObject);
		351
		352		// start.RunningIndex + startIndex <= end.RunningIndex + endIndex
	1	353		if (startSegment.RunningIndex - endIndex <= endSegment.RunningIndex - startIndex) // Rearranged to avoid
	1	354		{
		355		// Mult-segment in bounds
	1	356		return;
		357		}
	1	358		}
	1	359		else if (startIndex <= endIndex)
	1	360		{
	1	361		Debug.Assert(startObject == endObject);
		362		// Single segment in bounds
	1	363		return;
		364		}
		365
	1	366		ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
	1	367		}
		368
		369		internal bool TryGetReadOnlySequenceSegment(out ReadOnlySequenceSegment<T> startSegment, out int startIndex, out
	1	370		{
	1	371		GetTypeAndIndices(Start.GetInteger(), End.GetInteger(), out SequenceType type, out startIndex, out endIndex)
		372
	1	373		if (type != SequenceType.MultiSegment)
	1	374		{
	1	375		startSegment = null;
	1	376		endSegment = null;
	1	377		return false;
		378		}
		379
	1	380		Debug.Assert(Start.GetObject() != null);
	1	381		Debug.Assert(Start.GetObject() is ReadOnlySequenceSegment<T>);
	1	382		Debug.Assert(End.GetObject() != null);
	1	383		Debug.Assert(End.GetObject() is ReadOnlySequenceSegment<T>);
		384
	1	385		startSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(Start.GetObject());
	1	386		endSegment = Unsafe.As<ReadOnlySequenceSegment<T>>(End.GetObject());
	1	387		return true;
	1	388		}
		389
		390		internal bool TryGetArray(out ArraySegment<T> array)
	1	391		{
	1	392		GetTypeAndIndices(Start.GetInteger(), End.GetInteger(), out SequenceType type, out int startIndex, out int e
		393
	1	394		if (type != SequenceType.Array)
	1	395		{
	1	396		array = default;
	1	397		return false;
		398		}
		399
	1	400		Debug.Assert(Start.GetObject() != null);
	1	401		Debug.Assert(Start.GetObject() is T[]);
		402
	1	403		array = new ArraySegment<T>(Unsafe.As<T[]>(Start.GetObject()), startIndex, endIndex - startIndex);
	1	404		return true;
	1	405		}
		406
		407		internal bool TryGetOwnedMemory(out OwnedMemory<T> ownedMemory, out int start, out int length)
	1	408		{
	1	409		GetTypeAndIndices(Start.GetInteger(), End.GetInteger(), out SequenceType type, out start, out int endIndex);
		410
	1	411		if (type != SequenceType.OwnedMemory)
	1	412		{
	1	413		ownedMemory = default;
	1	414		length = 0;
	1	415		return false;
		416		}
		417
	1	418		Debug.Assert(Start.GetObject() != null);
	1	419		Debug.Assert(Start.GetObject() is OwnedMemory<T>);
		420
	1	421		ownedMemory = Unsafe.As<OwnedMemory<T>>(Start.GetObject());
	1	422		length = endIndex - start;
	1	423		return true;
	1	424		}
		425
		426		internal bool TryGetReadOnlyMemory(out ReadOnlyMemory<T> memory)
	1	427		{
	1	428		GetTypeAndIndices(Start.GetInteger(), End.GetInteger(), out SequenceType type, out int startIndex, out int e
		429
	1	430		object startObject = Start.GetObject();
	1	431		object endObject = End.GetObject();
		432
	1	433		Debug.Assert(startObject != null);
	1	434		Debug.Assert(endObject != null);
		435
	1	436		int length = endIndex - startIndex;
	1	437		if (startObject != endObject)
	1	438		{
		439		// Can't get ReadOnlyMemory from multi-block segments
	1	440		memory = default;
	1	441		return false;
		442		}
	1	443		else if (type == SequenceType.Array)
	1	444		{
	1	445		Debug.Assert(startObject is T[]);
		446
	1	447		memory = new ReadOnlyMemory<T>(Unsafe.As<T[]>(startObject));
	1	448		}
	1	449		else if (type == SequenceType.OwnedMemory)
	1	450		{
	1	451		Debug.Assert(startObject is OwnedMemory<T>);
		452
	1	453		memory = Unsafe.As<OwnedMemory<T>>(startObject).Memory;
	1	454		}
	1	455		else if (typeof(T) == typeof(char) && type == SequenceType.String)
	1	456		{
	1	457		Debug.Assert(startObject is string);
		458
	1	459		var text = Unsafe.As<string>(startObject);
	1	460		memory = (ReadOnlyMemory<T>)(object)text.AsMemory();
	1	461		}
		462		else // ReadOnlySequenceSegment
	1	463		{
	1	464		Debug.Assert(startObject is ReadOnlySequenceSegment<T>);
		465
	1	466		memory = Unsafe.As<ReadOnlySequenceSegment<T>>(startObject).Memory;
	1	467		}
		468
	1	469		memory = memory.Slice(startIndex, length);
	1	470		return true;
	1	471		}
		472
		473		internal bool TryGetString(out string text, out int start, out int length)
		474		{
		475		if (typeof(T) != typeof(char))
		476		{
		477		start = 0;
		478		length = 0;
		479		text = null;
		480		return false;
		481		}
		482
		483		GetTypeAndIndices(Start.GetInteger(), End.GetInteger(), out SequenceType type, out int startIndex, out int e
		484
		485		if (type != SequenceType.String)
		486		{
		487		start = 0;
		488		length = 0;
		489		text = null;
		490		return false;
		491		}
		492
		493		start = startIndex;
		494		length = endIndex - startIndex;
		495		text = (string)Start.GetObject();
		496
		497		return true;
		498		}
		499		}
		500		}