1 files changed, 119 insertions, 0 deletions

@@ -67,6 +67,29 @@ namespace verbly {
     return *this;
   }
   
+  adverb_query& adverb_query::with_prefix(filter<std::string> _f)
+  {
+    _f.clean();
+    _with_prefix = _f;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::with_suffix(filter<std::string> _f)
+  {
+    _f.clean();
+    _with_suffix = _f;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::with_complexity(int _arg)
+  {
+    _with_complexity = _arg;
+    
+    return *this;
+  }
+  
   adverb_query& adverb_query::has_antonyms()
   {
     _has_antonyms = true;
@@ -177,6 +200,85 @@ namespace verbly {
       conditions.push_back("superlative IS NOT NULL");
     }
     
+    if (!_with_prefix.empty())
+    {
+      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
+        switch (f.get_type())
+        {
+          case filter<std::string>::type::singleton:
+          {
+            if (notlogic == f.get_notlogic())
+            {
+              return "base_form LIKE @PREFIX";
+            } else {
+              return "base_form NOT LIKE @PREFIX";
+            }
+          }
+          
+          case filter<std::string>::type::group:
+          {
+            bool truelogic = notlogic != f.get_notlogic();
+            
+            std::list<std::string> clauses;
+            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
+              return recur(f2, truelogic);
+            });
+            
+            if (truelogic == f.get_orlogic())
+            {
+              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
+            } else {
+              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+            }
+          }
+        }
+      };
+      
+      conditions.push_back(recur(_with_prefix, false));
+    }
+    
+    if (!_with_suffix.empty())
+    {
+      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
+        switch (f.get_type())
+        {
+          case filter<std::string>::type::singleton:
+          {
+            if (notlogic == f.get_notlogic())
+            {
+              return "base_form LIKE @SUFFIX";
+            } else {
+              return "base_form NOT LIKE @SUFFIX";
+            }
+          }
+          
+          case filter<std::string>::type::group:
+          {
+            bool truelogic = notlogic != f.get_notlogic();
+            
+            std::list<std::string> clauses;
+            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
+              return recur(f2, truelogic);
+            });
+            
+            if (truelogic == f.get_orlogic())
+            {
+              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
+            } else {
+              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+            }
+          }
+        }
+      };
+      
+      conditions.push_back(recur(_with_suffix, false));
+    }
+    
+    if (_with_complexity != unlimited)
+    {
+      conditions.push_back("complexity = @COMPLEX");
+    }
+    
     if (_has_antonyms)
     {
       conditions.push_back("adverb_id IN (SELECT adverb_2_id FROM adverb_antonymy)");
@@ -421,6 +523,23 @@ namespace verbly {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
     }
     
+    for (auto prefix : _with_prefix.inorder_flatten())
+    {
+      std::string pfat = prefix + "%";
+      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PREFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
+    }
+    
+    for (auto suffix : _with_suffix.inorder_flatten())
+    {
+      std::string pfat = "%" + suffix;
+      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SUFFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
+    }
+    
+    if (_with_complexity != unlimited)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@COMPLEX"), _with_complexity);
+    }
+    
     for (auto antonym : _antonym_of.inorder_flatten())
     {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);