8 files changed, 433 insertions, 0 deletions

@@ -53,6 +53,29 @@ namespace verbly {
     return *this;
   }
   
+  adjective_query& adjective_query::with_prefix(filter<std::string> _f)
+  {
+    _f.clean();
+    _with_prefix = _f;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::with_suffix(filter<std::string> _f)
+  {
+    _f.clean();
+    _with_suffix = _f;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::with_complexity(int _arg)
+  {
+    _with_complexity = _arg;
+    
+    return *this;
+  }
+  
   adjective_query& adjective_query::is_variant()
   {
     this->_is_variant = true;
@@ -231,6 +254,85 @@ namespace verbly {
       case adjective::positioning::undefined: break;
     }
     
+    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 (_is_variant)
     {
       conditions.push_back("adjective_id IN (SELECT adjective_id FROM variation)");
@@ -691,6 +793,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 attribute : _variant_of.inorder_flatten())
     {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ATTRID"), attribute._id);
@@ -17,6 +17,11 @@ namespace verbly {
       adjective_query& requires_superlative_form();
       adjective_query& position(adjective::positioning pos);
       
+      adjective_query& with_prefix(filter<std::string> _f);
+      adjective_query& with_suffix(filter<std::string> _f);
+      
+      adjective_query& with_complexity(int _arg);
+      
       adjective_query& is_variant();
       adjective_query& variant_of(filter<noun> _f);
       
@@ -57,6 +62,11 @@ namespace verbly {
       bool _requires_superlative_form = false;
       adjective::positioning _position = adjective::positioning::undefined;
       
+      filter<std::string> _with_prefix;
+      filter<std::string> _with_suffix;
+      
+      int _with_complexity = unlimited;
+      
       bool _is_variant = false;
       filter<noun> _variant_of;
             
@@ -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);
@@ -16,6 +16,11 @@ namespace verbly {
       adverb_query& requires_comparative_form();
       adverb_query& requires_superlative_form();
       
+      adverb_query& with_prefix(filter<std::string> _f);
+      adverb_query& with_suffix(filter<std::string> _f);
+      
+      adverb_query& with_complexity(int _arg);
+      
       adverb_query& has_antonyms();
       adverb_query& antonym_of(filter<adverb> _f);
       
@@ -43,6 +48,11 @@ namespace verbly {
       bool _requires_comparative_form = false;
       bool _requires_superlative_form = false;
       
+      filter<std::string> _with_prefix;
+      filter<std::string> _with_suffix;
+      
+      int _with_complexity = unlimited;
+      
       bool _has_antonyms = false;
       filter<adverb> _antonym_of;
       
@@ -77,6 +77,13 @@ namespace verbly {
     return _data->nouns().part_meronym_of(*this);
   }
   
+  noun_query noun::full_part_meronyms() const
+  {
+    assert(_valid == true);
+    
+    return _data->nouns().full_part_meronym_of(*this);
+  }
+  
   noun_query noun::part_holonyms() const
   {
     assert(_valid == true);
@@ -84,6 +91,13 @@ namespace verbly {
     return _data->nouns().part_holonym_of(*this);
   }
   
+  noun_query noun::full_part_holonyms() const
+  {
+    assert(_valid == true);
+    
+    return _data->nouns().full_part_holonym_of(*this);
+  }
+  
   noun_query noun::substance_meronyms() const
   {
     assert(_valid == true);
@@ -91,6 +105,13 @@ namespace verbly {
     return _data->nouns().substance_meronym_of(*this);
   }
   
+  noun_query noun::full_substance_meronyms() const
+  {
+    assert(_valid == true);
+    
+    return _data->nouns().full_substance_meronym_of(*this);
+  }
+  
   noun_query noun::substance_holonyms() const
   {
     assert(_valid == true);
@@ -98,6 +119,13 @@ namespace verbly {
     return _data->nouns().substance_holonym_of(*this);
   }
   
+  noun_query noun::full_substance_holonyms() const
+  {
+    assert(_valid == true);
+    
+    return _data->nouns().full_substance_holonym_of(*this);
+  }
+  
   noun_query noun::member_meronyms() const
   {
     assert(_valid == true);
@@ -105,6 +133,13 @@ namespace verbly {
     return _data->nouns().member_meronym_of(*this);
   }
   
+  noun_query noun::full_member_meronyms() const
+  {
+    assert(_valid == true);
+    
+    return _data->nouns().full_member_meronym_of(*this);
+  }
+  
   noun_query noun::member_holonyms() const
   {
     assert(_valid == true);
@@ -112,6 +147,13 @@ namespace verbly {
     return _data->nouns().member_holonym_of(*this);
   }
   
+  noun_query noun::full_member_holonyms() const
+  {
+    assert(_valid == true);
+    
+    return _data->nouns().full_member_holonym_of(*this);
+  }
+  
   noun_query noun::classes() const
   {
     assert(_valid == true);
@@ -25,11 +25,17 @@ namespace verbly {
       noun_query hyponyms() const;
       noun_query full_hyponyms() const;
       noun_query part_meronyms() const;
+      noun_query full_part_meronyms() const;
       noun_query part_holonyms() const;
+      noun_query full_part_holonyms() const;
       noun_query substance_meronyms() const;
+      noun_query full_substance_meronyms() const;
       noun_query substance_holonyms() const;
+      noun_query full_substance_holonyms() const;
       noun_query member_meronyms() const;
+      noun_query full_member_meronyms() const;
       noun_query member_holonyms() const;
+      noun_query full_member_holonyms() const;
       noun_query classes() const;
       noun_query instances() const;
       noun_query synonyms() const;
@@ -60,6 +60,29 @@ namespace verbly {
     return *this;
   }
   
+  noun_query& noun_query::with_prefix(filter<std::string> _f)
+  {
+    _f.clean();
+    _with_prefix = _f;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::with_suffix(filter<std::string> _f)
+  {
+    _f.clean();
+    _with_suffix = _f;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::with_complexity(int _arg)
+  {
+    _with_complexity = _arg;
+    
+    return *this;
+  }
+  
   noun_query& noun_query::is_hypernym()
   {
     _is_hypernym = true;
@@ -461,6 +484,85 @@ namespace verbly {
       conditions.push_back(cond);
     }
     
+    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 "singular LIKE @PREFIX";
+            } else {
+              return "singular 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 "singular LIKE @SUFFIX";
+            } else {
+              return "singular 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 (_is_hypernym)
     {
       conditions.push_back("noun_id IN (SELECT hypernym_id FROM hypernymy)");
@@ -1610,6 +1712,23 @@ namespace verbly {
       sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SFORM"), sform.c_str(), sform.size(), SQLITE_STATIC);
     }
     
+    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 hyponym : _hypernym_of.inorder_flatten())
     {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@HYPO"), hyponym._id);
@@ -14,6 +14,10 @@ namespace verbly {
       noun_query& has_pronunciation();
       
       noun_query& with_singular_form(std::string _arg);
+      noun_query& with_prefix(filter<std::string> _f);
+      noun_query& with_suffix(filter<std::string> _f);
+      
+      noun_query& with_complexity(int _arg);
       
       noun_query& is_hypernym();
       noun_query& hypernym_of(filter<noun> _f);
@@ -84,6 +88,10 @@ namespace verbly {
       bool _has_prn = false;
       
       std::list<std::string> _with_singular_form;
+      filter<std::string> _with_prefix;
+      filter<std::string> _with_suffix;
+      
+      int _with_complexity = unlimited;
       
       bool _is_hypernym = false;
       filter<noun> _hypernym_of;