Converted verbly::generator::part to std::variant

fixes #5

1 files changed, 17 insertions, 288 deletions

@@ -8,13 +8,11 @@ namespace verbly {
 
     part part::createNounPhrase(std::string role, std::set<std::string> selrestrs, std::set<std::string> synrestrs)
     {
-      part p(type::noun_phrase);
-
-      new(&p.noun_phrase_.role) std::string(std::move(role));
-      new(&p.noun_phrase_.selrestrs) std::set<std::string>(std::move(selrestrs));
-      new(&p.noun_phrase_.synrestrs) std::set<std::string>(std::move(synrestrs));
-
-      return p;
+      return part(type::noun_phrase, noun_phrase_type {
+        .role = std::move(role),
+        .selrestrs = std::move(selrestrs),
+        .synrestrs = std::move(synrestrs)
+      });
     }
 
     part part::createVerb()
@@ -24,12 +22,10 @@ namespace verbly {
 
     part part::createPreposition(std::set<std::string> choices, bool literal)
     {
-      part p(type::preposition);
-
-      new(&p.preposition_.choices) std::set<std::string>(std::move(choices));
-      p.preposition_.literal = literal;
-
-      return p;
+      return part(type::preposition, preposition_type {
+        .choices = std::move(choices),
+        .literal = literal
+      });
     }
 
     part part::createAdjective()
@@ -44,286 +40,19 @@ namespace verbly {
 
     part part::createLiteral(std::string value)
     {
-      part p(type::literal);
-
-      new(&p.literal_) std::string(std::move(value));
-
-      return p;
+      return part(type::literal, std::move(value));
     }
 
     part part::duplicate(const part& other)
     {
-      part result(other.type_);
-
-      switch (result.type_)
-      {
-        case type::noun_phrase:
-        {
-          new(&result.noun_phrase_.role) std::string(other.noun_phrase_.role);
-          new(&result.noun_phrase_.selrestrs) std::set<std::string>(other.noun_phrase_.selrestrs);
-          new(&result.noun_phrase_.synrestrs) std::set<std::string>(other.noun_phrase_.synrestrs);
-
-          break;
-        }
-
-        case type::preposition:
-        {
-          new(&result.preposition_.choices) std::set<std::string>(other.preposition_.choices);
-          result.preposition_.literal = other.preposition_.literal;
-
-          break;
-        }
-
-        case type::literal:
-        {
-          new(&result.literal_) std::string(other.literal_);
-
-          break;
-        }
-
-        case type::verb:
-        case type::adjective:
-        case type::adverb:
-        case type::invalid:
-        {
-          break;
-        }
-      }
-
-      return result;
-    }
-
-    part::part(const part& other)
-    {
-      type_ = other.type_;
-      id_ = other.id_;
-
-      switch (type_)
-      {
-        case type::noun_phrase:
-        {
-          new(&noun_phrase_.role) std::string(other.noun_phrase_.role);
-          new(&noun_phrase_.selrestrs) std::set<std::string>(other.noun_phrase_.selrestrs);
-          new(&noun_phrase_.synrestrs) std::set<std::string>(other.noun_phrase_.synrestrs);
-
-          break;
-        }
-
-        case type::preposition:
-        {
-          new(&preposition_.choices) std::set<std::string>(other.preposition_.choices);
-          preposition_.literal = other.preposition_.literal;
-
-          break;
-        }
-
-        case type::literal:
-        {
-          new(&literal_) std::string(other.literal_);
-
-          break;
-        }
-
-        case type::verb:
-        case type::adjective:
-        case type::adverb:
-        case type::invalid:
-        {
-          break;
-        }
-      }
-    }
-
-    part::part(part&& other) : part()
-    {
-      swap(*this, other);
-    }
-
-    part& part::operator=(part other)
-    {
-      swap(*this, other);
-
-      return *this;
-    }
-
-    void swap(part& first, part& second)
-    {
-      using type = part::type;
-
-      type tempType = first.type_;
-      int tempId = first.id_;
-      std::string tempRole;
-      std::set<std::string> tempSelrestrs;
-      std::set<std::string> tempSynrestrs;
-      std::set<std::string> tempChoices;
-      bool tempPrepLiteral;
-      std::string tempLiteralValue;
-
-      switch (tempType)
-      {
-        case type::noun_phrase:
-        {
-          tempRole = std::move(first.noun_phrase_.role);
-          tempSelrestrs = std::move(first.noun_phrase_.selrestrs);
-          tempSynrestrs = std::move(first.noun_phrase_.synrestrs);
-
-          break;
-        }
-
-        case type::preposition:
-        {
-          tempChoices = std::move(first.preposition_.choices);
-          tempPrepLiteral = first.preposition_.literal;
-
-          break;
-        }
-
-        case type::literal:
-        {
-          tempLiteralValue = std::move(first.literal_);
-
-          break;
-        }
-
-        case type::verb:
-        case type::adjective:
-        case type::adverb:
-        case type::invalid:
-        {
-          break;
-        }
-      }
-
-      first.~part();
-
-      first.type_ = second.type_;
-      first.id_ = second.id_;
-
-      switch (first.type_)
-      {
-        case type::noun_phrase:
-        {
-          new(&first.noun_phrase_.role) std::string(std::move(second.noun_phrase_.role));
-          new(&first.noun_phrase_.selrestrs) std::set<std::string>(std::move(second.noun_phrase_.selrestrs));
-          new(&first.noun_phrase_.synrestrs) std::set<std::string>(std::move(second.noun_phrase_.synrestrs));
-
-          break;
-        }
-
-        case type::preposition:
-        {
-          new(&first.preposition_.choices) std::set<std::string>(std::move(second.preposition_.choices));
-          first.preposition_.literal = second.preposition_.literal;
-
-          break;
-        }
-
-        case type::literal:
-        {
-          new(&first.literal_) std::string(std::move(second.literal_));
-
-          break;
-        }
-
-        case type::verb:
-        case type::adjective:
-        case type::adverb:
-        case type::invalid:
-        {
-          break;
-        }
-      }
-
-      second.~part();
-
-      second.type_ = tempType;
-      second.id_ = tempId;
-
-      switch (second.type_)
-      {
-        case type::noun_phrase:
-        {
-          new(&second.noun_phrase_.role) std::string(std::move(tempRole));
-          new(&second.noun_phrase_.selrestrs) std::set<std::string>(std::move(tempSelrestrs));
-          new(&second.noun_phrase_.synrestrs) std::set<std::string>(std::move(tempSynrestrs));
-
-          break;
-        }
-
-        case type::preposition:
-        {
-          new(&second.preposition_.choices) std::set<std::string>(std::move(tempChoices));
-          second.preposition_.literal = tempPrepLiteral;
-
-          break;
-        }
-
-        case type::literal:
-        {
-          new(&second.literal_) std::string(std::move(tempLiteralValue));
-
-          break;
-        }
-
-        case type::verb:
-        case type::adjective:
-        case type::adverb:
-        case type::invalid:
-        {
-          break;
-        }
-      }
-    }
-
-    part::~part()
-    {
-      switch (type_)
-      {
-        case type::noun_phrase:
-        {
-          using string_type = std::string;
-          using set_type = std::set<std::string>;
-
-          noun_phrase_.role.~string_type();
-          noun_phrase_.selrestrs.~set_type();
-          noun_phrase_.synrestrs.~set_type();
-
-          break;
-        }
-
-        case type::preposition:
-        {
-          using set_type = std::set<std::string>;
-
-          preposition_.choices.~set_type();
-
-          break;
-        }
-
-        case type::literal:
-        {
-          using string_type = std::string;
-
-          literal_.~string_type();
-
-          break;
-        }
-
-        case type::verb:
-        case type::adjective:
-        case type::adverb:
-        case type::invalid:
-        {
-          break;
-        }
-      }
+      return part(other.type_, other.variant_);
     }
 
     std::string part::getNounRole() const
     {
       if (type_ == type::noun_phrase)
       {
-        return noun_phrase_.role;
+        return std::get<noun_phrase_type>(variant_).role;
       } else {
         throw std::domain_error("part::getNounRole is only valid for noun phrase parts");
       }
@@ -333,7 +62,7 @@ namespace verbly {
     {
       if (type_ == type::noun_phrase)
       {
-        return noun_phrase_.selrestrs;
+        return std::get<noun_phrase_type>(variant_).selrestrs;
       } else {
         throw std::domain_error("part::getNounSelrestrs is only valid for noun phrase parts");
       }
@@ -343,7 +72,7 @@ namespace verbly {
     {
       if (type_ == type::noun_phrase)
       {
-        return noun_phrase_.synrestrs;
+        return std::get<noun_phrase_type>(variant_).synrestrs;
       } else {
         throw std::domain_error("part::getNounSynrestrs is only valid for noun phrase parts");
       }
@@ -353,7 +82,7 @@ namespace verbly {
     {
       if (type_ == type::preposition)
       {
-        return preposition_.choices;
+        return std::get<preposition_type>(variant_).choices;
       } else {
         throw std::domain_error("part::getPrepositionChoices is only valid for preposition parts");
       }
@@ -363,7 +92,7 @@ namespace verbly {
     {
       if (type_ == type::preposition)
       {
-        return preposition_.literal;
+        return std::get<preposition_type>(variant_).literal;
       } else {
         throw std::domain_error("part::isPrepositionLiteral is only valid for preposition parts");
       }
@@ -373,7 +102,7 @@ namespace verbly {
     {
       if (type_ == type::literal)
       {
-        return literal_;
+        return std::get<literal_type>(variant_);
       } else {
         throw std::domain_error("part::getLiteralValue is only valid for literal parts");
       }