From 38c17f093615a16a4b4ec6dc2b5d3edb5c1d3895 Mon Sep 17 00:00:00 2001 From: Kelly Rauchenberger Date: Thu, 27 Sep 2018 21:40:52 -0400 Subject: 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 --- lib/token.cpp | 495 +++++++++++++++------------------------------------------- 1 file changed, 128 insertions(+), 367 deletions(-) (limited to 'lib/token.cpp') diff --git a/lib/token.cpp b/lib/token.cpp index 7b1d1fa..b3c7062 100644 --- a/lib/token.cpp +++ b/lib/token.cpp @@ -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(other.fillin_); - - break; - } - - case type::utterance: - { - new(&utterance_) std::list(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(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 tempFillin; - std::list tempUtterance; - transform_type tempTransformType; - std::string tempTransformStrParam; - std::string tempTransformStrParam2; - casing tempTransformCasingParam; - std::unique_ptr 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::move(second.fillin_)); - - break; - } - - case type::utterance: - { - new(&first.utterance_) std::list(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(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::move(tempFillin)); - - break; - } - - case type::utterance: - { - new(&second.utterance_) std::list(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(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; - fillin_.~set_type(); - - break; + return false; } case type::utterance: { - using list_type = std::list; - utterance_.~list_type(); + const utterance_type& utterance = mpark::get(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; - - transform_.strParam_.~string_type(); - transform_.strParam2_.~string_type(); - transform_.inner_.~ptr_type(); + const transform_type& transform = mpark::get(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(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(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(variant_); + bool first = true; std::list 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(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(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(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(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(variant_); } - token::token(std::set synrestrs) : type_(type::fillin) + token::token( + std::set synrestrs) : + type_(type::fillin), + variant_(std::move(synrestrs)) { - new(&fillin_) std::set(std::move(synrestrs)); } const std::set& token::getSynrestrs() const @@ -578,7 +327,7 @@ namespace verbly { throw std::domain_error("Token is not a fillin"); } - return fillin_; + return mpark::get(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(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(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(std::vector parts) : type_(type::utterance) + token::token( + std::vector parts) : + type_(type::utterance), + variant_(utterance_type { std::begin(parts), std::end(parts) }) { - new(&utterance_) std::list(std::begin(parts), std::end(parts)); } - token::token(std::initializer_list parts) : type_(type::utterance) + token::token( + std::initializer_list parts) : + type_(type::utterance), + variant_(utterance_type { std::move(parts) }) { - new(&utterance_) std::list(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(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(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(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(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(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(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(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(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(new token(std::move(inner))); } std::ostream& operator<<(std::ostream& os, token::type type) -- cgit 1.4.1