added basic_operation

Author: dietmarkuehl

include/beman/execution26/detail/basic_operation.hpp

@@ -4,8 +4,12 @@
 #ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_BASIC_OPERATION
 #define INCLUDED_BEMAN_EXECUTION26_DETAIL_BASIC_OPERATION
 
+#include <beman/execution26/detail/operation_state.hpp>
 #include <beman/execution26/detail/basic_state.hpp>
 #include <beman/execution26/detail/state_type.hpp>
+#include <beman/execution26/detail/sender_decompose.hpp>
+#include <beman/execution26/detail/impls_for.hpp>
+#include <beman/execution26/detail/connect_all_result.hpp>
 #include <beman/execution26/detail/valid_specialization.hpp>
 #include <utility>
 
@@ -20,11 +24,47 @@ namespace beman::execution26::detail
     struct basic_operation
         : ::beman::execution26::detail::basic_state<Sender, Receiver>
     {
+        using operation_state_concept = ::beman::execution26::operation_state_t;
+        using tag_t = ::beman::execution26::tag_of_t<Sender>;
+
+        using inner_ops_t = ::beman::execution26::detail::connect_all_result<Sender, Receiver>;
+        inner_ops_t inner_ops;
+
         basic_operation(Sender&& sender, Receiver&& receiver) noexcept(true/*-dk:TODO*/)
             : ::beman::execution26::detail::basic_state<Sender, Receiver>(
                 ::std::forward<Sender>(sender), ::std::move(receiver)
             )
+            , inner_ops(::beman::execution26::detail::connect_all(
+                this,
+                ::std::forward<Sender>(sender),
+                ::beman::execution26::detail::indices_for<Sender>()
+            ))
+        {
+        }
+
+        auto start() & noexcept -> void
         {
+            static constexpr ::beman::execution26::detail::sender_any_t at{};
+            if constexpr (requires{ inner_ops_t{at, at, at, at}; })
+            {
+                auto&[op0, op1, op2, op3] = this->inner_ops;
+                ::beman::execution26::detail::impls_for<tag_t>::start(this->state, this->receiver, op0, op1, op2, op3);
+            }
+            else if constexpr (requires{ inner_ops_t{at, at, at}; })
+            {
+                auto&[op0, op1, op2] = this->inner_ops;
+                ::beman::execution26::detail::impls_for<tag_t>::start(this->state, this->receiver, op0, op1, op2);
+            }
+            else if constexpr (requires{ inner_ops_t{at, at}; })
+            {
+                auto&[op0, op1] = this->inner_ops;
+                ::beman::execution26::detail::impls_for<tag_t>::start(this->state, this->receiver, op0, op1);
+            }
+            else if constexpr (requires{ inner_ops_t{at}; })
+            {
+                auto&[op0] = this->inner_ops;
+                ::beman::execution26::detail::impls_for<tag_t>::start(this->state, this->receiver, op0);
+            }
         }
     };
 }

src/beman/execution26/tests/exec-snd-expos.pass.cpp

@@ -101,67 +101,70 @@ namespace
     struct operation_state
     {
         using operation_state_concept = test_std::operation_state_t;
-        auto start() noexcept -> void {}
+        int* counter;
+        operation_state(int* counter): counter(counter) {}
+        operation_state(operation_state&&) = delete;
+        auto start() & noexcept -> void { ++*counter; }
     };
 
     struct sender0
     {
         using sender_concept = test_std::sender_t;
         using indices_for = ::std::index_sequence_for<>;
         tag t{};
-        int data{};
+        int* data{};
         template <typename Receiver>
-        auto connect(Receiver&&) const noexcept -> operation_state<Receiver> { return {}; }
+        auto connect(Receiver&&) const noexcept { return operation_state<Receiver>(data); }
     };
 
     struct sender1
     {
         using sender_concept = test_std::sender_t;
         using indices_for = ::std::index_sequence_for<sender0>;
         tag t{};
-        int data{};
+        int* data{};
         sender0 c0{};
         template <typename Receiver>
-        auto connect(Receiver&&) const noexcept -> operation_state<Receiver> { return {}; }
+        auto connect(Receiver&&) const noexcept { return operation_state<Receiver>(data); }
     };
 
     struct sender2
     {
         using sender_concept = test_std::sender_t;
         using indices_for = ::std::index_sequence_for<sender0, sender0>;
         tag t{};
-        int data{};
+        int* data{};
         sender0 c0{};
         sender0 c1{};
         template <typename Receiver>
-        auto connect(Receiver&&) const noexcept -> operation_state<Receiver> { return {}; }
+        auto connect(Receiver&&) const noexcept { return operation_state<Receiver>(data); }
     };
 
     struct sender3
     {
         using sender_concept = test_std::sender_t;
         using indices_for = ::std::index_sequence_for<sender0, sender0, sender0>;
         tag t{};
-        int data{};
+        int* data{};
         sender0 c0{};
         sender0 c1{};
         sender0 c2{};
         template <typename Receiver>
-        auto connect(Receiver&&) const noexcept -> operation_state<Receiver> { return {}; }
+        auto connect(Receiver&&) const noexcept { return operation_state<Receiver>(data); }
     };
 
     struct sender4
     {
         using sender_concept = test_std::sender_t;
         using indices_for = ::std::index_sequence_for<sender0, sender0, sender0, sender0>;
         tag t{};
-        int data{};
+        int* data{};
         sender0 c0{};
         sender0 c1{};
         sender0 c2{};
         sender0 c3{};
         template <typename Receiver>
-        auto connect(Receiver&&) const noexcept -> operation_state<Receiver> { return {}; }
+        auto connect(Receiver&&) const noexcept { return operation_state<Receiver>(data); }
     };
 
     struct receiver
@@ -1005,9 +1008,16 @@ namespace
 
     auto test_basic_operation() -> void
     {
-        test_detail::basic_operation op{sender0{}, receiver{}};
-        (void)op;
-        //-dk:TODO test basic_operation
+        int data{};
+        test_detail::basic_operation op{sender4{tag{}, &data,
+            sender0{tag{}, &data},
+            sender0{tag{}, &data},
+            sender0{tag{}, &data},
+            sender0{tag{}, &data}}, receiver{}};
+        static_assert(test_std::operation_state<decltype(op)>);
+        static_assert(requires{ typename decltype(op)::tag_t; });
+        op.start();
+        assert(data == 4);
     }
 }