Make len-based overloads private; add non-len overloads

Author: paulirwin

src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs

@@ -32,15 +32,14 @@ public static class StemmerUtil // LUCENENET specific: CA1052 Static holder type
         /// Returns true if the character array starts with the prefix.
         /// </summary>
         /// <param name="s"> Input Buffer </param>
-        /// <param name="len"> length of input buffer </param>
         /// <param name="prefix"> Prefix string to test </param>
         /// <returns> <c>true</c> if <paramref name="s"/> starts with <paramref name="prefix"/> </returns>
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
         /// </remarks>
-        public static bool StartsWith(ReadOnlySpan<char> s, int len, string prefix)
+        public static bool StartsWith(ReadOnlySpan<char> s, string prefix)
         {
-            return StartsWith(s, len, prefix.AsSpan());
+            return StartsWith(s, prefix.AsSpan());
         }
 
         /// <summary>
@@ -52,11 +51,27 @@ public static bool StartsWith(ReadOnlySpan<char> s, int len, string prefix)
         /// <returns> <c>true</c> if <paramref name="s"/> starts with <paramref name="prefix"/> </returns>
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
+        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
+        /// but this overload is provided for compatibility with existing code.
+        /// </remarks>
+        internal static bool StartsWith(ReadOnlySpan<char> s, int len, string prefix)
+        {
+            return StartsWith(s.Slice(0, len), prefix.AsSpan());
+        }
+
+        /// <summary>
+        /// Returns true if the character array starts with the prefix.
+        /// </summary>
+        /// <param name="s"> Input Buffer </param>
+        /// <param name="prefix"> Prefix string to test </param>
+        /// <returns> <c>true</c> if <paramref name="s"/> starts with <paramref name="prefix"/> </returns>
+        /// <remarks>
+        /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
         /// </remarks>
-        public static bool StartsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char> prefix)
+        public static bool StartsWith(ReadOnlySpan<char> s, ReadOnlySpan<char> prefix)
         {
             int prefixLen = prefix.Length;
-            if (prefixLen > len)
+            if (prefixLen > s.Length)
             {
                 return false;
             }
@@ -66,18 +81,34 @@ public static bool StartsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char>
         }
 
         /// <summary>
-        /// Returns true if the character array ends with the suffix.
+        /// Returns true if the character array starts with the prefix.
         /// </summary>
         /// <param name="s"> Input Buffer </param>
         /// <param name="len"> length of input buffer </param>
+        /// <param name="prefix"> Prefix string to test </param>
+        /// <returns> <c>true</c> if <paramref name="s"/> starts with <paramref name="prefix"/> </returns>
+        /// <remarks>
+        /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
+        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
+        /// but this overload is provided for compatibility with existing code.
+        /// </remarks>
+        internal static bool StartsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char> prefix)
+        {
+            return StartsWith(s.Slice(0, len), prefix);
+        }
+
+        /// <summary>
+        /// Returns true if the character array ends with the suffix.
+        /// </summary>
+        /// <param name="s"> Input Buffer </param>
         /// <param name="suffix"> Suffix string to test </param>
         /// <returns> <c>true</c> if <paramref name="s"/> ends with <paramref name="suffix"/> </returns>
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
         /// </remarks>
-        public static bool EndsWith(ReadOnlySpan<char> s, int len, string suffix)
+        public static bool EndsWith(ReadOnlySpan<char> s, string suffix)
         {
-            return EndsWith(s, len, suffix.AsSpan());
+            return EndsWith(s, suffix.AsSpan());
         }
 
         /// <summary>
@@ -89,17 +120,50 @@ public static bool EndsWith(ReadOnlySpan<char> s, int len, string suffix)
         /// <returns> <c>true</c> if <paramref name="s"/> ends with <paramref name="suffix"/> </returns>
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
+        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
+        /// but this overload is provided for compatibility with existing code.
+        /// </remarks>
+        internal static bool EndsWith(ReadOnlySpan<char> s, int len, string suffix)
+        {
+            return EndsWith(s.Slice(0, len), suffix.AsSpan());
+        }
+
+        /// <summary>
+        /// Returns true if the character array ends with the suffix.
+        /// </summary>
+        /// <param name="s"> Input Buffer </param>
+        /// <param name="suffix"> Suffix string to test </param>
+        /// <returns> <c>true</c> if <paramref name="s"/> ends with <paramref name="suffix"/> </returns>
+        /// <remarks>
+        /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
         /// </remarks>
-        public static bool EndsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char> suffix)
+        public static bool EndsWith(ReadOnlySpan<char> s, ReadOnlySpan<char> suffix)
         {
             int suffixLen = suffix.Length;
-            if (suffixLen > len)
+            if (suffixLen > s.Length)
             {
                 return false;
             }
 
             // LUCENENET: use more efficient implementation in MemoryExtensions
-            return s.Slice(0, len).EndsWith(suffix, StringComparison.Ordinal);
+            return s.EndsWith(suffix, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Returns true if the character array ends with the suffix.
+        /// </summary>
+        /// <param name="s"> Input Buffer </param>
+        /// <param name="len"> length of input buffer </param>
+        /// <param name="suffix"> Suffix string to test </param>
+        /// <returns> <c>true</c> if <paramref name="s"/> ends with <paramref name="suffix"/> </returns>
+        /// <remarks>
+        /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
+        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
+        /// but this overload is provided for compatibility with existing code.
+        /// </remarks>
+        internal static bool EndsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char> suffix)
+        {
+            return EndsWith(s.Slice(0, len), suffix);
         }
 
         // LUCENENET NOTE: char[] overload of EndsWith removed because the ReadOnlySpan<char> overload can be used instead
@@ -114,15 +178,32 @@ public static bool EndsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char> su
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="Span{T}"/>.
         /// </remarks>
-        public static int Delete(Span<char> s, int pos, int len)
+        public static int Delete(Span<char> s, int pos)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(pos < len);
-            if (pos < len - 1) // don't arraycopy if asked to delete last character
+            if (Debugging.AssertsEnabled) Debugging.Assert(pos < s.Length);
+            if (pos < s.Length - 1) // don't arraycopy if asked to delete last character
             {
                 // Arrays.Copy(s, pos + 1, s, pos, len - pos - 1);
-                s.Slice(pos + 1, len - pos - 1).CopyTo(s.Slice(pos, len - pos - 1));
+                s.Slice(pos + 1, s.Length - pos - 1).CopyTo(s.Slice(pos, s.Length - pos - 1));
             }
-            return len - 1;
+            return s.Length - 1;
+        }
+
+        /// <summary>
+        /// Delete a character in-place
+        /// </summary>
+        /// <param name="s"> Input Buffer </param>
+        /// <param name="pos"> Position of character to delete </param>
+        /// <param name="len"> length of input buffer </param>
+        /// <returns> length of input buffer after deletion </returns>
+        /// <remarks>
+        /// LUCENENET NOTE: This method has been converted to use <see cref="Span{T}"/>.
+        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
+        /// but this overload is provided for compatibility with existing code.
+        /// </remarks>
+        internal static int Delete(Span<char> s, int pos, int len)
+        {
+            return Delete(s.Slice(0, len), pos);
         }
 
         /// <summary>
@@ -136,15 +217,31 @@ public static int Delete(Span<char> s, int pos, int len)
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="Span{T}"/>.
         /// </remarks>
-        public static int DeleteN(Span<char> s, int pos, int len, int nChars)
+        public static int DeleteN(Span<char> s, int pos, int nChars)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(pos + nChars <= len);
-            if (pos + nChars < len) // don't arraycopy if asked to delete the last characters
+            if (Debugging.AssertsEnabled) Debugging.Assert(pos + nChars <= s.Length);
+            if (pos + nChars < s.Length) // don't arraycopy if asked to delete the last characters
             {
                 // Arrays.Copy(s, pos + nChars, s, pos, len - pos - nChars);
-                s.Slice(pos + nChars, len - pos - nChars).CopyTo(s.Slice(pos, len - pos - nChars));
+                s.Slice(pos + nChars, s.Length - pos - nChars).CopyTo(s.Slice(pos, s.Length - pos - nChars));
             }
-            return len - nChars;
+            return s.Length - nChars;
+        }
+
+        /// <summary>
+        /// Delete n characters in-place
+        /// </summary>
+        /// <param name="s"> Input Buffer </param>
+        /// <param name="pos"> Position of character to delete </param>
+        /// <param name="len"> Length of input buffer </param>
+        /// <param name="nChars"> number of characters to delete </param>
+        /// <returns> length of input buffer after deletion </returns>
+        /// <remarks>
+        /// LUCENENET NOTE: This method has been converted to use <see cref="Span{T}"/>.
+        /// </remarks>
+        internal static int DeleteN(Span<char> s, int pos, int len, int nChars)
+        {
+            return DeleteN(s.Slice(0, len), pos, nChars);
         }
     }
 }

src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestStemmerUtil.cs

@@ -37,7 +37,11 @@ public class TestStemmerUtil : LuceneTestCase
         [TestCase("foobar", 2, "foo", false)]
         public void TestStartsWith(string input, int len, string prefix, bool expected)
         {
+            // test len overload
             Assert.AreEqual(expected, StemmerUtil.StartsWith(input.AsSpan(), len, prefix));
+
+            // test no len overload
+            Assert.AreEqual(expected, StemmerUtil.StartsWith(input.AsSpan(0, len), prefix));
         }
 
         [Test]
@@ -48,7 +52,11 @@ public void TestStartsWith(string input, int len, string prefix, bool expected)
         [TestCase("foobar", 3, "foo", true)]
         public void TestEndsWith(string input, int len, string prefix, bool expected)
         {
+            // test len overload
             Assert.AreEqual(expected, StemmerUtil.EndsWith(input.AsSpan(), len, prefix));
+
+            // test no len overload
+            Assert.AreEqual(expected, StemmerUtil.EndsWith(input.AsSpan(0, len), prefix));
         }
 
         [Test]
@@ -58,9 +66,15 @@ public void TestEndsWith(string input, int len, string prefix, bool expected)
         [TestCase("foobar", 5, 6, "fooba", 5)]
         public void TestDelete(string input, int pos, int len, string expected, int expectedLen)
         {
+            // test len overload
             char[] buffer = input.ToCharArray();
             Assert.AreEqual(expectedLen, StemmerUtil.Delete(buffer, pos, len));
             Assert.AreEqual(expected, new string(buffer, 0, expectedLen));
+
+            // test no len overload
+            buffer = input.ToCharArray();
+            Assert.AreEqual(expectedLen, StemmerUtil.Delete(buffer.AsSpan(0, len), pos));
+            Assert.AreEqual(expected, new string(buffer, 0, expectedLen));
         }
 
         [Test]
@@ -70,9 +84,15 @@ public void TestDelete(string input, int pos, int len, string expected, int expe
         [TestCase("foobar", 4, 6, 2, "foob", 4)]
         public void TestDeleteN(string input, int pos, int len, int nChars, string expected, int expectedLen)
         {
+            // test len overload
             char[] buffer = input.ToCharArray();
             Assert.AreEqual(expectedLen, StemmerUtil.DeleteN(buffer, pos, len, nChars));
             Assert.AreEqual(expected, new string(buffer, 0, expectedLen));
+
+            // test no len overload
+            buffer = input.ToCharArray();
+            Assert.AreEqual(expectedLen, StemmerUtil.DeleteN(buffer.AsSpan(0, len), pos, nChars));
+            Assert.AreEqual(expected, new string(buffer, 0, expectedLen));
         }
     }
 }