rod.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <meta>
#include <ostream>
#include <string>
#include <utility>
 
#include <welder/welder.hpp>                              // driver + rod contract
#include <welder/rods/python/trampolines/document.hpp>    // the emission core
 
namespace welder::inline v0::rods::trampolines {

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

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

    struct class_handle {};

    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: the one primitive that emits ------------------------

    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...>) {
        if constexpr (!::welder::overridable_virtuals(^^T).empty() &&
                      !::welder::bound_flat(^^T))
            m.doc->template add<^^T>();
        return {};
    }

    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...>) {
        if constexpr (!::welder::overridable_virtuals(Decl).empty() &&
                      !::welder::bound_flat(std::meta::dealias(Decl)))
            m.doc->template add<Decl>();
        return {};
    }
 
    template <class T, auto Ctors, bool HasDefault, bool Aggregate, bool Copyable,
              class Style = ::welder::naming::none>
    static void add_constructors(class_handle&) {}
    template <std::meta::info, class = ::welder::naming::none>
    static void add_field(class_handle&) {}
    template <class T, std::meta::info Getter, std::meta::info Setter>
    static void add_property(class_handle&, const char*) {}
    template <auto Fns, class = ::welder::naming::none>
    static void add_method(class_handle&) {}
    template <auto Fns, class = ::welder::naming::none>
    static void add_static_method(class_handle&) {}
    template <class T, auto Fns> static void add_operator(class_handle&) {}
    template <class T, auto Fns, auto Covered>
    static void add_comparisons(class_handle&) {}
    template <class T, std::meta::info Fn>
    static void add_stringifier(class_handle&) {}
 
    // --- enum binding: nothing to emit --------------------------------------
 
    template <class E>
    static enum_handle make_enum(module_type&, const char*, const char*) {
        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: threading only -------------------------
 
    static session open_module(module_type&) { return {}; }
    static void set_module_doc(module_type&, const char*) {}
    template <auto Fns, class = ::welder::naming::none>
    static void add_function(module_type&, const char* = nullptr) {}
    template <std::meta::info, class = ::welder::naming::none>
    static void add_variable(module_type&, session&, const char* = nullptr) {}

    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: trampolines::generate<Ns>: Ns must reflect a namespace");
        document doc{};
        module_type m{&doc, {}};
        ::welder::welder<rod, Style>::template weld_namespace<Ns>(m);
        os << doc.render();
    }
};
 
static_assert(::welder::rod<rod>,
              "welder::rods::trampolines::rod must satisfy welder::rod");
 
} // namespace welder::rods::trampolines