From 34479a3e316d4d2db7c95a093f91a31275fba48e Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Sun, 23 May 2021 16:10:58 +0100 Subject: [PATCH] Working. No move functionality. --- include/etl/private/variant_new.h | 20 ++-- test/test_variant_new.cpp | 168 ++++++++++++++++-------------- 2 files changed, 97 insertions(+), 91 deletions(-) diff --git a/include/etl/private/variant_new.h b/include/etl/private/variant_new.h index 1c2d36d4..45447fc0 100644 --- a/include/etl/private/variant_new.h +++ b/include/etl/private/variant_new.h @@ -152,14 +152,18 @@ namespace etl //*************************************************************************** constexpr variant() : data() - , operation(null_operation) - , type_id(variant_npos) { + using type = typename etl::parameter_pack::type_from_index<0>::type; + + type temp; + + operation = do_operation; + operation(action_type::Construct, data, &temp); + type_id = 0; } //*************************************************************************** - /// Constructor that catches any types that are not supported. - /// Forces a static_assert. + /// Constructor for lvalues //*************************************************************************** template constexpr variant(const T& value) @@ -169,7 +173,7 @@ namespace etl { static_assert(etl::is_one_of::value, "Unsupported type"); - operation(action_type::Construct, data, &value); + operation(action_type::Construct, data, &const_cast(value)); } //*************************************************************************** @@ -326,12 +330,6 @@ namespace etl break; } - case action_type::Move: - { - ::new (pstorage) T(etl::move(*reinterpret_cast(pvalue))); - break; - } - case action_type::Destruct: { reinterpret_cast(pstorage)->~T(); diff --git a/test/test_variant_new.cpp b/test/test_variant_new.cpp index a99a6e83..69fcd47a 100644 --- a/test/test_variant_new.cpp +++ b/test/test_variant_new.cpp @@ -37,76 +37,35 @@ SOFTWARE. namespace { - // Test classes for polymorphic tests. - struct base - { - virtual ~base() - { - } - - base() - : value(0) - { - } - - virtual void set() = 0; - int value; - }; - - struct not_base - { - not_base() - : value(0) - { - } - - virtual void set() = 0; - int value; - }; - - struct derived_1 : public base - { - void set() - { - value = 1; - } - }; - - struct derived_2 : public base - { - void set() - { - value = 2; - } - }; - // Test variant types. - typedef etl::variant test_variant_3a; - typedef etl::variant test_variant_3b; - - typedef etl::variant test_variant_1; - typedef etl::variant test_variant_2; - typedef etl::variant test_variant_3; - typedef etl::variant test_variant_4; - typedef etl::variant test_variant_5; - typedef etl::variant test_variant_6; - typedef etl::variant test_variant_7; - typedef etl::variant test_variant_8; - - typedef etl::variant test_variant_polymorphic; - typedef etl::variant test_variant_max_types; - - // This line should compile with no errors. - test_variant_max_types variant_max; + typedef etl::variant test_variant_3; struct D1 { D1(const std::string& a_) : a(a_) { + copied = false; + moved = false; + } + + D1(const D1& other) + : a(other.a) + { + copied = true; + moved = false; + } + + D1(D1&& other) + : a(std::move(other.a)) + { + copied = false; + moved = true; } std::string a; + bool copied; + bool moved; }; struct D2 @@ -199,7 +158,7 @@ namespace return os; } - typedef etl::variant test_variant_emplace; + typedef etl::variant test_variant_emplace; SUITE(test_variant) { @@ -224,11 +183,11 @@ namespace //************************************************************************* TEST(test_constructor_default) { - CHECK_NO_THROW(test_variant_3a variant); + CHECK_NO_THROW(test_variant_3 variant); - test_variant_1 variant; + test_variant_3 variant; - CHECK(!etl::holds_alternative(variant)); + CHECK(etl::holds_alternative(variant)); } //************************************************************************* @@ -236,21 +195,46 @@ namespace { // Char. char c = 'a'; - test_variant_3a variant_char(c); + test_variant_3 variant_char(c); CHECK(etl::holds_alternative(variant_char)); CHECK_EQUAL(c, etl::get(variant_char)); // Int. int i = 1; - test_variant_3a variant_int(i); + test_variant_3 variant_int(i); CHECK(etl::holds_alternative(variant_int)); CHECK_EQUAL(i, etl::get(variant_int)); // String. std::string text("Some Text"); - test_variant_3a variant_text(text); + test_variant_3 variant_text(text); + + CHECK(etl::holds_alternative(variant_text)); + CHECK_EQUAL(text, etl::get(variant_text)); + } + + //************************************************************************* + TEST(test_constructor_move_value) + { + // Char. + char c = 'a'; + test_variant_3 variant_char(etl::move(c)); + + CHECK(etl::holds_alternative(variant_char)); + CHECK_EQUAL(c, etl::get(variant_char)); + + // Int. + int i = 1; + test_variant_3 variant_int(etl::move(i)); + + CHECK(etl::holds_alternative(variant_int)); + CHECK_EQUAL(i, etl::get(variant_int)); + + // String. + std::string text("Some Text"); + test_variant_3 variant_text(etl::move(text)); CHECK(etl::holds_alternative(variant_text)); CHECK_EQUAL(text, etl::get(variant_text)); @@ -260,9 +244,21 @@ namespace TEST(test_copy_constructor) { std::string text("Some Text"); - test_variant_3a variant_1(text); + test_variant_3 variant_1(text); - test_variant_3a variant_2(variant_1); + test_variant_3 variant_2(variant_1); + + CHECK_EQUAL(variant_1.index(), variant_2.index()); + CHECK_EQUAL(variant_1.get(), variant_2.get()); + } + + //************************************************************************* + TEST(test_move_constructor) + { + std::string text("Some Text"); + test_variant_3 variant_1(text); + + test_variant_3 variant_2(etl::move(variant_1)); CHECK_EQUAL(variant_1.index(), variant_2.index()); CHECK_EQUAL(variant_1.get(), variant_2.get()); @@ -272,7 +268,7 @@ namespace TEST(test_assign_from_value) { std::string text("Some Text"); - test_variant_3a variant; + test_variant_3 variant; variant = text; @@ -283,8 +279,8 @@ namespace TEST(test_assign_from_variant) { std::string text("Some Text"); - test_variant_3a variant_1; - test_variant_3a variant_2; + test_variant_3 variant_1; + test_variant_3 variant_2; variant_1 = text; variant_2 = variant_1; @@ -297,8 +293,8 @@ namespace { std::string text("Some Text"); int integer(99); - test_variant_3a variant_1; - test_variant_3a variant_2; + test_variant_3 variant_1; + test_variant_3 variant_2; variant_1 = text; variant_2 = integer; @@ -311,7 +307,7 @@ namespace TEST(test_assignment_incorrect_type_exception) { std::string text("Some Text"); - test_variant_3a variant(text); + test_variant_3 variant(text); int i; CHECK_THROW(etl::get(variant), etl::variant_incorrect_type_exception); @@ -321,7 +317,7 @@ namespace //************************************************************************* TEST(test_self_assignment) { - test_variant_3a variant; + test_variant_3 variant; variant = 1; variant = variant; @@ -334,8 +330,8 @@ namespace { std::string text("Some Text"); int integer(99); - test_variant_3a variant_1(text); - test_variant_3a variant_2(integer); + test_variant_3 variant_1(text); + test_variant_3 variant_2(integer); variant_1.swap(variant_2); @@ -351,8 +347,8 @@ namespace { std::string text("Some Text"); int integer(99); - test_variant_3a variant_1(text); - test_variant_3a variant_2(integer); + test_variant_3 variant_1(text); + test_variant_3 variant_2(integer); etl::swap(variant_1, variant_2); @@ -384,5 +380,17 @@ namespace CHECK(etl::holds_alternative(variant)); CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get(variant)); } + + //************************************************************************* + TEST(test_move) + { + test_variant_emplace variant; + + D1 da("1"); + + variant = da; + + D1 db = etl::move(etl::get(variant)); + } }; }