/// <summary> /// Determines whether two sequences overlap in memory. /// </summary> public static bool Overlaps <T>(this ReadOnlySpan <T> first, ReadOnlySpan <T> second) { if (first.IsEmpty || second.IsEmpty) { return(false); } IntPtr byteOffset = Unsafe.ByteOffset( ref first.DangerousGetPinnableReference(), ref second.DangerousGetPinnableReference()); if (Unsafe.SizeOf <IntPtr>() == sizeof(int)) { return((uint)byteOffset < (uint)(first.Length * Unsafe.SizeOf <T>()) || (uint)byteOffset > (uint)-(second.Length * Unsafe.SizeOf <T>())); } else { return((ulong)byteOffset < (ulong)((long)first.Length * Unsafe.SizeOf <T>()) || (ulong)byteOffset > (ulong)-((long)second.Length * Unsafe.SizeOf <T>())); } }
public static bool SequenceEqual(this Span <char> first, ReadOnlySpan <char> second) { int length = first.Length; return(length == second.Length && SpanHelpers.SequenceEqual(ref first.DangerousGetPinnableReference(), ref second.DangerousGetPinnableReference(), length)); }
public static bool SequenceEqual <T>(this Span <T> first, ReadOnlySpan <T> second) where T : struct, IEquatable <T> { int length = first.Length; return(length == second.Length && SpanHelpers.SequenceEqual(ref first.DangerousGetPinnableReference(), ref second.DangerousGetPinnableReference(), length)); }
public static int IndexOf(this Span <char> span, ReadOnlySpan <char> value) { return(SpanHelpers.IndexOf(ref span.DangerousGetPinnableReference(), span.Length, ref value.DangerousGetPinnableReference(), value.Length)); }
public static int IndexOf <T>(this Span <T> span, ReadOnlySpan <T> value) where T : struct, IEquatable <T> { return(SpanHelpers.IndexOf <T>(ref span.DangerousGetPinnableReference(), span.Length, ref value.DangerousGetPinnableReference(), value.Length)); }
public static int IndexOfAny(this ReadOnlySpan <byte> span, ReadOnlySpan <byte> values) { return(SpanHelpers.IndexOfAny(ref span.DangerousGetPinnableReference(), span.Length, ref values.DangerousGetPinnableReference(), values.Length)); }
public static int IndexOfAny(this ReadOnlySpan <byte> span, byte value0, byte value1, byte value2) { return(SpanHelpers.IndexOfAny(ref span.DangerousGetPinnableReference(), value0, value1, value2, span.Length)); }
public static bool StartsWith <T>(this ReadOnlySpan <T> span, ReadOnlySpan <T> value) where T : struct, IEquatable <T> { int valueLength = value.Length; return(valueLength <= span.Length && SpanHelpers.SequenceEqual(ref span.DangerousGetPinnableReference(), ref value.DangerousGetPinnableReference(), valueLength)); }
public static bool StartsWith(this ReadOnlySpan <byte> span, ReadOnlySpan <byte> value) { int valueLength = value.Length; return(valueLength <= span.Length && SpanHelpers.SequenceEqual(ref span.DangerousGetPinnableReference(), ref value.DangerousGetPinnableReference(), valueLength)); }
/// <summary> /// Checks to see if two spans point at the same memory. Note that /// this does *not* check to see if the *contents* are equal. /// </summary> public bool Equals(ReadOnlySpan <T> other) { return((_length == other.Length) && (_length == 0 || Unsafe.AreSame(ref DangerousGetPinnableReference(), ref other.DangerousGetPinnableReference()))); }
public static T Read <[Primitive] T>(this ReadOnlySpan <byte> slice) where T : struct { Contract.RequiresInInclusiveRange(Unsafe.SizeOf <T>(), (uint)slice.Length); return(Unsafe.As <byte, T>(ref slice.DangerousGetPinnableReference())); }