[tuple] Few tests and assign implementation

Author: Yaraslaut

include/rsl/tuple

@@ -8,6 +8,7 @@
 #include <rsl/_impl/index_of.hpp>
 #include <rsl/_impl/member_cache.hpp>
 #include <rsl/util/to_string.hpp>
+#include <rsl/utility>
 
 #ifndef RSL_STD_COMPAT
 #  define RSL_STD_COMPAT 1
@@ -91,23 +92,23 @@ concept is_implicitly_default_constructible = std::is_default_constructible_v<T>
 #ifdef __clang__
 template <typename T, std::size_t Idx>
 struct SubscriptElement {
-  constexpr decltype(auto) operator[](std::size_t idx) &
-      __attribute__((enable_if(idx == Idx, "index mismatch"))) {
+  constexpr decltype(auto) operator[](
+      std::size_t idx) & __attribute__((enable_if(idx == Idx, "index mismatch"))) {
     return get<Idx>(static_cast<T&>(*this));
   }
 
-  constexpr decltype(auto) operator[](std::size_t idx) const&
-      __attribute__((enable_if(idx == Idx, "index mismatch"))) {
+  constexpr decltype(auto) operator[](
+      std::size_t idx) const& __attribute__((enable_if(idx == Idx, "index mismatch"))) {
     return get<Idx>(static_cast<T const&>(*this));
   }
 
-  constexpr decltype(auto) operator[](std::size_t idx) &&
-      __attribute__((enable_if(idx == Idx, "index mismatch"))) {
+  constexpr decltype(auto) operator[](
+      std::size_t idx) && __attribute__((enable_if(idx == Idx, "index mismatch"))) {
     return get<Idx>(static_cast<T&&>(*this));
   }
 
-  constexpr decltype(auto) operator[](std::size_t idx) const&&
-      __attribute__((enable_if(idx == Idx, "index mismatch"))) {
+  constexpr decltype(auto) operator[](
+      std::size_t idx) const&& __attribute__((enable_if(idx == Idx, "index mismatch"))) {
     return get<Idx>(static_cast<T const&&>(*this));
   }
 };
@@ -127,7 +128,6 @@ struct Subscript<T, std::index_sequence<Idx...>> : SubscriptElement<T, Idx>... {
 #endif
 }  // namespace _tuple_impl
 
-
 namespace _impl {
 
 template <typename... Ts>
@@ -147,18 +147,18 @@ class tuple
 #endif
 {
 private:
+  template <typename... Us>
+  constexpr static bool enable_utypes_ctor =
+      !std::same_as<tuple, Us...[0]> && (std::is_constructible_v<Types, Us> && ...);
 
-template <typename... Us>
-constexpr static bool enable_utypes_ctor = !std::same_as<tuple, Us...[0]> && (std::is_constructible_v<Types, Us> && ...); 
-
-template<>
-constexpr bool enable_utypes_ctor<> = false;
+  template <>
+  constexpr bool enable_utypes_ctor<> = false;
 
-template <typename... Us>
-constexpr static bool enable_utypes_tuple_ctor = true; // TODO
+  template <typename... Us>
+  constexpr static bool enable_utypes_tuple_ctor = true;  // TODO
 
-template <>
-constexpr bool enable_utypes_tuple_ctor<> = false;
+  template <>
+  constexpr bool enable_utypes_tuple_ctor<> = false;
 
 public:
   template <typename... Ts>
@@ -172,10 +172,13 @@ public:
 
   // template <typename... UTypes>
   // static constexpr auto _impl_disambiguation_constraint =
-  //     (sizeof...(Types) == 1 && !std::same_as<std::remove_cvref_t<rsl::tuple_element_t<0, rsl::tuple<UTypes...>>>, tuple>) ||
+  //     (sizeof...(Types) == 1 && !std::same_as<std::remove_cvref_t<rsl::tuple_element_t<0,
+  //     rsl::tuple<UTypes...>>>, tuple>) ||
   //     ((sizeof...(Types) == 2 || sizeof...(Types) == 3) &&
-  //      (!std::same_as<std::remove_cvref_t<rsl::tuple_element_t<0, rsl::tuple<UTypes...>>>, std::allocator_arg_t> ||
-  //       std::same_as<std::remove_cvref_t<rsl::tuple_element_t<0, rsl::tuple<Types...>>>, std::allocator_arg_t>)) ||
+  //      (!std::same_as<std::remove_cvref_t<rsl::tuple_element_t<0, rsl::tuple<UTypes...>>>,
+  //      std::allocator_arg_t> ||
+  //       std::same_as<std::remove_cvref_t<rsl::tuple_element_t<0, rsl::tuple<Types...>>>,
+  //       std::allocator_arg_t>)) ||
   //     sizeof...(Types) >= 1;
 
   // [tuple.cnstr], tuple construction
@@ -211,32 +214,32 @@ public:
     requires(std::is_move_constructible_v<Storage>)
   = default;
 
-    template <class... UTypes>
-    constexpr explicit(!(std::is_convertible_v<UTypes&, Types> && ...)) 
-    tuple(tuple<UTypes...>& other)
-    noexcept((std::is_nothrow_constructible_v<Types, UTypes&> && ...))
-    requires(false) // TODO
-    : _impl_storage(other) {}
-    
-    template <class... UTypes>
-    constexpr explicit(!(std::is_convertible_v<UTypes const&, Types> && ...)) 
-    tuple(tuple<UTypes...> const& other)
-    noexcept((std::is_nothrow_constructible_v<Types, UTypes const&> && ...))
-    requires(false) // TODO
-    : _impl_storage(other) {}
-
-    template <class... UTypes>
-    constexpr explicit(!(std::is_convertible_v<UTypes, Types> && ...)) 
-    tuple(tuple<UTypes...>&& other)
-    noexcept((std::is_nothrow_constructible_v<Types, UTypes> && ...))
-    requires(false) // TODO
-    : _impl_storage(std::move(other)) {}
-    
-    template <class... UTypes>
-    constexpr explicit(!(std::is_convertible_v<UTypes, Types> && ...)) 
-    tuple(tuple<UTypes...> const&& other)
-    requires(false) // TODO
-    : _impl_storage(std::move(other)) {}
+  template <class... UTypes>
+  constexpr explicit(!(std::is_convertible_v<UTypes&, Types> && ...))
+      tuple(tuple<UTypes...>& other) noexcept((std::is_nothrow_constructible_v<Types, UTypes&> &&
+                                               ...))
+    requires(false)  // TODO
+      : _impl_storage(other) {}
+
+  template <class... UTypes>
+  constexpr explicit(!(std::is_convertible_v<UTypes const&, Types> && ...))
+      tuple(tuple<UTypes...> const& other) noexcept(
+          (std::is_nothrow_constructible_v<Types, UTypes const&> && ...))
+    requires(false)  // TODO
+      : _impl_storage(other) {}
+
+  template <class... UTypes>
+  constexpr explicit(!(std::is_convertible_v<UTypes, Types> && ...))
+      tuple(tuple<UTypes...>&& other) noexcept((std::is_nothrow_constructible_v<Types, UTypes> &&
+                                                ...))
+    requires(false)  // TODO
+      : _impl_storage(std::move(other)) {}
+
+  template <class... UTypes>
+  constexpr explicit(!(std::is_convertible_v<UTypes, Types> && ...))
+      tuple(tuple<UTypes...> const&& other)
+    requires(false)  // TODO
+      : _impl_storage(std::move(other)) {}
 
   //   template <class U1, class U2>
   //   constexpr explicit(true /* TODO*/) tuple(std::pair<U1, U2>&);  // only if
@@ -300,19 +303,98 @@ public:
   }
 
   // [tuple.assign], tuple assignment
-  //   constexpr tuple& operator=(const tuple&);
-  //   constexpr const tuple& operator=(const tuple&) const;
-  //   constexpr tuple& operator=(tuple&&) noexcept(true /* TODO */);
-  //   constexpr const tuple& operator=(tuple&&) const;
-
-  //   template <class... UTypes>
-  //   constexpr tuple& operator=(const tuple<UTypes...>&);
-  //   template <class... UTypes>
-  //   constexpr const tuple& operator=(const tuple<UTypes...>&) const;
-  //   template <class... UTypes>
-  //   constexpr tuple& operator=(tuple<UTypes...>&&);
-  //   template <class... UTypes>
-  //   constexpr const tuple& operator=(tuple<UTypes...>&&) const;
+
+  constexpr tuple& operator=(const tuple& other)
+    requires(std::ranges::all_of(_impl_accessor.types, std::meta::is_copy_assignable_type))
+  {
+    template for (constexpr auto el : define_static_array(
+                      nonstatic_data_members_of(^^Storage, std::meta::access_context::current()))) {
+      this->_impl_storage.[:el:] = other._impl_storage.[:el:];
+    }
+    return *this;
+  }
+
+  constexpr const tuple& operator=(const tuple& other) const
+      noexcept(std::ranges::all_of(_impl_accessor.types,
+                                   std::meta::is_nothrow_copy_constructible_type))
+    requires(std::ranges::all_of(_impl_accessor.types,
+                                 [](std::meta::info type) consteval {
+                                   return std::meta::is_copy_assignable_type(
+                                       std::meta::add_const(type));
+                                 }))
+  {
+    template for (constexpr auto el : define_static_array(
+                      nonstatic_data_members_of(^^Storage, std::meta::access_context::current()))) {
+      this->_impl_storage.[:el:] = other._impl_storage.[:el:];
+    }
+    return *this;
+  }
+
+  constexpr tuple& operator=(tuple&& other) noexcept(
+      std::ranges::all_of(_impl_accessor.types, std::meta::is_nothrow_move_constructible_type))
+    requires(std::ranges::all_of(_impl_accessor.types,
+                                 std::meta::is_move_assignable_type))  // tuple.assign-8
+  {
+    this->_impl_storage = std::move(other._impl_storage);
+    return *this;
+  }
+
+  constexpr const tuple& operator=(tuple&& other) const
+    requires(std::ranges::all_of(_impl_accessor.types,  // tuple.assign-12
+                                 [](std::meta::info type) consteval {
+                                   return std::meta::is_assignable_type(std::meta::add_const(type),
+                                                                        type);
+                                 }))
+  {
+    template for (constexpr auto el : define_static_array(
+                      nonstatic_data_members_of(^^Storage, std::meta::access_context::current()))) {
+      this->_impl_storage.[:el:] = std::move(other._impl_storage.[:el:]);
+    }
+    return *this;
+  }
+
+  template <class... UTypes>
+    requires(sizeof...(UTypes) == sizeof...(Types) &&
+             (std::is_assignable_v<Types&, UTypes const&> && ...))  // tuple-assign-15
+  constexpr tuple& operator=(const tuple<UTypes...>& other) {
+    template for (constexpr auto Idx : rsl::make_index_sequence<sizeof...(Types)>()) {
+      this->get<Idx>() = other.template get<Idx>();
+    }
+    return *this;
+  }
+  template <class... UTypes>
+    requires(sizeof...(UTypes) == sizeof...(Types) &&
+             (std::is_assignable_v<const Types&, const UTypes&> && ...))  // tuple-assign-18
+  constexpr const tuple& operator=(const tuple<UTypes...>& other) const {
+    template for (constexpr auto Idx : rsl::make_index_sequence<sizeof...(Types)>()) {
+      constexpr auto el = define_static_array(
+          nonstatic_data_members_of(^^Storage, std::meta::access_context::current()))[Idx];
+      this->_impl_storage.[:el:] = other.template get<Idx>();
+    }
+    return *this;
+  }
+
+  template <class... UTypes>
+    requires(sizeof...(UTypes) == sizeof...(Types) &&
+             (std::is_assignable_v<Types&, UTypes> && ...))  // tuple-assign-21
+  constexpr tuple& operator=(tuple<UTypes...>&& other) {
+    template for (constexpr auto Idx : rsl::make_index_sequence<sizeof...(Types)>()) {
+      this->get<Idx>() = std::forward<UTypes...[Idx]>(other.template get<Idx>());
+    }
+    return *this;
+  }
+
+  template <class... UTypes>
+    requires(sizeof...(UTypes) == sizeof...(Types) &&
+             (std::is_assignable_v<const Types&, UTypes> && ...))  // tuple-assign-24
+  constexpr const tuple& operator=(tuple<UTypes...>&& other) const {
+    template for (constexpr auto Idx : rsl::make_index_sequence<sizeof...(Types)>()) {
+      constexpr auto el = define_static_array(
+          nonstatic_data_members_of(^^Storage, std::meta::access_context::current()))[Idx];
+      this->_impl_storage.[:el:] = std::forward<UTypes...[Idx]>(other.template get<Idx>());
+    }
+    return *this;
+  }
 
   //   template <class U1, class U2>
   //   constexpr tuple& operator=(const std::pair<U1, U2>&);  // only if sizeof...(Types) == 2

test/tuple/CMakeLists.txt

@@ -1,7 +1,10 @@
 target_sources(rsl-util-test PRIVATE 
     structured_bindings.cpp
     empty.cpp
+    assign.cpp
+    tie.cpp
+    make_tuple.cpp
 )
 
 add_subdirectory(tuple.get)
-add_subdirectory(extensions)
+add_subdirectory(extensions)