property_execution.h

#pragma once

 
#include <scl/feature/type_traits/executor.h>
#include <scl/utility/type_traits/forward_like.h>
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace scl::feature::detail
{
    template <typename OuterExecutorType, typename PropertyTag>
    struct property_execution
    {
        template <typename PropertyType>
        class holder
        {
        public:
            using value_type = PropertyType;

            using outer_value_type = ::std::remove_reference_t<
                decltype(OuterExecutorType::access(::std::declval<OuterExecutorType &>()))>;

            using member_pointer_type = PropertyType outer_value_type::*;
 
        private:
            ::std::ptrdiff_t m_offset;              
            member_pointer_type m_property_pointer; 
 
        private:
            // ── offset-based executor access ──────────────────────────────────

            template <typename Self>
            [[nodiscard]]
            static auto
            outer_exec_ptr(Self && self) noexcept // NOLINT(cppcoreguidelines-missing-std-forward)
                requires ::std::same_as<::std::remove_cvref_t<Self>, holder>
            {
                using exec_obj = ::std::remove_reference_t<::scl::forward_like_t<Self, OuterExecutorType>>;
                using byte_cv = ::std::remove_reference_t<::scl::forward_like_t<Self, ::std::byte>>;
 
                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic)
                byte_cv * const cursor = reinterpret_cast<byte_cv *>(&self) - self.m_offset;
                return reinterpret_cast<exec_obj *>(cursor); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
            }
 
            // ── noexcept predicate for access() ────────────────────────────────

            template <typename Self>
            static constexpr bool access_noexcept =
                PropertyTag::template override_noexcept<::scl::forward_like_t<Self, OuterExecutorType>>;
 
        public:
            // ── construction ──────────────────────────────────────────────────

            holder(OuterExecutorType const * exec, member_pointer_type property_pointer) noexcept
                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                : m_offset{reinterpret_cast<::std::byte const *>(this) - reinterpret_cast<::std::byte const *>(exec)}
                , m_property_pointer{property_pointer}
            {}

            holder(holder const &) = default;
            holder(holder &&) = default;
            holder & operator=(holder const &) = delete;
            holder & operator=(holder &&) = delete;
            ~holder() = default;
 
            // ── executor interface ────────────────────────────────────────────

            template <typename Self>
            static decltype(auto) access(Self && self) noexcept(access_noexcept<Self>)
                requires ::std::same_as<::std::remove_cvref_t<Self>, holder>
            {
                using exec_refer = ::scl::forward_like_t<Self, OuterExecutorType>;
 
                if constexpr (PropertyTag::template has_override<exec_refer>)
                {
                    return PropertyTag::call_override(
                        ::scl::forward_like<Self>(*outer_exec_ptr(::std::forward<Self>(self))));
                }
                else
                {
                    auto property_pointer = self.m_property_pointer;
                    auto * const exec = outer_exec_ptr(::std::forward<Self>(self));
                    return OuterExecutorType::execute(::scl::forward_like<Self>(*exec),
                        [property_pointer](auto && scl_e) -> decltype(auto) {
                        // access() is resolved here, inside execute() (after any guard()),
                        // so guarding executors (e.g. copy-on-write) project the field
                        // from the post-guard value rather than a pre-guard reference.
                        decltype(auto) v = OuterExecutorType::access(::std::forward<decltype(scl_e)>(scl_e));
                        using property_refer = ::scl::forward_like_t<decltype(v), PropertyType>;
                        return static_cast<property_refer>(::std::forward<decltype(v)>(v).*property_pointer);
                    }, ::scl::forward_like<Self>(*exec));
                }
            }

            template <typename Self, typename Func>
            static decltype(auto) execute(Self && self, Func && func)
                requires ::std::same_as<::std::remove_cvref_t<Self>, holder>
            {
                return OuterExecutorType::execute(
                    ::scl::forward_like<Self>(*outer_exec_ptr(::std::forward<Self>(self))),
                    ::std::forward<Func>(func));
            }
 
            // ── optional guard / unguard ──────────────────────────────────────

            template <typename Self>
            static void guard(Self && self) /**/
                noexcept(is_guard_noexcept_v<OuterExecutorType, ::scl::forward_like_t<Self, OuterExecutorType>>)
                requires ::std::same_as<::std::remove_cvref_t<Self>, holder> &&
                requires {
                    OuterExecutorType::guard(
                        ::std::declval<::scl::forward_like_t<Self, OuterExecutorType>>());
                }
            {
                OuterExecutorType::guard(
                    ::scl::forward_like<Self>(*outer_exec_ptr(::std::forward<Self>(self))));
            }

            template <typename Self>
            static void unguard(Self && self) /**/
                noexcept(is_unguard_noexcept_v<OuterExecutorType, ::scl::forward_like_t<Self, OuterExecutorType>>)
                requires ::std::same_as<::std::remove_cvref_t<Self>, holder> &&
                requires {
                    OuterExecutorType::unguard(
                        ::std::declval<::scl::forward_like_t<Self, OuterExecutorType>>());
                }
            {
                OuterExecutorType::unguard(
                    ::scl::forward_like<Self>(*outer_exec_ptr(::std::forward<Self>(self))));
            }
        };
    };
} // namespace scl::feature::detail