1 files changed, 298 insertions, 1 deletions

@@ -2,7 +2,6 @@
 #define DATA_H_C4AEC3DD
 
 #include <sqlite3.h>
-#include <stdexcept>
 
 namespace verbly {
   
@@ -12,10 +11,13 @@ namespace verbly {
   class noun;
   class verb;
   class adverb;
+  class frame;
   class adjective_query;
   class adverb_query;
   class noun_query;
   class verb_query;
+  class frame_query;
+  class preposition_query;
   
   class data {
     private:
@@ -25,6 +27,8 @@ namespace verbly {
       friend class noun_query;
       friend class verb_query;
       friend class adverb_query;
+      friend class frame_query;
+      friend class preposition_query;
       
     public:
       data(std::string datafile);
@@ -41,9 +45,302 @@ namespace verbly {
       adjective_query adjectives() const;
       adverb_query adverbs() const;
       noun_query nouns() const;
+      frame_query frames() const;
+      preposition_query prepositions() const;
       
   };
   
+  template <class T>
+  class filter {
+    public:
+      enum class type {
+        singleton,
+        group
+      };
+      
+      typedef filter<T> value_type;
+      
+      type get_type() const
+      {
+        return _type;
+      }
+      
+      filter(const filter<T>& other)
+      {
+        _type = other._type;
+        _notlogic = other._notlogic;
+        
+        switch (_type)
+        {
+          case type::singleton:
+          {
+            new(&_singleton.elem) T(other._singleton.elem);
+            
+            break;
+          }
+          
+          case type::group:
+          {
+            new(&_group.elems) std::list<filter<T>>(other._group.elems);
+            _group.orlogic = other._group.orlogic;
+            
+            break;
+          }
+        }
+      }
+      
+      filter<T>& operator=(const filter<T>& other)
+      {
+        this->~filter();
+        
+        _type = other._type;
+        _notlogic = other._notlogic;
+        
+        switch (_type)
+        {
+          case type::singleton:
+          {
+            new(&_singleton.elem) T(other._singleton.elem);
+            
+            break;
+          }
+          
+          case type::group:
+          {
+            new(&_group.elems) std::list<filter<T>>(other._group.elems);
+            _group.orlogic = other._group.orlogic;
+            
+            break;
+          }
+        }
+        
+        return *this;
+      }
+      
+      ~filter()
+      {
+        switch (_type)
+        {
+          case type::singleton:
+          {
+            _singleton.elem.~T();
+            
+            break;
+          }
+          
+          case type::group:
+          {
+            using list_type = std::list<filter<T>>;
+            _group.elems.~list_type();
+            
+            break;
+          }
+        }
+      }
+      
+      bool get_notlogic() const
+      {
+        return _notlogic;
+      }
+      
+      void set_notlogic(bool _nl)
+      {
+        _notlogic = _nl;
+      }
+      
+      std::list<T> inorder_flatten() const
+      {
+        std::list<T> result;
+        
+        if (_type == type::singleton)
+        {
+          result.push_back(_singleton.elem);
+        } else if (_type == type::group)
+        {
+          for (auto elem : _group.elems)
+          {
+            auto l = elem.inorder_flatten();
+            result.insert(std::end(result), std::begin(l), std::end(l));
+          }
+        }
+        
+        return result;
+      }
+      
+      std::set<T> uniq_flatten() const
+      {
+        std::set<T> result;
+        
+        if (_type == type::singleton)
+        {
+          result.insert(_singleton.elem);
+        } else if (_type == type::group)
+        {
+          for (auto elem : _group.elems)
+          {
+            auto l = elem.uniq_flatten();
+            result.insert(std::begin(l), std::end(l));
+          }
+        }
+        
+        return result;
+      }
+      
+      void clean()
+      {
+        if (_type == type::group)
+        {
+          std::list<typename std::list<filter<T>>::iterator> toremove;
+          for (auto it = _group.elems.begin(); it != _group.elems.end(); it++)
+          {
+            it->clean();
+            
+            if (it->get_type() == type::group)
+            {
+              if (it->_group.elems.size() == 0)
+              {
+                toremove.push_back(it);
+              } else if (it->_group.elems.size() == 1)
+              {
+                bool truelogic = it->_notlogic != it->_group.elems.front()._notlogic;
+                *it = it->_group.elems.front();
+                it->_notlogic = truelogic;
+              }
+            }
+          }
+          
+          for (auto rem : toremove)
+          {
+            _group.elems.erase(rem);
+          }
+          
+          if (_group.elems.size() == 1)
+          {
+            bool truelogic = _notlogic != _group.elems.front()._notlogic;
+            *this = _group.elems.front();
+            _notlogic = truelogic;
+          }
+        }
+      }
+      
+      // Singleton
+      filter(T _elem, bool _notlogic = false) : _type(type::singleton)
+      {
+        new(&_singleton.elem) T(_elem);
+        this->_notlogic = _notlogic;
+      }
+      
+      filter<T>& operator=(T _elem)
+      {
+        *this = filter<T>{_elem};
+        
+        return *this;
+      }
+      
+      T get_elem() const
+      {
+        assert(_type == type::singleton);
+        
+        return _singleton.elem;
+      }
+      
+      void set_elem(T _elem)
+      {
+        assert(_type == type::singleton);
+        
+        _singleton.elem = _elem;
+      }
+      
+      // Group
+      typedef typename std::list<filter<T>>::iterator iterator;
+      
+      filter() : _type(type::group)
+      {
+        new(&_group.elems) std::list<filter<T>>();
+        _group.orlogic = false;
+      }
+      
+      filter(std::initializer_list<filter<T>> _init) : _type(type::group)
+      {
+        new(&_group.elems) std::list<filter<T>>(_init);
+        _group.orlogic = false;
+      }
+      
+      iterator begin()
+      {
+        assert(_type == type::group);
+        
+        return _group.elems.begin();
+      }
+      
+      iterator end()
+      {
+        assert(_type == type::group);
+        
+        return _group.elems.end();
+      }
+      
+      filter<T>& operator<<(filter<T> _elem)
+      {
+        assert(_type == type::group);
+        
+        _group.elems.push_back(_elem);
+        
+        return *this;
+      }
+      
+      void push_back(filter<T> _elem)
+      {
+        assert(_type == type::group);
+        
+        _group.elems.push_back(_elem);
+      }
+      
+      bool get_orlogic() const
+      {
+        assert(_type == type::group);
+        
+        return _group.orlogic;
+      }
+      
+      void set_orlogic(bool _ol)
+      {
+        assert(_type == type::group);
+        
+        _group.orlogic = _ol;
+      }
+      
+      bool empty() const
+      {
+        if (_type == type::group)
+        {
+          return _group.elems.empty();
+        } else {
+          return false;
+        }
+      }
+      
+      int size() const
+      {
+        assert(_type == type::group);
+        
+        return _group.elems.size();
+      }
+      
+    private:
+      type _type;
+      bool _notlogic = false;
+      union {
+        struct {
+          T elem;
+        } _singleton;
+        struct {
+          std::list<filter<T>> elems;
+          bool orlogic;
+        } _group;
+      };
+  };
+  
 };
 
 #endif /* end of include guard: DATA_H_C4AEC3DD */