Merge pull request #25 from rsl-org/variant/make_structural

[variant] Make structural type and some testing

Author: Tsche

include/rsl/variant

@@ -244,12 +244,12 @@ protected:
   friend struct variant_size<variant_base>;
 
   constexpr void reset() {
-    if (discriminator != npos) {
+    if (_impl_discriminator != npos) {
       _visit_impl::visit_at<void>(
-          discriminator,
+          _impl_discriminator,
           [](auto&& member) { std::destroy_at(std::addressof(member)); },
           *this);
-      discriminator = npos;
+      _impl_discriminator = npos;
     }
   }
 
@@ -280,7 +280,7 @@ protected:
           std::construct_at(&lhs, idx, std::forward<T>(rhs_alternative));
         },
         std::forward<V>(rhs));
-    lhs.discriminator = index_type(rhs_index);
+    lhs._impl_discriminator = index_type(rhs_index);
   }
 
 public:
@@ -292,13 +292,11 @@ public:
   using index_type = std::conditional_t<(alternatives.count >= 255), unsigned short, unsigned char>;
   static constexpr auto npos = index_type(-1ULL);
 
-protected:
   union {
-    Storage storage;
+    Storage _impl_storage;
   };
-  index_type discriminator = npos;
+  index_type _impl_discriminator = npos;
 
-public:
   // default constructor, only if alternative #0 is default constructible
   constexpr variant_base()                                                    //
       noexcept(is_nothrow_default_constructible_type(alternatives.types[0]))  // [variant.ctor]/5
@@ -364,11 +362,11 @@ public:
   template <std::size_t Idx, typename... Args>
   constexpr explicit variant_base(std::in_place_index_t<Idx>, Args&&... args)  //
       noexcept(is_nothrow_constructible_type(alternatives.types[Idx], {^^Args...}))
-      : discriminator(Idx) {
+      : _impl_discriminator(Idx) {
     // Primary constructor
 
-    std::construct_at(&storage, '\0');
-    std::construct_at(alternatives.template get_addr<Idx>(storage), std::forward<Args>(args)...);
+    std::construct_at(&_impl_storage, '\0');
+    std::construct_at(alternatives.template get_addr<Idx>(_impl_storage), std::forward<Args>(args)...);
   }
 
   template <std::size_t Idx, typename U, typename... Args>
@@ -377,11 +375,11 @@ public:
                                   Args&&... args)  //
       noexcept(std::is_nothrow_constructible_v<    //
                typename[:alternatives.types[Idx]:], std::initializer_list<U>&, Args...>)
-      : discriminator(Idx) {
+      : _impl_discriminator(Idx) {
     // Primary constructor
 
-    std::construct_at(&storage, '\0');
-    std::construct_at(alternatives.template get_addr<Idx>(storage),
+    std::construct_at(&_impl_storage, '\0');
+    std::construct_at(alternatives.template get_addr<Idx>(_impl_storage),
                       init_list,
                       std::forward<Args>(args)...);
   }
@@ -429,11 +427,11 @@ public:
   = default;
   constexpr ~variant_base() { reset(); }
   [[nodiscard]] constexpr bool valueless_by_exception() const noexcept {
-    return discriminator == npos;
+    return _impl_discriminator == npos;
   }
   [[nodiscard]] constexpr std::size_t index() const noexcept {
-    if (discriminator != npos) {
-      return discriminator;
+    if (_impl_discriminator != npos) {
+      return _impl_discriminator;
     }
     return variant_npos;
   }
@@ -443,8 +441,8 @@ public:
     static_assert(Idx < alternatives.count, "Alternative index out of bounds");
 
     reset();
-    std::construct_at(alternatives.template get_addr<Idx>(storage), std::forward<Args>(args)...);
-    discriminator = Idx;
+    std::construct_at(alternatives.template get_addr<Idx>(_impl_storage), std::forward<Args>(args)...);
+    _impl_discriminator = Idx;
   }
 
   template <typename T, typename... Args>
@@ -456,7 +454,7 @@ public:
   template <std::size_t Idx, typename Self>
   constexpr decltype(auto) get_alt(this Self&& self) {
     static_assert(Idx < alternatives.count, "Alternative index out of bounds");
-    return alternatives.template get<Idx>(std::forward<Self>(self).storage);
+    return alternatives.template get<Idx>(std::forward<Self>(self)._impl_storage);
   }
 
   template <std::size_t Idx, typename Self>
@@ -929,10 +927,10 @@ public:
 
   using tags = E;
 
-  storage_type* operator->() { return &this->storage; }
-  storage_type const* operator->() const { return &this->storage; }
-  storage_type* operator*() { return &this->storage; }
-  storage_type const* operator*() const { return &this->storage; }
+  storage_type* operator->() { return &this->_impl_storage; }
+  storage_type const* operator->() const { return &this->_impl_storage; }
+  storage_type* operator*() { return &this->_impl_storage; }
+  storage_type const* operator*() const { return &this->_impl_storage; }
 
   explicit(false) operator E() const { return _tagged_variant_impl::transitions<E>[this->index()]; }
 

test/variant/CMakeLists.txt

@@ -1,7 +1,9 @@
 target_sources(rsl-util-test PRIVATE 
   lifetime.cpp 
   special_members.cpp
-  swap.cpp)
+  swap.cpp
+  template.cpp
+)
 
 add_subdirectory(variant.assign)
 add_subdirectory(variant.bad.access)

test/variant/template.cpp

@@ -0,0 +1,84 @@
+#include <string>
+#include <gtest/gtest.h>
+#include <common/assertions.h>
+
+#include <rsl/variant>
+#include <rsl/string_view>
+
+template <typename valueType, auto... Indices>
+consteval std::array<valueType, sizeof...(Indices)> construct_array(
+    std::integer_sequence<valueType, Indices...>) {
+  return {(static_cast<valueType>(Indices))...};
+};
+
+enum class Options : uint8_t {
+  option1,
+  option2,
+};
+using variant_options = rsl::variant<int, rsl::string_view, Options>;
+template <variant_options... Args>
+struct WhoKnows {
+  static constexpr size_t number_of_args = sizeof...(Args);
+
+  template <typename T>
+  static constexpr bool has = (rsl::holds_alternative<T>(Args) || ...);
+
+  template <typename T>
+  static constexpr bool hasOne = (static_cast<int>(rsl::holds_alternative<T>(Args)) + ...) == 1;
+
+  template <typename T>
+  constexpr T get() {
+    static_assert(hasOne<T>);
+    template for (constexpr auto index :
+                  construct_array(std::integer_sequence<int, 0, number_of_args - 1>())) {
+      if constexpr (rsl::holds_alternative<T>(Args...[index])) {
+        return rsl::get<T>(Args...[index]);
+      }
+    }
+    return rsl::get<T>(Args...[0]);
+  }
+};
+
+TEST(Variant, MultipleParameters) {
+  {
+    WhoKnows<variant_options(42), variant_options(43)> obj;
+    ASSERT_TRUE([:type_of(^^obj):] ::has<int>);
+    ASSERT_FALSE([:type_of(^^obj):] ::hasOne<int>);
+  }
+
+  {
+    WhoKnows<variant_options(42), variant_options(Options::option1)> obj;
+    ASSERT_TRUE([:type_of(^^obj):] ::has<int>);
+    ASSERT_TRUE([:type_of(^^obj):] ::hasOne<int>);
+    ASSERT_EQ(obj.get<int>(), 42);
+    ASSERT_NE(obj.get<int>(), 1);
+  }
+
+  {
+    WhoKnows<variant_options(Options::option1)> obj;
+    ASSERT_FALSE([:type_of(^^obj):] ::has<int>);
+    ASSERT_TRUE([:type_of(^^obj):] ::has<Options>);
+
+    ASSERT_FALSE([:type_of(^^obj):] ::hasOne<int>);
+    ASSERT_TRUE([:type_of(^^obj):] ::hasOne<Options>);
+
+    ASSERT_EQ(obj.get<Options>(), Options::option1);
+    ASSERT_NE(obj.get<Options>(), Options::option2);
+  }
+
+  {
+    WhoKnows<variant_options(Options::option1),
+             variant_options(std::define_static_string("Hello world"))>
+        obj;
+
+    ASSERT_FALSE([:type_of(^^obj):] ::has<int>);
+    ASSERT_TRUE([:type_of(^^obj):] ::has<Options>);
+    ASSERT_TRUE([:type_of(^^obj):] ::has<rsl::string_view>);
+
+    ASSERT_FALSE([:type_of(^^obj):] ::hasOne<int>);
+    ASSERT_TRUE([:type_of(^^obj):] ::hasOne<Options>);
+    ASSERT_TRUE([:type_of(^^obj):] ::hasOne<rsl::string_view>);
+
+    ASSERT_EQ(obj.get<rsl::string_view>(), "Hello world");
+  }
+}