context.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace yorch::detail {
 
template <typename T, typename... Ts>
inline constexpr std::size_t type_count_v = (std::size_t{0} + ... + (std::is_same_v<T, Ts> ? 1 : 0));
 
template <typename... Ts>
inline constexpr bool unique_types_v = ((type_count_v<Ts, Ts...> == 1) && ...);
 
template <typename>
inline constexpr bool no_prev_always_false_v = false;
 
} // namespace yorch::detail
 
namespace yorch {
 
struct no_prev {
    template <typename T>
    [[nodiscard]] static constexpr bool contains() noexcept {
        return false;
    }
 
    template <typename T>
    constexpr auto get() const -> T& {
        static_assert(detail::no_prev_always_false_v<T>,
                      "no_prev does not carry a direct parent value");
    }
};
 
template <typename T>
struct prev_slot_view {
    using stored_type = std::remove_reference_t<T>;
    using type = std::remove_cv_t<stored_type>;
 
    static_assert(!std::is_void_v<type>,
                  "prev_slot_view<T> requires a non-void payload type");
 
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    stored_type& ref;
 
    template <typename U>
    [[nodiscard]] static constexpr bool contains() noexcept {
        return std::is_same_v<std::remove_cv_t<U>, type>;
    }
 
    template <typename U>
    constexpr stored_type& get() const noexcept {
        static_assert(contains<U>(),
                      "Requested type is not present in the direct parent slot");
        return ref;
    }
};
 
template <typename T>
[[nodiscard]] constexpr auto prev_slot(T& value) noexcept
    -> prev_slot_view<T> {
    return {value};
}
 
template <typename... Ts>
struct context {
    static_assert(detail::unique_types_v<Ts...>,
                  "yorch::context<Ts...> requires unique types");
 
    std::tuple<Ts...> storage;
 
    constexpr context()
        requires (std::default_initializable<Ts> && ...)
    = default;
 
    template <typename... Us>
        requires (sizeof...(Us) == sizeof...(Ts)) &&
                 std::constructible_from<std::tuple<Ts...>, Us&&...>
    constexpr explicit context(Us&&... xs)
        : storage(std::forward<Us>(xs)...) {}
 
    template <typename T>
    [[nodiscard]] static constexpr bool contains() noexcept {
        return detail::type_count_v<T, Ts...> == 1;
    }
 
    template <typename T>
    constexpr T& get() & noexcept {
        static_assert(contains<T>(),
                      "T must appear exactly once in yorch::context");
        return std::get<T>(storage);
    }
 
    template <typename T>
    constexpr const T& get() const& noexcept {
        static_assert(contains<T>(),
                      "T must appear exactly once in yorch::context");
        return std::get<T>(storage);
    }
 
    template <typename T>
    constexpr T&& get() && noexcept {
        static_assert(contains<T>(),
                      "T must appear exactly once in yorch::context");
        return std::get<T>(std::move(storage));
    }
 
    template <typename T>
    constexpr const T&& get() const&& noexcept {
        static_assert(contains<T>(),
                      "T must appear exactly once in yorch::context");
        return std::get<T>(std::move(storage));
    }
};
 
template <typename Ctx, typename Prev = no_prev>
struct exec_context {
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    Ctx& ctx;
 
    Prev prev;
 
    [[nodiscard]] constexpr Prev& prev_view() & noexcept {
        return prev;
    }
 
    [[nodiscard]] constexpr const Prev& prev_view() const& noexcept {
        return prev;
    }
};
 
template <typename Ctx>
struct exec_context<Ctx, no_prev> {
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    Ctx& ctx;
 
    [[nodiscard]] constexpr no_prev prev_view() const noexcept {
        return {};
    }
};
 
template <>
struct exec_context<void, no_prev> {
    // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
    [[nodiscard]] constexpr no_prev prev_view() const noexcept {
        return {};
    }
};
 
template <typename Prev>
struct exec_context<void, Prev> {
    Prev prev;
 
    [[nodiscard]] constexpr Prev& prev_view() & noexcept {
        return prev;
    }
 
    [[nodiscard]] constexpr const Prev& prev_view() const& noexcept {
        return prev;
    }
};
 
}  // namespace yorch