Support multiple entry in inner fuzzy (#111)

Previous commit added a duplicate entry in inner fuzzy, which would
require some additional change to support. It seems there's no much
benefit in exposing inner fuzzy, the new version will make use to
transparent map and be hidden API.

Author: wengxt

src/libime/core/utils_p.h

@@ -194,6 +194,19 @@ inline int millisecondsTill(T t0) {
         .count();
 }
 
+struct StringHash {
+    using hash_type = std::hash<std::string_view>;
+    using is_transparent = void;
+
+    std::size_t operator()(const char *str) const { return hash_type{}(str); }
+    std::size_t operator()(std::string_view str) const {
+        return hash_type{}(str);
+    }
+    std::size_t operator()(const std::string &str) const {
+        return hash_type{}(str);
+    }
+};
+
 } // namespace libime
 
 #endif // _LIBIME_LIBIME_CORE_UTILS_P_H_

src/libime/pinyin/pinyindata.cpp

@@ -16,6 +16,7 @@
 #include <vector>
 #include <fcitx-utils/log.h>
 #include <fcitx-utils/stringutils.h>
+#include "pinyindata_p.h"
 #include "pinyinencoder.h"
 
 namespace libime {
@@ -152,6 +153,39 @@ getInnerSegment() {
     return innerSegment;
 }
 
+const InnerSegmentMap &getInnerSegmentV2() {
+    static const InnerSegmentMap innerSegment = []() {
+        InnerSegmentMap innerSegmentV2;
+        for (const auto &[key, value] : getInnerSegment()) {
+            innerSegmentV2[key].push_back(value);
+        }
+
+        for (const auto &newItem : std::vector<
+                 std::pair<std::string, std::pair<std::string, std::string>>>{
+                 {"qiao", {"qia", "o"}},
+                 {"niao", {"nia", "o"}},
+                 {"liao", {"lia", "o"}},
+                 {"zhuo", {"zhu", "o"}},
+                 {"diao", {"dia", "o"}},
+                 {"shao", {"sha", "o"}},
+                 {"xiao", {"xia", "o"}},
+                 {"zhua", {"zhu", "a"}},
+                 {"shuo", {"shu", "o"}},
+                 {"shua", {"shu", "a"}},
+                 {"zhao", {"zha", "o"}},
+                 {"jiao", {"jia", "o"}},
+                 {"chuo", {"chu", "o"}},
+                 {"chua", {"chu", "a"}},
+                 {"chao", {"cha", "o"}},
+             }) {
+            innerSegmentV2[newItem.first].push_back(newItem.second);
+        }
+        return innerSegmentV2;
+    }();
+
+    return innerSegment;
+}
+
 inline bool operator==(const PinyinEntry &a, const PinyinEntry &b) {
     return a.pinyin() == b.pinyin() && a.initial() == b.initial() &&
            a.final() == b.final() && a.flags() == b.flags();

src/libime/pinyin/pinyindata_p.h

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2017-2017 CSSlayer <wengxt@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+#ifndef _FCITX_LIBIME_PINYIN_PINYINDATA_P_H_
+#define _FCITX_LIBIME_PINYIN_PINYINDATA_P_H_
+
+#include <functional>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#include "libime/core/utils_p.h"
+
+namespace libime {
+
+using InnerSegmentMap =
+    std::unordered_map<std::string,
+                       std::vector<std::pair<std::string, std::string>>,
+                       StringHash, std::equal_to<>>;
+
+const std::unordered_map<std::string,
+                         std::vector<std::pair<std::string, std::string>>,
+                         StringHash, std::equal_to<>> &
+getInnerSegmentV2();
+} // namespace libime
+
+#endif // _FCITX_LIBIME_PINYIN_PINYINDATA_P_H_

src/libime/pinyin/pinyinencoder.cpp

@@ -29,6 +29,7 @@
 #include "libime/core/segmentgraph.h"
 #include "pinyincorrectionprofile.h"
 #include "pinyindata.h"
+#include "pinyindata_p.h"
 #include "shuangpinprofile.h"
 
 namespace libime {
@@ -295,13 +296,15 @@ PinyinEncoder::parseUserPinyin(std::string userPinyin,
                                 fuzzyFlags.test(PinyinFuzzyFlag::Inner)) ||
                                (nextPinyin.size() == 3 &&
                                 flags.test(PinyinFuzzyFlag::InnerShort))) {
-                        const auto &innerSegments = getInnerSegment();
-                        auto iter = innerSegments.find(std::string(nextPinyin));
+                        const auto &innerSegments = getInnerSegmentV2();
+                        auto iter = innerSegments.find(nextPinyin);
                         if (iter != innerSegments.end()) {
-                            result.addNext(top,
-                                           top + iter->second.first.size());
-                            result.addNext(top + iter->second.first.size(),
-                                           top + nextSize[i]);
+                            for (const auto &innerSeg : iter->second) {
+                                result.addNext(top,
+                                               top + innerSeg.first.size());
+                                result.addNext(top + innerSeg.first.size(),
+                                               top + nextSize[i]);
+                            }
                         }
                     } else if (nextPinyin.size() == 2 &&
                                flags.test(PinyinFuzzyFlag::InnerShort) &&

test/testpinyinencoder.cpp

@@ -251,6 +251,10 @@ int main() {
 
     check("sangeren", PinyinFuzzyFlag::Inner, {"san", "ge", "ren"});
 
+    check("jiao", PinyinFuzzyFlag::Inner, {"jiao"});
+    check("jiao", PinyinFuzzyFlag::Inner, {"ji", "ao"});
+    check("jiao", PinyinFuzzyFlag::Inner, {"jia", "o"});
+
     {
         PinyinCorrectionProfile profile(BuiltinPinyinCorrectionProfile::Qwerty);
         auto graph = PinyinEncoder::parseUserPinyin(