concepts.hpp

Go to the documentation of this file.

#pragma once
#include <array> // overload-group probes (std::array<std::meta::info, N> NTTPs)
#include <concepts>
#include <meta>
#include <ranges>
#include <string>
#include <type_traits>
#include <utility>

 
namespace welder::inline v0 {
 
namespace detail {

struct any_type {};

enum class any_enum {};
 
} // namespace detail

namespace detail {
struct function_doc;
struct enum_doc;
} // namespace detail

template <class B>
concept caster_oracle = requires {
    { B::template has_native_caster<detail::any_type> } -> std::convertible_to<bool>;
};

template <class B>
concept two_phase_rod = requires(typename B::module_type& m, const char* s) {
    B::template reopen_class<detail::any_type>(m, s);
};

template <class B>
concept rod =
    caster_oracle<B> &&
    requires {
        { B::language } -> std::convertible_to<lang>;
        typename B::module_type;
    } &&
    // Module / session machinery + the handle-free per-entity hooks. Every requirement
    // here takes concrete arguments and returns void or an explicit type, so only the
    // signatures are substituted — no hook body is instantiated (the reflection/type
    // template arguments, e.g. `^^int` / `detail::any_type`, reach only the bodies,
    // which a requires-expression leaves untouched). The per-handle hooks follow in
    // their own conjunct below; only the make_class/make_enum factories stay unprobed
    // (see the concept's @note).
    requires(typename B::module_type& m, const char* s,
             std::remove_cvref_t<decltype(B::open_module(
                 std::declval<typename B::module_type&>()))> session) {
        { B::open_module(m) };
        { B::add_submodule(m, s) } -> std::same_as<typename B::module_type>;
        B::set_module_doc(m, s);
        B::close_module(m, session);
        { B::special_method_name(^^int) } -> std::convertible_to<const char*>;
        B::template add_function<std::array<std::meta::info, 1>{^^int},
                                 detail::any_type>(m);
        B::template add_variable<^^int, detail::any_type>(m, session);
    } &&
    // The per-class / per-enum hooks, probed against the rod's declared handle types
    // (@ref class_handle_type / @ref enum_handle_type — the associated types naming what
    // make_class / make_enum yield). All return void, so given the handle type only the
    // signatures are checked; the placeholder reflections (`^^int`) / types
    // (@ref detail::any_type) reach only the bodies, which are not instantiated.
    requires(typename B::template class_handle_type<detail::any_type>& cls,
             typename B::template enum_handle_type<detail::any_enum>& en,
             const char* s) {
        B::template add_constructors<detail::any_type,
                                     std::array<std::meta::info, 0>{}, false,
                                     false, false>(cls);
        B::template add_field<^^int, detail::any_type>(cls);
        B::template add_property<detail::any_type, ^^int, std::meta::info{}>(cls,
                                                                             s);
        B::template add_method<std::array<std::meta::info, 1>{^^int},
                               detail::any_type>(cls);
        B::template add_static_method<std::array<std::meta::info, 1>{^^int},
                                      detail::any_type>(cls);
        B::template add_operator<detail::any_type,
                                 std::array<std::meta::info, 1>{^^int}>(cls);
        B::template add_comparisons<detail::any_type,
                                    std::array<std::meta::info, 1>{^^int},
                                    std::array<bool, 4>{}>(cls);
        B::template add_stringifier<detail::any_type, ^^int>(cls);
        B::template add_enumerator<^^int, detail::any_type>(en);
        B::template finish_enum<detail::any_enum>(en);
    };

*/
template <class R>
concept resolution =
    requires(std::meta::info e, lang L, policy_kind pol, std::meta::info into) {
        { R::participates(e, L) } -> std::convertible_to<bool>;
        { R::is_native_base(e, L, into) } -> std::convertible_to<bool>;
        { R::member_participates(e, L, pol, into) } -> std::convertible_to<bool>;
        { R::class_member_participates(e, L, pol, into) } -> std::convertible_to<bool>;
        { R::namespace_participates(e, L, pol, into) } -> std::convertible_to<bool>;
        { R::counts_as_registered(e, L) } -> std::convertible_to<bool>;
    } &&
    requires {
        { R::template native_bases<^^detail::any_type, lang{}>() }
            -> std::ranges::range;
        requires std::same_as<
            std::ranges::range_value_t<
                decltype(R::template native_bases<^^detail::any_type, lang{}>())>,
            std::meta::info>;
    };

*/
template <class S>
concept doc_style = requires(const detail::function_doc& d, const detail::enum_doc& e) {
    { S::format(d) } -> std::same_as<std::string>;
    { S::format_enum(e) } -> std::same_as<std::string>;
};
 
namespace naming {

    @tparam S the candidate style type. */
template <class S>
concept name_style = requires {
    { S::transform_class(^^int) } -> std::convertible_to<std::string>;
    { S::transform_enum(^^int) } -> std::convertible_to<std::string>;
    { S::transform_enumerator(^^int) } -> std::convertible_to<std::string>;
    { S::transform_method(^^int) } -> std::convertible_to<std::string>;
    { S::transform_static_method(^^int) } -> std::convertible_to<std::string>;
    { S::transform_function(^^int) } -> std::convertible_to<std::string>;
    { S::transform_field(^^int) } -> std::convertible_to<std::string>;
    { S::transform_variable(^^int) } -> std::convertible_to<std::string>;
    { S::transform_submodule(^^int) } -> std::convertible_to<std::string>;
};
 
} // namespace naming
 
} // namespace welder