More hkutil refactoring

All database access goes through hatkirby::database now.

verbly::token, verbly::statement::condition, and verbly::part have been converted to use mpark::variant now. verbly::binding has been deleted, and replaced with a mpark::variant typedef in statement.h. This means that the only remaining tagged union class is verbly::generator::part.

refs #5

1 files changed, 128 insertions, 367 deletions

@@ -5,322 +5,43 @@
 
 namespace verbly {
 
-  token::token(const token& other)
-  {
-    type_ = other.type_;
-
-    switch (type_)
-    {
-      case type::word:
-      {
-        new(&word_.word_) word(other.word_.word_);
-        word_.category_ = other.word_.category_;
-
-        break;
-      }
-
-      case type::literal:
-      {
-        new(&literal_) std::string(other.literal_);
-
-        break;
-      }
-
-      case type::part:
-      {
-        new(&part_) part(other.part_);
-
-        break;
-      }
-
-      case type::fillin:
-      {
-        new(&fillin_) std::set<std::string>(other.fillin_);
-
-        break;
-      }
-
-      case type::utterance:
-      {
-        new(&utterance_) std::list<token>(other.utterance_);
-
-        break;
-      }
-
-      case type::transform:
-      {
-        transform_.type_ = other.transform_.type_;
-        new(&transform_.strParam_) std::string(other.transform_.strParam_);
-        new(&transform_.strParam2_) std::string(other.transform_.strParam2_);
-        transform_.casingParam_ = other.transform_.casingParam_;
-        new(&transform_.inner_) std::unique_ptr<token>(new token(*other.transform_.inner_));
-
-        break;
-      }
-    }
-  }
-
-  token::token(token&& other) : token()
-  {
-    swap(*this, other);
-  }
-
-  token& token::operator=(token other)
-  {
-    swap(*this, other);
-
-    return *this;
-  }
-
-  void swap(token& first, token& second)
-  {
-    using type = token::type;
-    using transform_type = token::transform_type;
-    using casing = token::casing;
-
-    type tempType = first.type_;
-    word tempWord;
-    inflection tempCategory;
-    std::string tempLiteral;
-    part tempPart;
-    std::set<std::string> tempFillin;
-    std::list<token> tempUtterance;
-    transform_type tempTransformType;
-    std::string tempTransformStrParam;
-    std::string tempTransformStrParam2;
-    casing tempTransformCasingParam;
-    std::unique_ptr<token> tempTransformInner;
-
-    switch (tempType)
-    {
-      case type::word:
-      {
-        tempWord = std::move(first.word_.word_);
-        tempCategory = first.word_.category_;
-
-        break;
-      }
-
-      case type::literal:
-      {
-        tempLiteral = std::move(first.literal_);
-
-        break;
-      }
-
-      case type::part:
-      {
-        tempPart = std::move(first.part_);
-
-        break;
-      }
-
-      case type::fillin:
-      {
-        tempFillin = std::move(first.fillin_);
-
-        break;
-      }
-
-      case type::utterance:
-      {
-        tempUtterance = std::move(first.utterance_);
-
-        break;
-      }
-
-      case type::transform:
-      {
-        tempTransformType = first.transform_.type_;
-        tempTransformStrParam = std::move(first.transform_.strParam_);
-        tempTransformStrParam2 = std::move(first.transform_.strParam2_);
-        tempTransformCasingParam = first.transform_.casingParam_;
-        tempTransformInner = std::move(first.transform_.inner_);
-
-        break;
-      }
-    }
-
-    first.~token();
-
-    first.type_ = second.type_;
-
-    switch (first.type_)
-    {
-      case type::word:
-      {
-        new(&first.word_.word_) word(std::move(second.word_.word_));
-        first.word_.category_ = second.word_.category_;
-
-        break;
-      }
-
-      case type::literal:
-      {
-        new(&first.literal_) std::string(std::move(second.literal_));
-
-        break;
-      }
-
-      case type::part:
-      {
-        new(&first.part_) part(std::move(second.part_));
-
-        break;
-      }
-
-      case type::fillin:
-      {
-        new(&first.fillin_) std::set<std::string>(std::move(second.fillin_));
-
-        break;
-      }
-
-      case type::utterance:
-      {
-        new(&first.utterance_) std::list<token>(std::move(second.utterance_));
-
-        break;
-      }
-
-      case type::transform:
-      {
-        first.transform_.type_ = second.transform_.type_;
-        new(&first.transform_.strParam_) std::string(std::move(second.transform_.strParam_));
-        new(&first.transform_.strParam2_) std::string(std::move(second.transform_.strParam2_));
-        first.transform_.casingParam_ = second.transform_.casingParam_;
-        new(&first.transform_.inner_) std::unique_ptr<token>(std::move(second.transform_.inner_));
-
-        break;
-      }
-    }
-
-    second.~token();
-
-    second.type_ = tempType;
-
-    switch (second.type_)
-    {
-      case type::word:
-      {
-        new(&second.word_.word_) word(std::move(tempWord));
-        second.word_.category_ = tempCategory;
-
-        break;
-      }
-
-      case type::literal:
-      {
-        new(&second.literal_) std::string(std::move(tempLiteral));
-
-        break;
-      }
-
-      case type::part:
-      {
-        new(&second.part_) part(std::move(tempPart));
-
-        break;
-      }
-
-      case type::fillin:
-      {
-        new(&second.fillin_) std::set<std::string>(std::move(tempFillin));
-
-        break;
-      }
-
-      case type::utterance:
-      {
-        new(&second.utterance_) std::list<token>(std::move(tempUtterance));
-
-        break;
-      }
-
-      case type::transform:
-      {
-        second.transform_.type_ = tempTransformType;
-        new(&second.transform_.strParam_) std::string(std::move(tempTransformStrParam));
-        new(&second.transform_.strParam2_) std::string(std::move(tempTransformStrParam2));
-        second.transform_.casingParam_ = tempTransformCasingParam;
-        new(&second.transform_.inner_) std::unique_ptr<token>(std::move(tempTransformInner));
-
-        break;
-      }
-    }
-  }
-
-  token::~token()
+  bool token::isComplete() const
   {
     switch (type_)
     {
       case type::word:
-      {
-        word_.word_.~word();
-
-        break;
-      }
-
       case type::literal:
       {
-        using string_type = std::string;
-        literal_.~string_type();
-
-        break;
+        return true;
       }
 
       case type::part:
-      {
-        part_.~part();
-
-        break;
-      }
-
       case type::fillin:
       {
-        using set_type = std::set<std::string>;
-        fillin_.~set_type();
-
-        break;
+        return false;
       }
 
       case type::utterance:
       {
-        using list_type = std::list<token>;
-        utterance_.~list_type();
+        const utterance_type& utterance = mpark::get<utterance_type>(variant_);
 
-        break;
+        return std::all_of(
+          std::begin(utterance),
+          std::end(utterance),
+          [] (const token& tkn) {
+            return tkn.isComplete();
+          });
       }
 
       case type::transform:
       {
-        using string_type = std::string;
-        using ptr_type = std::unique_ptr<token>;
-
-        transform_.strParam_.~string_type();
-        transform_.strParam2_.~string_type();
-        transform_.inner_.~ptr_type();
+        const transform_type& transform = mpark::get<transform_type>(variant_);
 
-        break;
+        return transform.inner->isComplete();
       }
     }
   }
 
-  bool token::isComplete() const
-  {
-    switch (type_)
-    {
-      case type::word: return true;
-      case type::literal: return true;
-      case type::part: return false;
-      case type::fillin: return false;
-      case type::utterance: return std::all_of(std::begin(utterance_), std::end(utterance_), [] (const token& tkn) {
-        return tkn.isComplete();
-      });
-      case type::transform: return transform_.inner_->isComplete();
-    }
-  }
-
   std::string token::compile() const
   {
     return compileHelper(" ", false, casing::normal);
@@ -335,8 +56,9 @@ namespace verbly {
     {
       case type::word:
       {
-        const form& wordForm = word_.word_.getInflections(word_.category_)
-          .front();
+        const word_type& w = mpark::get<word_type>(variant_);
+
+        const form& wordForm = w.value.getInflections(w.category).front();
 
         std::string result = wordForm.getText();
 
@@ -381,13 +103,12 @@ namespace verbly {
           }
         }
 
-
         return result;
       }
 
       case type::literal:
       {
-        std::string result = literal_;
+        std::string result = mpark::get<literal_type>(variant_);
 
         if (indefiniteArticle && std::isalpha(result[0]))
         {
@@ -435,14 +156,19 @@ namespace verbly {
         return result;
       }
 
-      case type::part: throw std::domain_error("Cannot compile incomplete token");
-      case type::fillin: throw std::domain_error("Cannot compile incomplete token");
+      case type::part:
+      case type::fillin:
+      {
+        throw std::domain_error("Cannot compile incomplete token");
+      }
 
       case type::utterance:
       {
+        const utterance_type& utterance = mpark::get<utterance_type>(variant_);
+
         bool first = true;
         std::list<std::string> compiled;
-        for (const token& tkn : utterance_)
+        for (const token& tkn : utterance)
         {
           casing propagateCasing = capitalization;
           if ((capitalization == casing::capitalize) && (!first))
@@ -458,58 +184,70 @@ namespace verbly {
           first = false;
         }
 
-        return hatkirby::implode(std::begin(compiled), std::end(compiled), separator);
+        return hatkirby::implode(
+          std::begin(compiled),
+          std::end(compiled),
+          separator);
       }
 
       case type::transform:
       {
-        switch (transform_.type_)
+        const transform_type& transform = mpark::get<transform_type>(variant_);
+
+        switch (transform.type)
         {
-          case transform_type::separator:
+          case transform_mode::separator:
           {
-            return transform_.inner_->compileHelper(
-              transform_.strParam_, indefiniteArticle, capitalization);
+            return transform.inner->compileHelper(
+              transform.strParam,
+              indefiniteArticle,
+              capitalization);
           }
 
-          case transform_type::punctuation:
+          case transform_mode::punctuation:
           {
-            return transform_.inner_->compileHelper(
-              separator, indefiniteArticle, capitalization)
-              + transform_.strParam_;
+            return transform.inner->compileHelper(
+              separator,
+              indefiniteArticle,
+              capitalization) + transform.strParam;
           }
 
-          case transform_type::indefinite_article:
+          case transform_mode::indefinite_article:
           {
-            return transform_.inner_->compileHelper(
-              separator, true, capitalization);
+            return transform.inner->compileHelper(
+              separator,
+              true,
+              capitalization);
           }
 
-          case transform_type::capitalize:
+          case transform_mode::capitalize:
           {
-            return transform_.inner_->compileHelper(
+            return transform.inner->compileHelper(
               separator,
               indefiniteArticle,
-              transform_.casingParam_);
+              transform.casingParam);
           }
 
-          case transform_type::quote:
+          case transform_mode::quote:
           {
-            return transform_.strParam_ +
-              transform_.inner_->compileHelper(
+            return transform.strParam +
+              transform.inner->compileHelper(
                 separator,
                 indefiniteArticle,
                 capitalization) +
-              transform_.strParam2_;
+              transform.strParam2;
           }
         }
       }
     }
   }
 
-  token::token(word arg, inflection category) : type_(type::word)
+  token::token(
+    word arg,
+    inflection category) :
+      type_(type::word),
+      variant_(word_type { std::move(arg), category })
   {
-    new(&word_.word_) word(std::move(arg));
-    word_.category_ = category;
   }
 
   const word& token::getWord() const
@@ -519,7 +257,7 @@ namespace verbly {
       throw std::domain_error("Token is not a word");
     }
 
-    return word_.word_;
+    return mpark::get<word_type>(variant_).value;
   }
 
   token token::inflect(inflection category) const
@@ -529,46 +267,57 @@ namespace verbly {
       throw std::domain_error("Token is not a word");
     }
 
-    return token(word_.word_, category);
+    return {
+      mpark::get<word_type>(variant_).value,
+      category
+    };
   }
 
-  token::token(std::string arg) : type_(type::literal)
+  token::token(
+    std::string arg) :
+      type_(type::literal),
+      variant_(std::move(arg))
   {
-    new(&literal_) std::string(std::move(arg));
   }
 
-  token::token(const char* arg) : token(std::string(arg))
+  token::token(
+    const char* arg) :
+      token(std::string(arg))
   {
   }
 
-  std::string token::getLiteral() const
+  const std::string& token::getLiteral() const
   {
     if (type_ != type::literal)
     {
       throw std::domain_error("Token is not a literal");
     }
 
-    return literal_;
+    return mpark::get<literal_type>(variant_);
   }
 
-  token::token(part arg) : type_(type::part)
+  token::token(
+    part arg) :
+      type_(type::part),
+      variant_(std::move(arg))
   {
-    new(&part_) part(std::move(arg));
   }
 
-  part token::getPart() const
+ const part& token::getPart() const
   {
     if (type_ != type::part)
     {
       throw std::domain_error("Token is not a part");
     }
 
-    return part_;
+    return mpark::get<part>(variant_);
   }
 
-  token::token(std::set<std::string> synrestrs) : type_(type::fillin)
+  token::token(
+    std::set<std::string> synrestrs) :
+      type_(type::fillin),
+      variant_(std::move(synrestrs))
   {
-    new(&fillin_) std::set<std::string>(std::move(synrestrs));
   }
 
   const std::set<std::string>& token::getSynrestrs() const
@@ -578,7 +327,7 @@ namespace verbly {
       throw std::domain_error("Token is not a fillin");
     }
 
-    return fillin_;
+    return mpark::get<fillin_type>(variant_);
   }
 
   bool token::hasSynrestr(std::string synrestr) const
@@ -588,7 +337,7 @@ namespace verbly {
       throw std::domain_error("Token is not a fillin");
     }
 
-    return (fillin_.count(synrestr) == 1);
+    return mpark::get<fillin_type>(variant_).count(synrestr);
   }
 
   void token::addSynrestr(std::string synrestr)
@@ -598,22 +347,28 @@ namespace verbly {
       throw std::domain_error("Token is not a fillin");
     }
 
-    fillin_.insert(std::move(synrestr));
+    fillin_type& fillin = mpark::get<fillin_type>(variant_);
+    fillin.insert(std::move(synrestr));
   }
 
-  token::token() : type_(type::utterance)
+  token::token() :
+    type_(type::utterance),
+    variant_(utterance_type {})
   {
-    new(&utterance_) std::list<token>();
   }
 
-  token::token(std::vector<part> parts) : type_(type::utterance)
+  token::token(
+    std::vector<part> parts) :
+      type_(type::utterance),
+      variant_(utterance_type { std::begin(parts), std::end(parts) })
   {
-    new(&utterance_) std::list<token>(std::begin(parts), std::end(parts));
   }
 
-  token::token(std::initializer_list<token> parts) : type_(type::utterance)
+  token::token(
+    std::initializer_list<token> parts) :
+      type_(type::utterance),
+      variant_(utterance_type { std::move(parts) })
   {
-    new(&utterance_) std::list<token>(std::move(parts));
   }
 
   token::iterator token::begin()
@@ -623,7 +378,7 @@ namespace verbly {
       throw std::domain_error("Token is not an utterance");
     }
 
-    return std::begin(utterance_);
+    return std::begin(mpark::get<utterance_type>(variant_));
   }
 
   token::const_iterator token::begin() const
@@ -633,7 +388,7 @@ namespace verbly {
       throw std::domain_error("Token is not an utterance");
     }
 
-    return std::begin(utterance_);
+    return std::begin(mpark::get<utterance_type>(variant_));
   }
 
   token::iterator token::end()
@@ -643,7 +398,7 @@ namespace verbly {
       throw std::domain_error("Token is not an utterance");
     }
 
-    return std::end(utterance_);
+    return std::end(mpark::get<utterance_type>(variant_));
   }
 
   token::const_iterator token::end() const
@@ -653,7 +408,7 @@ namespace verbly {
       throw std::domain_error("Token is not an utterance");
     }
 
-    return std::end(utterance_);
+    return std::end(mpark::get<utterance_type>(variant_));
   }
 
   token& token::operator<<(token arg)
@@ -663,35 +418,36 @@ namespace verbly {
       throw std::domain_error("Token is not an utterance");
     }
 
-    utterance_.push_back(std::move(arg));
+    utterance_type& utterance = mpark::get<utterance_type>(variant_);
+    utterance.push_back(std::move(arg));
 
     return *this;
   }
 
   token token::separator(std::string param, token inner)
   {
-    return token(transform_type::separator, std::move(param), "", std::move(inner));
+    return token(transform_mode::separator, std::move(param), "", std::move(inner));
   }
 
   token token::punctuation(std::string param, token inner)
   {
-    return token(transform_type::punctuation, std::move(param), "", std::move(inner));
+    return token(transform_mode::punctuation, std::move(param), "", std::move(inner));
   }
 
   token token::indefiniteArticle(token inner)
   {
-    return token(transform_type::indefinite_article, "", "", std::move(inner));
+    return token(transform_mode::indefinite_article, "", "", std::move(inner));
   }
 
   token token::capitalize(casing param, token inner)
   {
-    return token(transform_type::capitalize, param, std::move(inner));
+    return token(transform_mode::capitalize, param, std::move(inner));
   }
 
   token token::quote(std::string opening, std::string closing, token inner)
   {
     return token(
-      transform_type::quote,
+      transform_mode::quote,
       std::move(opening),
       std::move(closing),
       std::move(inner));
@@ -704,7 +460,7 @@ namespace verbly {
       throw std::domain_error("Invalid access on non-tranform token");
     }
 
-    return *transform_.inner_;
+    return *mpark::get<transform_type>(variant_).inner;
   }
 
   const token& token::getInnerToken() const
@@ -714,33 +470,38 @@ namespace verbly {
       throw std::domain_error("Invalid access on non-tranform token");
     }
 
-    return *transform_.inner_;
+    return *mpark::get<transform_type>(variant_).inner;
   }
 
   token::token(
-    transform_type type,
+    transform_mode type,
     std::string param1,
     std::string param2,
     token inner) :
-      type_(type::transform)
+      type_(type::transform),
+      variant_(transform_type {
+        type,
+        std::move(param1),
+        std::move(param2),
+        casing::normal,
+        new token(std::move(inner))
+      })
   {
-    transform_.type_ = type;
-    new(&transform_.strParam_) std::string(std::move(param1));
-    new(&transform_.strParam2_) std::string(std::move(param2));
-    new(&transform_.inner_) std::unique_ptr<token>(new token(std::move(inner)));
   }
 
   token::token(
-    transform_type type,
+    transform_mode type,
     casing param,
     token inner) :
-      type_(type::transform)
+      type_(type::transform),
+      variant_(transform_type {
+        type,
+        {},
+        {},
+        param,
+        new token(std::move(inner))
+      })
   {
-    transform_.type_ = type;
-    new(&transform_.strParam_) std::string();
-    new(&transform_.strParam2_) std::string();
-    transform_.casingParam_ = param;
-    new(&transform_.inner_) std::unique_ptr<token>(new token(std::move(inner)));
   }
 
   std::ostream& operator<<(std::ostream& os, token::type type)