added structured binding support for types derived from product type

Author: dietmarkuehl

include/beman/execution26/detail/product_type.hpp

@@ -10,7 +10,8 @@
 // ----------------------------------------------------------------------------
 
 namespace beman::execution26::detail {
-template <::std::size_t, typename T>
+
+template <::std::size_t I, typename T>
 struct product_type_element {
     T    value;
     auto operator==(const product_type_element&) const -> bool = default;
@@ -23,6 +24,7 @@ template <::std::size_t... I, typename... T>
 struct product_type_base<::std::index_sequence<I...>, T...>
     : ::beman::execution26::detail::product_type_element<I, T>... {
     static constexpr ::std::size_t size() { return sizeof...(T); }
+    static constexpr bool is_product_type{true};
 
     template <::std::size_t J, typename S>
     static auto element_get(::beman::execution26::detail::product_type_element<J, S>& self) noexcept -> S& {
@@ -64,6 +66,10 @@ struct product_type_base<::std::index_sequence<I...>, T...>
     auto operator==(const product_type_base&) const -> bool = default;
 };
 
+template <typename T>
+concept is_product_type_c = requires(T const& t){ T::is_product_type; };
+
+
 template <typename... T>
 struct product_type : ::beman::execution26::detail::product_type_base<::std::index_sequence_for<T...>, T...> {
     template <typename Allocator, typename Product, std::size_t... I>
@@ -108,13 +114,16 @@ constexpr auto is_product_type(const ::beman::execution26::detail::product_type<
 } // namespace beman::execution26::detail
 
 namespace std {
-template <typename... T>
-struct tuple_size<::beman::execution26::detail::product_type<T...>>
-    : ::std::integral_constant<std::size_t, sizeof...(T)> {};
-template <::std::size_t I, typename... T>
-struct tuple_element<I, ::beman::execution26::detail::product_type<T...>> {
+template <typename T>
+     requires ::beman::execution26::detail::is_product_type_c<T>
+struct tuple_size<T>
+    : ::std::integral_constant<std::size_t, T::size()> {};
+
+template <::std::size_t I, typename T>
+     requires ::beman::execution26::detail::is_product_type_c<T>
+struct tuple_element<I, T> {
     using type =
-        ::std::decay_t<decltype(::std::declval<::beman::execution26::detail::product_type<T...>>().template get<I>())>;
+        ::std::decay_t<decltype(::std::declval<T>().template get<I>())>;
 };
 } // namespace std
 

tests/beman/execution26/CMakeLists.txt

@@ -129,7 +129,7 @@ foreach(test ${execution_tests})
   add_test(NAME ${TEST_EXE} COMMAND $<TARGET_FILE:${TEST_EXE}>)
 endforeach()
 
-if(PROJECT_IS_TOP_LEVEL)
+if(NOT PROJECT_IS_TOP_LEVEL)
   # test if the targets are findable from the build directory
   # cmake-format: off
   add_test(NAME find-package-test

tests/beman/execution26/exec-snd-expos.test.cpp

@@ -858,6 +858,27 @@ auto test_product_type() -> void {
     ASSERT(p5.get<2>() == nm(3));
     ASSERT(p5.get<3>() == nm(4));
     ASSERT(p5.get<4>() == nm(5));
+
+    test_detail::product_type prod{1, true, 'c'};
+    static_assert(test_detail::is_product_type_c<decltype(prod)>);
+    static_assert(3u == std::tuple_size<decltype(prod)>::value);
+    static_assert(std::same_as<int, std::tuple_element<0u, decltype(prod)>::type>);
+    static_assert(std::same_as<bool, std::tuple_element<1u, decltype(prod)>::type>);
+    static_assert(std::same_as<char, std::tuple_element<2u, decltype(prod)>::type>);
+    auto&&[i, b, c] = prod;
+    test::use(i, b, c);
+
+    struct derived: decltype(prod) {};
+    static_assert(3u == std::tuple_size<derived>::value);
+    static_assert(std::same_as<int, std::tuple_element<0u, derived>::type>);
+    static_assert(std::same_as<bool, std::tuple_element<1u, derived>::type>);
+    static_assert(std::same_as<char, std::tuple_element<2u, derived>::type>);
+    derived d{1, true, 'c'};
+    auto&&[di, db, dc] = d;
+    assert(di == d.get<0>());
+    assert(db == d.get<1>());
+    assert(dc == d.get<2>());
+    test::use(di, db, dc);
 }
 auto test_connect_all() -> void {
     static_assert(test_std::operation_state<operation_state<receiver>>);