wrapper_constructors.h

#pragma once
 
#include <scl/feature/detail/executor_access.h>
#include <scl/feature/type_traits/wrapper.h>
#include <scl/utility/type_traits/forward_like.h>
 
#include <concepts>
#include <type_traits>

// cppcheck-suppress noExplicitConstructor
#define SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(cv_ref)                               \
    constexpr wrapper(self_type cv_ref other) /**/                                       \
        noexcept(::std::is_nothrow_constructible_v<executor_type, executor_type cv_ref>) \
        requires(::std::constructible_from<executor_type, executor_type cv_ref>)         \
        : m_executor{::scl::forward_like<self_type cv_ref>(other.m_executor)}            \
    {}

#define SCL_WRAPPER_CONSTRUCTOR_FOR_SELF                         \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(&)                \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(const &)          \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(volatile &)       \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(const volatile &) \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(&&)               \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(const &&)         \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(volatile &&)      \
    SCL_WRAPPER_CONSTRUCTOR_FOR_SELF_PROTOTYPE(const volatile &&)

// cppcheck-suppress noExplicitConstructor
#define SCL_WRAPPER_CONSTRUCTOR_FOR_OTHER                                                                           \
    template <typename Other>                                                                                       \
    constexpr wrapper(Other && other) /**/                                                                          \
        noexcept(noexcept(::std::declval<wrapper_constructor_resolver<self_type, Other &&>>().resolve()))           \
        requires(::scl::feature::is_wrapper_v<Other> && !::std::same_as<::std::remove_cvref_t<Other>, self_type> && \
            ::std::constructible_from<executor_type,                                                                \
                decltype(::std::declval<wrapper_constructor_resolver<self_type, Other &&>>().resolve())>)           \
        : m_executor{wrapper_constructor_resolver<self_type, Other &&>{::std::forward<Other>(other)}.resolve()}     \
    {}

#define SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(cv_ref)                                               \
    constexpr wrapper & operator=(self_type cv_ref other) /**/                                          \
        noexcept(noexcept(                                                                              \
            executor_type::access(::std::declval<executor_type &>()) =                                  \
                executor_type::access(::std::declval<executor_type cv_ref>())))                         \
        requires requires {                                                                             \
                     executor_type::access(::std::declval<executor_type &>()) =                         \
                         executor_type::access(::std::declval<executor_type cv_ref>());                 \
                 }                                                                                      \
    {                                                                                                   \
        executor_type::execute(m_executor, [](auto && scl_self, auto && scl_source) -> decltype(auto) { \
            return executor_type::access(::std::forward<decltype(scl_self)>(scl_self)) =                \
                       executor_type::access(::std::forward<decltype(scl_source)>(scl_source));         \
        }, m_executor, ::scl::forward_like<self_type cv_ref>(other.m_executor));                        \
        return *this;                                                                                   \
    }

#define SCL_WRAPPER_ASSIGNMENT_FOR_SELF                         \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(&)                \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(const &)          \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(volatile &)       \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(const volatile &) \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(&&)               \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(const &&)         \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(volatile &&)      \
    SCL_WRAPPER_ASSIGNMENT_FOR_SELF_PROTOTYPE(const volatile &&)

#define SCL_WRAPPER_ASSIGNMENT_FOR_OTHER                                                                                    \
    template <typename Other>                                                                                               \
    constexpr wrapper & operator=(Other && other) /**/                                                                      \
        noexcept(noexcept(                                                                                                  \
            executor_type::access(::std::declval<executor_type &>()) = ::std::remove_cvref_t<Other>::executor_type::access( \
                ::std::declval<::scl::forward_like_t<Other, typename ::std::remove_cvref_t<Other>::executor_type>>())))     \
        requires(::scl::feature::is_wrapper_v<Other> && !::std::same_as<::std::remove_cvref_t<Other>, self_type> &&         \
            requires {                                                                                                      \
                executor_type::access(::std::declval<executor_type &>()) = ::std::remove_cvref_t<                           \
                    Other>::executor_type::access(::std::declval<::scl::forward_like_t<Other,                               \
                        typename ::std::remove_cvref_t<Other>::executor_type>>());                                          \
            })                                                                                                              \
    {                                                                                                                       \
        executor_type::execute(m_executor, [](auto && scl_self, auto && scl_source) -> decltype(auto) {                     \
            return executor_type::access(::std::forward<decltype(scl_self)>(scl_self)) = ::std::remove_cvref_t<             \
                       Other>::executor_type::access(::std::forward<decltype(scl_source)>(scl_source));                     \
        }, m_executor, ::scl::feature::detail::executor_access::get(::std::forward<Other>(other)));                         \
        return *this;                                                                                                       \
    }