added FindIndexesInSourceString function and a test case for it

Author: carlosirna

src/Unidecoder.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 
@@ -69,7 +71,7 @@ public static string Unidecode(this string input, int? tempStringBuilderCapacity
       return new string(stackBuffer[0..buffIdx]);
     }
 
-
+    // this implementation is slower but it has no limits for the lenght of the input stirng. it gets called by Unidecode() for long strings
     internal static string SlowUnidecode(this string input, int? tempStringBuilderCapacity = null)
     {
       if (string.IsNullOrEmpty(input))
@@ -127,6 +129,8 @@ public static string Unidecode(this in char c)
       return bytes[c & 0xff];
     }
 
+    // I keep a precalculated cache of all the single character strings for ascii characters, so the Unidecode character extension method
+    // does not instantiate a new string every time it has to return a single character string for a character <0x80
     private static class AsciiCharacter
     {
       public static readonly string[] AsString;
@@ -139,5 +143,53 @@ static AsciiCharacter()
 
     }
 
+    /// <summary>
+    /// this function helps you translate a set of indexes you have found in a decoded stirng to the corresponding indexes
+    /// in the original string, <br/>
+    /// for example Süßigkeit gets decoded to Sussigkeit, so the first 'i' character has index 4 in the decoded string, and 3 in the source string.
+    /// With the avove example Unidecode.GetIndexesInSourceString("Süßigkeit", new int[] {4}) will return {3}
+    /// Warning: this implementation assumes that the input IEnumerable is sorted!
+    /// </summary>
+    public static IEnumerable<int> FindIndexesInSourceString(string sourceString, IEnumerable<int> indexesInDecodedString)
+    {
+      if (string.IsNullOrEmpty(sourceString))
+        yield break;
+      if (indexesInDecodedString == null)
+        yield break;
+
+      using var indexesEnumerator = indexesInDecodedString.GetEnumerator();
+      if (!indexesEnumerator.MoveNext())
+        yield break;
+      var currIndex = indexesEnumerator.Current;
+      if (currIndex < 0)
+        throw new ArgumentException("indexes can't be negative values", nameof(indexesInDecodedString));
+
+      int decodedIdx = 0;
+      for (int srcIdx=0; srcIdx<sourceString.Length; srcIdx++)
+      {
+        if (decodedIdx >= currIndex)
+        {
+          yield return srcIdx;
+          var prevIndex = currIndex;
+          if (!indexesEnumerator.MoveNext()) 
+            yield break; // we decoded all the indexes
+          currIndex = indexesEnumerator.Current;
+          if (currIndex < 0)
+            throw new ArgumentException("indexes can't be negative values", nameof(indexesInDecodedString));
+          if (currIndex <= prevIndex)
+            throw new ArgumentException("Input sequence of indexes must be strictly increasing", nameof(indexesInDecodedString));
+        }
+
+        var ch = sourceString[srcIdx];
+
+        var decodedCh = ch.Unidecode();
+        if (decodedCh != null)
+          decodedIdx += decodedCh.Length;
+      }
+
+    }
+
+    
+
   }
 }

test/UnidecoderTest.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Text;
 using Xunit;
 
@@ -106,6 +107,35 @@ public void MaximumLowByteTest()
       }
     }
 
+
+    [Fact]
+    public void test()
+    {
+      var translated = "Süßigkeit".Unidecode();
+      Assert.Equal("Sussigkeit", translated);
+      // I search some letters in the decoded string
+      var idx_u = translated.IndexOf("u");
+      var idx_i = translated.IndexOf("i");
+      var idx_e = translated.IndexOf("e");
+      var idx_t = translated.IndexOf("t");
+
+
+      Assert.Equal(1, idx_u);
+      Assert.Equal(4, idx_i);
+      Assert.Equal(7, idx_e);
+      Assert.Equal(9, idx_t);
+
+      // I want to know where are the corresponding locations in the source string of these occourrences
+
+      var srcIndexes = Unidecoder.FindIndexesInSourceString("Süßigkeit", new int[] { idx_u, idx_i, idx_e, idx_t }).ToArray();
+
+      Assert.Equal(1, srcIndexes[0]);
+      Assert.Equal(3, srcIndexes[1]);
+      Assert.Equal(6, srcIndexes[2]);
+      Assert.Equal(8, srcIndexes[3]);
+    }
+
+
     /// <summary>
     ///   Tests that Unidecode "stackAlloc" optimized implementation falls back to the slowest SlowUnidecode implementation for long strings,
     ///   instead of raising an error