13 files changed, 20 insertions, 431 deletions

@@ -6,7 +6,7 @@ pkg_check_modules(sqlite3 sqlite3 REQUIRED)
 find_package(libxml2 REQUIRED)
 
 include_directories(${sqlite3_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR} ../vendor/json)
-add_executable(generator notion.cpp word.cpp lemma.cpp form.cpp pronunciation.cpp group.cpp frame.cpp part.cpp selrestr.cpp database.cpp field.cpp generator.cpp main.cpp)
+add_executable(generator notion.cpp word.cpp lemma.cpp form.cpp pronunciation.cpp group.cpp frame.cpp part.cpp ../lib/selrestr.cpp database.cpp field.cpp generator.cpp main.cpp)
 set_property(TARGET generator PROPERTY CXX_STANDARD 11)
 set_property(TARGET generator PROPERTY CXX_STANDARD_REQUIRED ON)
 target_link_libraries(generator ${sqlite3_LIBRARIES} ${LIBXML2_LIBRARIES})
@@ -5,10 +5,10 @@
 #include <regex>
 #include <dirent.h>
 #include <fstream>
-#include "enums.h"
+#include "../lib/enums.h"
 #include "progress.h"
-#include "selrestr.h"
-#include "role.h"
+#include "../lib/selrestr.h"
+#include "../lib/role.h"
 #include "part.h"
 #include "field.h"
 #include "../lib/util.h"
@@ -1290,21 +1290,20 @@ namespace verbly {
           {
             if (!xmlStrcmp(roletopnode->name, reinterpret_cast<const xmlChar*>("THEMROLE")))
             {
-              role r;
-              
               key = xmlGetProp(roletopnode, reinterpret_cast<const xmlChar*>("type"));
               std::string roleName = reinterpret_cast<const char*>(key);
               xmlFree(key);
               
+              selrestr roleSelrestrs;
               for (xmlNodePtr rolenode = roletopnode->xmlChildrenNode; rolenode != nullptr; rolenode = rolenode->next)
               {
                 if (!xmlStrcmp(rolenode->name, reinterpret_cast<const xmlChar*>("SELRESTRS")))
                 {
-                  r.setSelrestrs(parseSelrestr(rolenode));
+                  roleSelrestrs = parseSelrestr(rolenode);
                 }
               }
 
-              grp.addRole(roleName, std::move(r));
+              grp.addRole({roleName, std::move(roleSelrestrs)});
             }
           }
         } else if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("FRAMES")))
@@ -16,10 +16,11 @@
 #include "frame.h"
 
 namespace verbly {
+  
+  enum class part_of_speech;
+  class selrestr;
+  
   namespace generator {
-
-    enum class part_of_speech;
-    class selrestr;
     
     class generator {
     public:
@@ -23,10 +23,11 @@ namespace verbly {
       parent_ = &parent;
     }
     
-    void group::addRole(std::string name, role r)
+    void group::addRole(role r)
     {
-      roleNames_.insert(name);
+      std::string name = r.getName();
       roles_[name] = std::move(r);
+      roleNames_.insert(std::move(name));
     }
     
     void group::addFrame(const frame& f)
@@ -5,7 +5,7 @@
 #include <set>
 #include <string>
 #include <cassert>
-#include "role.h"
+#include "../lib/role.h"
 
 namespace verbly {
   namespace generator {
@@ -24,7 +24,7 @@ namespace verbly {
       
       void setParent(const group& parent);
       
-      void addRole(std::string name, role r);
+      void addRole(role r);
       
       void addFrame(const frame& f);
       
@@ -4,7 +4,7 @@
 #include <string>
 #include <map>
 #include <set>
-#include "enums.h"
+#include "../lib/enums.h"
 
 namespace verbly {
   namespace generator {
@@ -4,7 +4,7 @@
 #include <cassert>
 #include <list>
 #include <string>
-#include "enums.h"
+#include "../lib/enums.h"
 
 namespace verbly {
   namespace generator {
@@ -1,6 +1,5 @@
 #include "part.h"
 #include <stdexcept>
-#include "selrestr.h"
 
 namespace verbly {
   namespace generator {
@@ -3,7 +3,7 @@
 
 #include <string>
 #include <set>
-#include "selrestr.h"
+#include "../lib/selrestr.h"
 
 namespace verbly {
   namespace generator {
@@ -1,35 +0,0 @@
-#ifndef ROLE_H_249F9A9C
-#define ROLE_H_249F9A9C
-
-#include "selrestr.h"
-
-namespace verbly {
-  namespace generator {
-    
-    class role {
-    public:
-      
-      // Mutators
-      
-      void setSelrestrs(selrestr selrestrs)
-      {
-        selrestrs_ = selrestrs;
-      }
-      
-      // Accessors
-      
-      const selrestr& getSelrestrs() const
-      {
-        return selrestrs_;
-      }
-      
-    private:
-      
-      selrestr selrestrs_;
-      
-    };
-    
-  };
-};
-
-#endif /* end of include guard: ROLE_H_249F9A9C */
@@ -1,288 +0,0 @@
-#include "selrestr.h"
-
-namespace verbly {
-  namespace generator {
-    
-    selrestr::selrestr(const selrestr& other)
-    {
-      type_ = other.type_;
-      
-      switch (type_)
-      {
-        case type::singleton:
-        {
-          singleton_.pos = other.singleton_.pos;
-          new(&singleton_.restriction) std::string(other.singleton_.restriction);
-          
-          break;
-        }
-        
-        case type::group:
-        {
-          new(&group_.children) std::list<selrestr>(other.group_.children);
-          group_.orlogic = other.group_.orlogic;
-          
-          break;
-        }
-        
-        case type::empty:
-        {
-          break;
-        }
-      }
-    }
-    
-    selrestr::selrestr(selrestr&& other) : selrestr()
-    {
-      swap(*this, other);
-    }
-    
-    selrestr& selrestr::operator=(selrestr other)
-    {
-      swap(*this, other);
-      
-      return *this;
-    }
-    
-    void swap(selrestr& first, selrestr& second)
-    {
-      using type = selrestr::type;
-      
-      type tempType = first.type_;
-      int tempPos;
-      std::string tempRestriction;
-      std::list<selrestr> tempChildren;
-      bool tempOrlogic;
-      
-      switch (tempType)
-      {
-        case type::singleton:
-        {
-          tempPos = first.singleton_.pos;
-          tempRestriction = std::move(first.singleton_.restriction);
-          
-          break;
-        }
-        
-        case type::group:
-        {
-          tempChildren = std::move(first.group_.children);
-          tempOrlogic = first.group_.orlogic;
-          
-          break;
-        }
-        
-        case type::empty:
-        {
-          break;
-        }
-      }
-      
-      first.~selrestr();
-      
-      first.type_ = second.type_;
-      
-      switch (first.type_)
-      {
-        case type::singleton:
-        {
-          first.singleton_.pos = second.singleton_.pos;
-          new(&first.singleton_.restriction) std::string(std::move(second.singleton_.restriction));
-          
-          break;
-        }
-        
-        case type::group:
-        {
-          new(&first.group_.children) std::list<selrestr>(std::move(second.group_.children));
-          first.group_.orlogic = second.group_.orlogic;
-          
-          break;
-        }
-        
-        case type::empty:
-        {
-          break;
-        }
-      }
-      
-      second.~selrestr();
-      
-      second.type_ = tempType;
-      
-      switch (second.type_)
-      {
-        case type::singleton:
-        {
-          second.singleton_.pos = tempPos;
-          new(&second.singleton_.restriction) std::string(std::move(tempRestriction));
-          
-          break;
-        }
-        
-        case type::group:
-        {
-          new(&second.group_.children) std::list<selrestr>(std::move(tempChildren));
-          second.group_.orlogic = tempOrlogic;
-          
-          break;
-        }
-        
-        case type::empty:
-        {
-          break;
-        }
-      }
-    }
-    
-    selrestr::~selrestr()
-    {
-      switch (type_)
-      {
-        case type::singleton:
-        {
-          using string_type = std::string;
-          singleton_.restriction.~string_type();
-          
-          break;
-        }
-        
-        case type::group:
-        {
-          using list_type = std::list<selrestr>;
-          group_.children.~list_type();
-          
-          break;
-        }
-        
-        case type::empty:
-        {
-          break;
-        }
-      }
-    }
-    
-    selrestr::selrestr() : type_(type::empty)
-    {
-    }
-    
-    selrestr::selrestr(
-      std::string restriction,
-      bool pos) :
-        type_(type::singleton)
-    {
-      new(&singleton_.restriction) std::string(std::move(restriction));
-      singleton_.pos = pos;
-    }
-    
-    std::string selrestr::getRestriction() const
-    {
-      if (type_ == type::singleton)
-      {
-        return singleton_.restriction;
-      } else {
-        throw std::domain_error("Only singleton selrestrs have restrictions");
-      }
-    }
-    
-    bool selrestr::getPos() const
-    {
-      if (type_ == type::singleton)
-      {
-        return singleton_.pos;
-      } else {
-        throw std::domain_error("Only singleton selrestrs have positivity flags");
-      }
-    }
-    
-    selrestr::selrestr(
-      std::list<selrestr> children,
-      bool orlogic) :
-        type_(type::group)
-    {
-      new(&group_.children) std::list<selrestr>(std::move(children));
-      group_.orlogic = orlogic;
-    }
-    
-    std::list<selrestr> selrestr::getChildren() const
-    {
-      if (type_ == type::group)
-      {
-        return group_.children;
-      } else {
-        throw std::domain_error("Only group selrestrs have children");
-      }
-    }
-    
-    std::list<selrestr>::const_iterator selrestr::begin() const
-    {
-      if (type_ == type::group)
-      {
-        return std::begin(group_.children);
-      } else {
-        throw std::domain_error("Only group selrestrs have children");
-      }
-    }
-    
-    std::list<selrestr>::const_iterator selrestr::end() const
-    {
-      if (type_ == type::group)
-      {
-        return std::end(group_.children);
-      } else {
-        throw std::domain_error("Only group selrestrs have children");
-      }
-    }
-    
-    bool selrestr::getOrlogic() const
-    {
-      if (type_ == type::group)
-      {
-        return group_.orlogic;
-      } else {
-        throw std::domain_error("Only group selrestrs have logic");
-      }
-    }
-    
-    nlohmann::json selrestr::toJson() const
-    {
-      switch (type_)
-      {
-        case type::empty:
-        {
-          return {};
-        }
-        
-        case type::singleton:
-        {
-          return {
-            {"type", singleton_.restriction},
-            {"pos", singleton_.pos}
-          };
-        }
-        
-        case type::group:
-        {
-          std::string logic;
-          if (group_.orlogic)
-          {
-            logic = "or";
-          } else {
-            logic = "and";
-          }
-          
-          std::list<nlohmann::json> children;
-          std::transform(std::begin(group_.children), std::end(group_.children), std::back_inserter(children), [] (const selrestr& child) {
-            return child.toJson();
-          });
-          
-          return {
-            {"logic", logic},
-            {"children", children}
-          };
-        }
-      }
-    }
-    
-  };
-};
@@ -1,88 +0,0 @@
-#ifndef SELRESTR_H_50652FB7
-#define SELRESTR_H_50652FB7
-
-#include <list>
-#include <string>
-#include <json.hpp>
-
-namespace verbly {
-  namespace generator {
-    
-    class selrestr {
-    public:
-      enum class type {
-        empty,
-        singleton,
-        group
-      };
-      
-      // Copy and move constructors
-      
-      selrestr(const selrestr& other);
-      selrestr(selrestr&& other);
-      
-      // Assignment
-      
-      selrestr& operator=(selrestr other);
-      
-      // Swap
-      
-      friend void swap(selrestr& first, selrestr& second);
-      
-      // Destructor
-      
-      ~selrestr();
-      
-      // Generic accessors
-      
-      type getType() const
-      {
-        return type_;
-      }
-      
-      // Empty
-      
-      selrestr();
-      
-      // Singleton
-      
-      selrestr(std::string restriction, bool pos);
-      
-      std::string getRestriction() const;
-      
-      bool getPos() const;
-      
-      // Group
-      
-      selrestr(std::list<selrestr> children, bool orlogic);
-      
-      std::list<selrestr> getChildren() const;
-      
-      std::list<selrestr>::const_iterator begin() const;
-      
-      std::list<selrestr>::const_iterator end() const;
-      
-      bool getOrlogic() const;
-      
-      // Helpers
-      
-      nlohmann::json toJson() const;
-      
-    private:
-      union {
-        struct {
-          bool pos;
-          std::string restriction;
-        } singleton_;
-        struct {
-          std::list<selrestr> children;
-          bool orlogic;
-        } group_;
-      };
-      type type_;
-    };
-    
-  };
-};
-
-#endif /* end of include guard: SELRESTR_H_50652FB7 */
@@ -2,7 +2,7 @@
 #define WORD_H_91F99D46
 
 #include <cassert>
-#include "enums.h"
+#include "../lib/enums.h"
 
 namespace verbly {
   namespace generator {