wrapper.h

#pragma once
 
#ifndef DOXYGEN
 
#include <scl/feature/detail/wrapper.h>
#include <scl/feature/executor/inplace/plain.h>
 
#include <type_traits>
 
namespace scl::feature::detail
{
    template <typename State, template <typename> class... Executor>
    struct wrapper_fold
    {
        using type = State;
    };
 
    template <typename State, template <typename> class Executor, template <typename> class... Rest>
    struct wrapper_fold<State, Executor, Rest...>
    {
        using type = typename wrapper_fold<::scl::feature::detail::wrapper<State, Executor>, Rest...>::type;
    };
 
    template <typename Value, template <typename> class Executor, template <typename> class... Rest>
    struct wrapper_fold<::scl::feature::detail::wrapper<Value, Executor>, Executor, Rest...>
    {
        using type = typename wrapper_fold<::scl::feature::detail::wrapper<Value, Executor>, Rest...>::type;
    };
} // namespace scl::feature::detail
 
namespace scl
{
    template <typename Value, template <typename> class... Executors>
    using wrapper = ::std::conditional_t<sizeof...(Executors) == 0,
        typename ::scl::feature::detail::wrapper_fold<Value, ::scl::feature::inplace::plain>::type,
        typename ::scl::feature::detail::wrapper_fold<Value, Executors...>::type>;
} // namespace scl
 
#else // DOXYGEN
 
namespace scl
{

    template <typename Value, template <typename> class... Executors>
    class wrapper
    {
    public:
        using value_type = Value;

        using executor_type = /* implementation defined */;

        constexpr wrapper()
            requires ::std::default_initializable<executor_type>;

        template <typename... Args>
        constexpr explicit wrapper(Args &&... args)
            requires ::std::constructible_from<executor_type, Args...>;

        constexpr wrapper(wrapper & other)
            requires ::std::constructible_from<executor_type, executor_type &>;
        constexpr wrapper(wrapper const & other)
            requires ::std::constructible_from<executor_type, executor_type const &>;
        constexpr wrapper(wrapper volatile & other)
            requires ::std::constructible_from<executor_type, executor_type volatile &>;
        constexpr wrapper(wrapper const volatile & other)
            requires ::std::constructible_from<executor_type, executor_type const volatile &>;
        constexpr wrapper(wrapper && other)
            requires ::std::constructible_from<executor_type, executor_type &&>;
        constexpr wrapper(wrapper const && other)
            requires ::std::constructible_from<executor_type, executor_type const &&>;
        constexpr wrapper(wrapper volatile && other)
            requires ::std::constructible_from<executor_type, executor_type volatile &&>;
        constexpr wrapper(wrapper const volatile && other)
            requires ::std::constructible_from<executor_type, executor_type const volatile &&>;

        template <concepts::wrapper Other>
        constexpr wrapper(Other && other)
            requires(!::std::same_as<::std::remove_cvref_t<Other>, wrapper> &&
                ::std::constructible_from<executor_type,
                    decltype(wrapper_constructor_resolver<wrapper, Other &&>{other}.resolve())>);
    };
 // end of group scl_feature_wrapper
} // namespace scl
 
#endif // DOXYGEN