welder.hpp

Go to the documentation of this file.

#pragma once
#include <meta>
#include <type_traits>
 
#include <welder/carriage.hpp> // the traversal driver + stitch/tack carriage aliases
#include <welder/concepts.hpp> // the welder::rod contract
#include <welder/naming.hpp>   // naming::none (the default name style)

 
namespace welder::inline v0 {

template <rod B, class Style = naming::none, class Carriage = carriage>
struct welder {
    using rod_type = B;
    using name_style = Style;
    using carriage_type = Carriage;
    using module_type = typename B::module_type;

    static constexpr auto noop{[](module_type&) {}};

    template <class T>
    static auto weld_type(module_type& m, const char* name = nullptr) {
        if constexpr (std::is_enum_v<T>)
            return Carriage::template bind_enum<B, T, Style>(m, name);
        else
            return Carriage::template bind_type<B, T, Style>(m, name);
    }

    template <std::meta::info Alias>
    static auto weld_type(module_type& m, const char* name = nullptr) {
        using T = [:Alias:];
        static_assert(!std::is_enum_v<T>,
                      "welder: weld_type<Alias>: enums are never alias-welded — "
                      "call weld_type<E>() with the enum type itself");
        return Carriage::template bind_type<B, T, Style, Alias>(m, name);
    }

    template <std::meta::info Fn>
    static auto weld_function(module_type& m, const char* name = nullptr) {
        return Carriage::template bind_function<B, Fn, Style>(m, name);
    }

    template <std::meta::info Var>
    static auto weld_variable(module_type& m, const char* name = nullptr) {
        return Carriage::template bind_variable<B, Var, Style>(m, name);
    }

    template <std::meta::info Ns>
    static module_type& weld_namespace(module_type& m) {
        Carriage::template bind_namespace<B, Ns, Style>(m);
        return m;
    }

    template <std::meta::info Ns>
    static module_type weld_namespace_as_submodule(module_type& m,
                                                   const char* name = nullptr) {
        return Carriage::template bind_namespace_as_submodule<B, Ns, Style>(m, name);
    }

    template <std::meta::info Ns, class Pre = decltype(noop),
              class Post = decltype(noop)>
    static module_type& weld_module(module_type& m, Pre pre = noop,
                                    Post post = noop) {
        Carriage::template build_module<B, Ns, Style>(m, pre, post);
        return m;
    }
};
 
} // namespace welder