/// <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()));
}
