Patch recognizer

src/rime/gear/matcher.h

@@ -19,7 +19,7 @@ class Matcher : public Segmentor {
   virtual bool Proceed(Segmentation* segmentation);
 
  protected:
-  RecognizerPatterns patterns_;
+  RecognizerPatternsOfVector patterns_;
 };
 
 }  // namespace rime

src/rime/gear/recognizer.cc

@@ -32,8 +32,8 @@ static void load_patterns(RecognizerPatterns* patterns, an<ConfigMap> map) {
   }
 }
 
-void RecognizerPatterns::LoadConfig(Config* config) {
-  load_patterns(this, config->GetMap("recognizer/patterns"));
+void RecognizerPatterns::LoadConfig(Config* config, const string& path) {
+  load_patterns(this, config->GetMap(path));
 }
 
 RecognizerMatch RecognizerPatterns::GetMatch(
@@ -69,6 +69,33 @@ RecognizerMatch RecognizerPatterns::GetMatch(
   return RecognizerMatch();
 }
 
+void RecognizerPatternsOfVector::LoadConfig(Config* config) {
+  this->clear();
+  string path = "recognizer/patterns";
+  if (config->IsMap(path)) {
+    this->assign(1, RecognizerPatterns());
+    (*this)[0].LoadConfig(config, path);
+  } else if (config->IsList(path)) {
+    size_t size = config->GetListSize(path);
+    this->assign(size, RecognizerPatterns());
+    for (size_t i = 0; i < size; ++i) {
+      (*this)[i].LoadConfig(config, path + "/@" + std::to_string(i));
+    }
+  }
+}
+
+RecognizerMatch RecognizerPatternsOfVector::GetMatch(
+    const string& input,
+    const Segmentation& segmentation) const {
+  for (auto it : *this) {
+    auto res = it.GetMatch(input, segmentation);
+    if (res.found()) {
+      return res;
+    }
+  }
+  return RecognizerMatch();
+}
+
 Recognizer::Recognizer(const Ticket& ticket) : Processor(ticket) {
   if (!ticket.schema)
     return;

src/rime/gear/recognizer.h

@@ -29,19 +29,25 @@ struct RecognizerMatch {
 
 class RecognizerPatterns : public map<string, boost::regex> {
  public:
-  void LoadConfig(Config* config);
+  void LoadConfig(Config* config, const string& path = "recognizer/patterns");
   RecognizerMatch GetMatch(const string& input,
                            const Segmentation& segmentation) const;
 };
 
+class RecognizerPatternsOfVector : public vector<RecognizerPatterns> {
+ public:
+  void LoadConfig(Config* config);
+  RecognizerMatch GetMatch(const string& input,
+                           const Segmentation& segmentation) const;
+};
 class Recognizer : public Processor {
  public:
   Recognizer(const Ticket& ticket);
 
   virtual ProcessResult ProcessKeyEvent(const KeyEvent& key_event);
 
  protected:
-  RecognizerPatterns patterns_;
+  RecognizerPatternsOfVector patterns_;
   bool use_space_ = false;
 };