rod.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <meta>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>
 
#include <welder/welder.hpp>
#include <welder/rods/python/opaque_containers/document.hpp>
#include <welder/rods/python/opaque_containers/marks.hpp> // marked_by_value
 
namespace welder::inline v0::rods::opaque_containers {

struct rod {
    static constexpr lang language{lang::py}; 

    struct module_handle {
        document* doc{};
        std::string prefix{};
    };
    using module_type = module_handle;

    struct class_handle {
        document* doc{};
    };

    struct enum_handle {};
 
    template <class> using class_handle_type = class_handle;
    template <class> using enum_handle_type = enum_handle;
 
    struct session {}; 

    template <class T>
    static constexpr bool has_native_caster = true;

    static consteval const char* special_method_name(std::meta::info) {
        return nullptr;
    }
 
    // --- class binding: pass the document down to the per-member hooks -------
 
    template <class T, auto Bases, std::size_t... I>
    static class_handle make_class(module_type& m, const char* /*name*/,
                                   const char* /*doc*/, std::index_sequence<I...>) {
        return {m.doc};
    }

    template <class T, std::meta::info Decl, auto Bases, std::size_t... I>
    static class_handle make_class(module_type& m, const char* /*name*/,
                                   const char* /*doc*/, std::index_sequence<I...>) {
        return {m.doc};
    }
    template <class T, auto Bases, std::size_t... I>
    static class_handle make_nested_class(module_type& m, class_handle&,
                                          const char* /*name*/, const char* /*doc*/,
                                          std::index_sequence<I...>) {
        return {m.doc};
    }

    template <class T, auto Ctors, bool HasDefault, bool Aggregate, bool Copyable,
              class Style = ::welder::naming::none>
    static void add_constructors(class_handle& cls) {
        template for (constexpr auto ctor : std::define_static_array(Ctors))
            cls.doc->template collect_callable<ctor, Style>(false);
    }

    template <std::meta::info Mem, class Style = ::welder::naming::none>
    static void add_field(class_handle& cls) {
        cls.doc->template collect<std::meta::type_of(Mem), Style,
                                  std::meta::parent_of(Mem), Mem>(
            ::welder::rods::python::marked_by_value(Mem), true);
    }

    template <class T, std::meta::info Getter, std::meta::info Setter>
    static void add_property(class_handle& cls, const char*) {
        cls.doc->template collect_callable<Getter, ::welder::naming::none>(false);
        if constexpr (Setter != std::meta::info{})
            cls.doc->template collect_callable<Setter, ::welder::naming::none>(false);
    }
 
    template <auto Fns, class Style = ::welder::naming::none>
    static void add_method(class_handle& cls) {
        template for (constexpr auto fn : std::define_static_array(Fns))
            cls.doc->template collect_callable<fn, Style>(true);
    }
    template <auto Fns, class Style = ::welder::naming::none>
    static void add_static_method(class_handle& cls) {
        template for (constexpr auto fn : std::define_static_array(Fns))
            cls.doc->template collect_callable<fn, Style>(true);
    }
    template <class T, auto Fns>
    static void add_operator(class_handle& cls) {
        template for (constexpr auto fn : std::define_static_array(Fns))
            cls.doc->template collect_callable<fn, ::welder::naming::none>(false);
    }
    template <class T, auto Fns, auto Covered>
    static void add_comparisons(class_handle&) {} // spaceship operands are the anchor type
    template <class T, std::meta::info Fn>
    static void add_stringifier(class_handle&) {} // ostream inserter: no container surface
 
    // --- enum binding: nothing to collect -----------------------------------
 
    template <class E>
    static enum_handle make_enum(module_type&, const char*,
                                 const ::welder::detail::enum_doc&) {
        return {};
    }
    template <class E>
    static enum_handle make_nested_enum(module_type&, class_handle&, const char*,
                                        const ::welder::detail::enum_doc&) {
        return {};
    }
    template <std::meta::info, class = ::welder::naming::none>
    static void add_enumerator(enum_handle&) {}
    template <class E> static void finish_enum(enum_handle&) {}
 
    // --- namespace / module binding -----------------------------------------
 
    static session open_module(module_type&) { return {}; }
    static void set_module_doc(module_type&, const char*) {}

    template <auto Fns, class Style = ::welder::naming::none>
    static void add_function(module_type& m, const char* = nullptr) {
        template for (constexpr auto fn : std::define_static_array(Fns))
            m.doc->template collect_callable<fn, Style>(true);
    }

    template <std::meta::info Var, class Style = ::welder::naming::none>
    static void add_variable(module_type& m, session&, const char* = nullptr) {
        m.doc->template collect<std::meta::type_of(Var), Style,
                                std::meta::parent_of(Var), Var>(false, true);
    }

    static module_type add_submodule(module_type& m, const char* name) {
        return module_type{m.doc, m.prefix.empty() ? std::string{name}
                                                   : m.prefix + "." + name};
    }
    static void close_module(module_type&, session&) {}
 
    // --- whole-header generation (this backend's extra entry point) ----------

    template <std::meta::info Ns, class Style = ::welder::naming::none>
    static void generate(std::ostream& os) {
        static_assert(std::meta::is_namespace(Ns),
                      "welder: opaque_containers::generate<Ns>: Ns must reflect a "
                      "namespace");
        document doc{};
        module_type m{&doc, {}};
        ::welder::welder<rod, Style>::template weld_namespace<Ns>(m);
        // namespace_name is consteval (heap std::string), so materialize its result
        // to a static C-string before it crosses into this runtime call.
        os << doc.render(std::define_static_string(namespace_name(Ns)));
    }
};
 
static_assert(::welder::rod<rod>,
              "welder::rods::opaque_containers::rod must satisfy welder::rod");
 
} // namespace welder::inline v0::rods::opaque_containers