Temp

MihaZupan · May 19, 2023 · 2dec12f · 2dec12f
1 parent e108a1a
commit 2dec12f
Show file tree

Hide file tree

Showing 9 changed files with 329 additions and 105 deletions.
diff --git a/src/libraries/System.Memory/ref/System.Memory.cs b/src/libraries/System.Memory/ref/System.Memory.cs
@@ -234,6 +234,8 @@ public static partial class MemoryExtensions
         public static bool Contains(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static bool Contains<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
         public static bool Contains<T>(this System.Span<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAny<T>(this System.Span<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static void CopyTo<T>(this T[]? source, System.Memory<T> destination) { }
         public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         public static int Count<T>(this System.Span<T> span, T value) where T : System.IEquatable<T>? { throw null; }

diff --git a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
@@ -401,6 +401,24 @@ ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.Contains(ref MemoryMarshal.GetReference(span), value, span.Length);
         }
 
+        /// <summary>
+        /// Searches for any of the specified values and returns true if found. If not found, returns false.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The set of values to search for.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAny<T>(this Span<T> span, SearchValues<T> values) where T : IEquatable<T>? =>
+            ContainsAny((ReadOnlySpan<T>)span, values);
+
+        /// <summary>
+        /// Searches for any of the specified values and returns true if found. If not found, returns false.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The set of values to search for.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAny<T>(this ReadOnlySpan<T> span, SearchValues<T> values) where T : IEquatable<T>? =>
+            SearchValues<T>.ContainsAny(span, values);
+
         /// <summary>
         /// Searches for the specified value and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
         /// </summary>

diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AnyByteSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AnyByteSearchValues.cs
@@ -24,6 +24,14 @@ public AnyByteSearchValues(ReadOnlySpan<byte> values)
         internal override bool ContainsCore(byte value) =>
             _lookup.Contains(value);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal override bool ContainsAny(ReadOnlySpan<byte> span)
+        {
+            return IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= sizeof(ulong)
+                ? IndexOfAnyAsciiSearcher.ContainsAnyByte(ref MemoryMarshal.GetReference(span), span.Length, ref _bitmaps)
+                : ContainsAnyScalar(ref MemoryMarshal.GetReference(span), span.Length);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal override int IndexOfAny(ReadOnlySpan<byte> span) =>
             IndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length);
@@ -45,7 +53,7 @@ private int IndexOfAny<TNegator>(ref byte searchSpace, int searchSpaceLength)
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {
             return IndexOfAnyAsciiSearcher.IsVectorizationSupported && searchSpaceLength >= sizeof(ulong)
-                ? IndexOfAnyAsciiSearcher.IndexOfAnyVectorizedAnyByte<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmaps)
+                ? IndexOfAnyAsciiSearcher.IndexOfAnyByte<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmaps)
                 : IndexOfAnyScalar<TNegator>(ref searchSpace, searchSpaceLength);
         }
 
@@ -54,10 +62,29 @@ private int LastIndexOfAny<TNegator>(ref byte searchSpace, int searchSpaceLength
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {
             return IndexOfAnyAsciiSearcher.IsVectorizationSupported && searchSpaceLength >= sizeof(ulong)
-                ? IndexOfAnyAsciiSearcher.LastIndexOfAnyVectorizedAnyByte<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmaps)
+                ? IndexOfAnyAsciiSearcher.LastIndexOfAnyByte<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmaps)
                 : LastIndexOfAnyScalar<TNegator>(ref searchSpace, searchSpaceLength);
         }
 
+        private bool ContainsAnyScalar(ref byte searchSpace, int searchSpaceLength)
+        {
+            ref byte searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
+            ref byte cur = ref searchSpace;
+
+            while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd))
+            {
+                byte b = cur;
+                if (_lookup.Contains(b))
+                {
+                    return true;
+                }
+
+                cur = ref Unsafe.Add(ref cur, 1);
+            }
+
+            return false;
+        }
+
         private int IndexOfAnyScalar<TNegator>(ref byte searchSpace, int searchSpaceLength)
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {

diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiByteSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiByteSearchValues.cs
@@ -21,6 +21,14 @@ public AsciiByteSearchValues(ReadOnlySpan<byte> values) =>
         internal override bool ContainsCore(byte value) =>
             _lookup.Contains(value);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal override bool ContainsAny(ReadOnlySpan<byte> span)
+        {
+            return IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= sizeof(ulong)
+                ? IndexOfAnyAsciiSearcher.ContainsAny(ref MemoryMarshal.GetReference(span), span.Length, ref _bitmap)
+                : ContainsAnyScalar(ref MemoryMarshal.GetReference(span), span.Length);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal override int IndexOfAny(ReadOnlySpan<byte> span) =>
             IndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length);
@@ -42,7 +50,7 @@ private int IndexOfAny<TNegator>(ref byte searchSpace, int searchSpaceLength)
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {
             return IndexOfAnyAsciiSearcher.IsVectorizationSupported && searchSpaceLength >= sizeof(ulong)
-                ? IndexOfAnyAsciiSearcher.IndexOfAnyVectorized<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmap)
+                ? IndexOfAnyAsciiSearcher.IndexOfAny<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmap)
                 : IndexOfAnyScalar<TNegator>(ref searchSpace, searchSpaceLength);
         }
 
@@ -51,10 +59,29 @@ private int LastIndexOfAny<TNegator>(ref byte searchSpace, int searchSpaceLength
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {
             return IndexOfAnyAsciiSearcher.IsVectorizationSupported && searchSpaceLength >= sizeof(ulong)
-                ? IndexOfAnyAsciiSearcher.LastIndexOfAnyVectorized<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmap)
+                ? IndexOfAnyAsciiSearcher.LastIndexOfAny<TNegator>(ref searchSpace, searchSpaceLength, ref _bitmap)
                 : LastIndexOfAnyScalar<TNegator>(ref searchSpace, searchSpaceLength);
         }
 
+        private bool ContainsAnyScalar(ref byte searchSpace, int searchSpaceLength)
+        {
+            ref byte searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
+            ref byte cur = ref searchSpace;
+
+            while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd))
+            {
+                byte b = cur;
+                if (_lookup.Contains(b))
+                {
+                    return true;
+                }
+
+                cur = ref Unsafe.Add(ref cur, 1);
+            }
+
+            return false;
+        }
+
         private int IndexOfAnyScalar<TNegator>(ref byte searchSpace, int searchSpaceLength)
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {

diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiCharSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiCharSearchValues.cs
@@ -25,6 +25,14 @@ public AsciiCharSearchValues(Vector256<byte> bitmap, BitVector256 lookup)
         internal override bool ContainsCore(char value) =>
             _lookup.Contains128(value);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal override bool ContainsAny(ReadOnlySpan<char> span)
+        {
+            return IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128<short>.Count
+                ? IndexOfAnyAsciiSearcher.ContainsAny<TOptimizations>(ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _bitmap)
+                : ContainsAnyScalar(ref MemoryMarshal.GetReference(span), span.Length);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal override int IndexOfAny(ReadOnlySpan<char> span) =>
             IndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length);
@@ -46,7 +54,7 @@ private int IndexOfAny<TNegator>(ref char searchSpace, int searchSpaceLength)
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {
             return IndexOfAnyAsciiSearcher.IsVectorizationSupported && searchSpaceLength >= Vector128<short>.Count
-                ? IndexOfAnyAsciiSearcher.IndexOfAnyVectorized<TNegator, TOptimizations>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, ref _bitmap)
+                ? IndexOfAnyAsciiSearcher.IndexOfAny<TNegator, TOptimizations>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, ref _bitmap)
                 : IndexOfAnyScalar<TNegator>(ref searchSpace, searchSpaceLength);
         }
 
@@ -55,10 +63,29 @@ private int LastIndexOfAny<TNegator>(ref char searchSpace, int searchSpaceLength
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {
             return IndexOfAnyAsciiSearcher.IsVectorizationSupported && searchSpaceLength >= Vector128<short>.Count
-                ? IndexOfAnyAsciiSearcher.LastIndexOfAnyVectorized<TNegator, TOptimizations>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, ref _bitmap)
+                ? IndexOfAnyAsciiSearcher.LastIndexOfAny<TNegator, TOptimizations>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, ref _bitmap)
                 : LastIndexOfAnyScalar<TNegator>(ref searchSpace, searchSpaceLength);
         }
 
+        private bool ContainsAnyScalar(ref char searchSpace, int searchSpaceLength)
+        {
+            ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
+            ref char cur = ref searchSpace;
+
+            while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd))
+            {
+                char c = cur;
+                if (_lookup.Contains128(c))
+                {
+                    return true;
+                }
+
+                cur = ref Unsafe.Add(ref cur, 1);
+            }
+
+            return false;
+        }
+
         private int IndexOfAnyScalar<TNegator>(ref char searchSpace, int searchSpaceLength)
             where TNegator : struct, IndexOfAnyAsciiSearcher.INegator
         {