Merge DoublePinAlphabet logic

Author: VictoriousRaptor

Flow.Launcher.Infrastructure/DoublePinAlphabet.cs

@@ -1,18 +1,18 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using JetBrains.Annotations;
 using Flow.Launcher.Infrastructure.UserSettings;
 using ToolGood.Words.Pinyin;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 
 namespace Flow.Launcher.Infrastructure
 {
     public class PinyinAlphabet : IAlphabet
     {
-        private ConcurrentDictionary<string, (string translation, TranslationMapping map)> _pinyinCache =
-            new ConcurrentDictionary<string, (string translation, TranslationMapping map)>();
+        private readonly ConcurrentDictionary<string, (string translation, TranslationMapping map)> _pinyinCache =
+            new();
 
         private Settings _settings;
 
@@ -23,20 +23,22 @@ public void Initialize([NotNull] Settings settings)
 
         public bool ShouldTranslate(string stringToTranslate)
         {
-            return WordsHelper.HasChinese(stringToTranslate);
+            return _settings.UseDoublePinyin ? 
+                (WordsHelper.HasChinese(stringToTranslate) && stringToTranslate.Length % 2 == 0) : 
+                WordsHelper.HasChinese(stringToTranslate);
         }
 
         public (string translation, TranslationMapping map) Translate(string content)
         {
             if (_settings.ShouldUsePinyin)
             {
-                if (!_pinyinCache.ContainsKey(content))
+                if (!_pinyinCache.TryGetValue(content, out var value))
                 {
                     return BuildCacheFromContent(content);
                 }
                 else
                 {
-                    return _pinyinCache[content];
+                    return value;
                 }
             }
             return (content, null);
@@ -57,9 +59,10 @@ public bool ShouldTranslate(string stringToTranslate)
                 {
                     if (content[i] >= 0x3400 && content[i] <= 0x9FD5)
                     {
-                        map.AddNewIndex(i, resultBuilder.Length, resultList[i].Length + 1);
+                        string dp = _settings.UseDoublePinyin ? ToDoublePin(resultList[i].ToLower()) : resultList[i];
+                        map.AddNewIndex(i, resultBuilder.Length, dp.Length + 1);
                         resultBuilder.Append(' ');
-                        resultBuilder.Append(resultList[i]);
+                        resultBuilder.Append(dp);
                         pre = true;
                     }
                     else
@@ -86,5 +89,111 @@ public bool ShouldTranslate(string stringToTranslate)
                 return (content, null);
             }
         }
+
+        #region Double Pinyin
+
+        private static readonly ReadOnlyDictionary<string, string> special = new(new Dictionary<string, string>(){
+            {"a", "aa"},
+            {"ai", "ai"},
+            {"an", "an"},
+            {"ang", "ah"},
+            {"ao", "ao"},
+            {"e", "ee"},
+            {"ei", "ei"},
+            {"en", "en"},
+            {"er", "er"},
+            {"o", "oo"},
+            {"ou", "ou"}
+        });
+
+
+        private static readonly ReadOnlyDictionary<string, string> first = new(new Dictionary<string, string>(){
+            {"ch", "i"},
+            {"sh", "u"},
+            {"zh", "v"}
+        });
+
+
+        private static readonly ReadOnlyDictionary<string, string> second = new(new Dictionary<string, string>()
+        {
+            {"ua", "x"},
+            {"ei", "w"},
+            {"e", "e"},
+            {"ou", "z"},
+            {"iu", "q"},
+            {"ve", "t"},
+            {"ue", "t"},
+            {"u", "u"},
+            {"i", "i"},
+            {"o", "o"},
+            {"uo", "o"},
+            {"ie", "p"},
+            {"a", "a"},
+            {"ong", "s"},
+            {"iong", "s"},
+            {"ai", "d"},
+            {"ing", "k"},
+            {"uai", "k"},
+            {"ang", "h"},
+            {"uan", "r"},
+            {"an", "j"},
+            {"en", "f"},
+            {"ia", "x"},
+            {"iang", "l"},
+            {"uang", "l"},
+            {"eng", "g"},
+            {"in", "b"},
+            {"ao", "c"},
+            {"v", "v"},
+            {"ui", "v"},
+            {"un", "y"},
+            {"iao", "n"},
+            {"ian", "m"}
+        });
+
+        private static string ToDoublePin(string fullPinyin)
+        {
+            // Assuming s is valid
+            StringBuilder doublePin = new StringBuilder();
+
+            if (fullPinyin.Length <= 3 && (fullPinyin[0] == 'a' || fullPinyin[0] == 'e' || fullPinyin[0] == 'o'))
+            {
+                if (special.TryGetValue(fullPinyin, out var value))
+                {
+                    return value;
+                }
+            }
+
+            // zh, ch, sh
+            if (fullPinyin.Length >= 2 && first.ContainsKey(fullPinyin[..2]))
+            {
+                doublePin.Append(first[fullPinyin[..2]]);
+
+                if (second.TryGetValue(fullPinyin[2..], out string tmp))
+                {
+                    doublePin.Append(tmp);
+                }
+                else
+                {
+                    doublePin.Append(fullPinyin[2..]);
+                }
+            }
+            else
+            {
+                doublePin.Append(fullPinyin[0]);
+
+                if (second.TryGetValue(fullPinyin[1..], out string tmp))
+                {
+                    doublePin.Append(tmp);
+                }
+                else
+                {
+                    doublePin.Append(fullPinyin[1..]);
+                }
+            }
+
+            return doublePin.ToString();
+        }
+        #endregion
     }
 }

Flow.Launcher.Infrastructure/PinyinAlphabet.cs

@@ -186,7 +186,8 @@ public CustomBrowserViewModel CustomBrowser
         /// </summary>
         public bool ShouldUsePinyin { get; set; } = false;
 
-        public bool ShouldUseDoublePin { get; set; } = false;
+        public bool UseDoublePinyin { get; set; } = false;
+
         public bool AlwaysPreview { get; set; } = false;
         public bool AlwaysStartEn { get; set; } = false;
 

Flow.Launcher.Infrastructure/UserSettings/Settings.cs

@@ -30,7 +30,7 @@ public partial class App : IDisposable, ISingleInstanceApp
         private SettingWindowViewModel _settingsVM;
         private readonly Updater _updater = new Updater(Flow.Launcher.Properties.Settings.Default.GithubRepo);
         private readonly Portable _portable = new Portable();
-        private readonly DoublePinAlphabet _alphabet = new DoublePinAlphabet();
+        private readonly PinyinAlphabet _alphabet = new PinyinAlphabet();
         private StringMatcher _stringMatcher;
 
         [STAThread]