|
| template<rod B, class E, class Style = naming::none> |
| static auto | bind_enum (typename B::module_type &m, const char *name=nullptr) |
| | Reflect over enum E and register it via rod B onto module m.
|
| template<rod B, class T, std::meta::info Decl, auto Bases> |
| static auto | make_class_of (typename B::module_type &m, const char *cls_name, const char *doc) |
| | Call the rod's class-creation primitive, preferring the extended declaring-entity-aware form when the rod provides one.
|
| template<rod B, class T, class Style = naming::none, std::meta::info Decl = std::meta::info{}> |
| static auto | bind_type (typename B::module_type &m, const char *name=nullptr) |
| | Reflect over T and register it via rod B onto module m.
|
| template<rod B, class T, class Style = naming::none, std::meta::info Decl = std::meta::info{}> |
| static void | predeclare_type (typename B::module_type &m, const char *name=nullptr) |
| | Phase 1 of the two-phase sweep: register T's NAME only (create the class handle via make_class_of, then discard it — it lives in scope.attr(name)), WITHOUT filling its interior.
|
| template<rod B, class T, class Style = naming::none, std::meta::info Decl = std::meta::info{}> |
| static void | fill_type (typename B::module_type &m, const char *name=nullptr) |
| | Phase 3 of the two-phase sweep: RETRIEVE T's predeclared handle (via the rod's reopen_class) and fill its interior — nested types, constructors, members, methods, operators — exactly as bind_type's tail does.
|
| template<rod B, std::meta::info Fn, class Style = naming::none> |
| static auto | bind_function (typename B::module_type &m, const char *name=nullptr) |
| | Register free function Fn — with its participating overload siblings — as a module-level function of m.
|
| template<rod B, std::meta::info Var, class Style = naming::none> |
| static auto | bind_variable (typename B::module_type &m, const char *name=nullptr) |
| | Register a single namespace variable Var as an attribute of m.
|
| template<rod B, std::meta::info Ns, class Style = naming::none> |
| static void | bind_namespace (typename B::module_type &m) |
| | Reflect over a whole namespace Ns and expose its members on module m.
|
| template<rod B, std::meta::info Ns, class Style = naming::none> |
| static B::module_type | bind_namespace_as_submodule (typename B::module_type &m, const char *name=nullptr) |
| | Define a submodule of m and bind namespace Ns into it.
|
| template<rod B, std::meta::info Ns, class Style = naming::none, class Pre, class Post> |
| static void | build_module (typename B::module_type &m, Pre pre, Post post) |
| | Fill an existing module out of top-level namespace Ns: pre hook, bind the namespace, post hook.
|
|
| template<rod B, std::meta::info BoundInto, std::meta::info Src, class Style, class Cls> |
| static void | bind_members (Cls &cls) |
| | Flatten the eligible data members, methods and operators of Src onto the class handle cls (a handle for a type deriving from Src) — public ones, plus protected ones whose access is admitted (see detail::member_access_admitted; private never binds).
|
| template<rod B, class E, class Style, class EnumHandle> |
| static void | emit_enumerators (EnumHandle &e) |
| | The per-enumerator walk shared by bind_enum and bind_nested_enum: each enumerator resolves like a data member (the enum's policy + its own marks) and is emitted through the rod's add_enumerator.
|
| template<rod B, class E, class Style> |
| static std::vector< welder::detail::enumerator_doc > | collect_enum_docs () |
| | Gather the documented, participating enumerators of E as welder::detail::enumerator_doc entries, in declaration order, to fold into the enum's class docstring (an welder::detail::enum_doc).
|
| template<rod B, class T, class Style, class Cls> |
| static void | bind_class_interior (typename B::module_type &m, Cls &cls) |
| | Everything a class binding contains beyond the class handle itself — shared by bind_type (a module-scope class) and bind_nested_type (a class-scoped one).
|
| template<rod B, class T, class Style, class Cls> |
| static void | bind_properties (Cls &cls) |
| | Emit T's method-backed properties: every accessor-marked member function (own + flattened bases', see detail::collect_accessors), shape-validated and paired into one detail::property_entry per property name by detail::property_entries — the getter authoritative, the setter optional (absent = read-only).
|
| template<rod B, class T, class Cls> |
| static void | bind_operators (Cls &cls) |
| | Emit T's operators: member ones (own + flattened bases') and the anchored free operators** of T's enclosing namespace, combined per (operator, arity) slot (detail::operator_entries / operator_slot_set) so a one-value-per-slot backend (the Lua rods) receives each slot's complete overload set in one call — a free operator+ and a member operator+ can never clobber each other, and a flattened base's operator now shares its slot with the derived type's instead of being overwritten.
|
| template<rod B, std::meta::info Outer, class Style, class Cls> |
| static void | bind_nested_types (typename B::module_type &m, Cls &cls) |
| | Register the participating member types of Outer onto its class handle cls — the nested-class / nested-enum walk.
|
| template<rod B, class T, class Style, std::meta::info Decl = std::meta::info{}, class OuterCls> |
| static void | bind_nested_type (typename B::module_type &m, OuterCls &outer, const char *name=nullptr) |
| | Register nested class T onto the class handle of its enclosing type — bind_type's class-scope sibling.
|
| template<rod B, class E, class Style, class OuterCls> |
| static void | bind_nested_enum (typename B::module_type &m, OuterCls &outer, const char *name=nullptr) |
| | Register nested enum E onto the class handle of its enclosing type — bind_enum's class-scope sibling (see bind_nested_type for the shared rationale; the fallback for a rod without make_nested_enum is the module-scope make_enum).
|
| template<rod B, class T, std::meta::info Decl, auto Bases, class OuterCls> |
| static auto | make_nested_class_of (typename B::module_type &m, OuterCls &outer, const char *cls_name, const char *doc) |
| | Call the rod's nested-class primitive when it declares one, else fall back to the module-scope factory (flat placement).
|
| template<rod B, class E> |
| static auto | make_enum_of (typename B::module_type &m, const char *name, const welder::detail::enum_doc &ed) |
| | Create the module-scope enum handle for E, folding its enumerator docs into the class docstring where the backend supports it.
|
| template<rod B, class E, class OuterCls> |
| static auto | make_nested_enum_of (typename B::module_type &m, OuterCls &outer, const char *name, const welder::detail::enum_doc &ed) |
| | make_nested_class_of's enum counterpart: the rod's make_nested_enum when present, else the module-scope make_enum — each preferring the extended enum-doc-folding form over the legacy summary-only one, exactly like make_enum_of.
|
template<resolution Resolution>
struct welder::carriages::basic_carriage< Resolution >
A carriage: welder's reflection-driven traversal, parameterized on a Resolution (which markers it obeys).
In welding, the carriage (or tractor) is the mechanism that drives the torch — fed by the rod — steadily along the joint. Here it is the entity that walks a reflected type or namespace and drives a welder::rod's emission primitives along it: it owns all the traversal and emission orchestration (base flattening, the bindability gate, name resolution, sessions), delegating only the which participates decisions to Resolution and the framework-specific emission to the rod. It is a stateless policy struct of static member templates, each parameterized on the rod B and the name style Style.
Two are aliased for welder::welder's Carriage argument (defaulted to welder::stitch_welding_carriage): the marker-directed stitch carriage and the greedy tack carriage (welder::tack_welding_carriage). A user may inject either, or a bespoke basic_carriage<CustomResolution> — the seam is deliberately open. The members cross-reference each other (a namespace's class members bind via bind_type, a nested namespace recurses via bind_namespace), so a replacement is expected to be a coherent whole rather than a partial override.
- Template Parameters
-
Definition at line 468 of file carriage.hpp.
template<resolution Resolution>
template<rod B, std::meta::info BoundInto, std::meta::info Src, class Style, class Cls>
Flatten the eligible data members, methods and operators of Src onto the class handle cls (a handle for a type deriving from Src) — public ones, plus protected ones whose access is admitted (see detail::member_access_admitted; private never binds).
A base that Resolution treats as native is skipped here (it binds as a base of the class handle); the rest are recursed first so that, on a name clash, the member declared closer to the derived type wins. Constructors are never flattened (the derived type provides its own).
- Template Parameters
-
| B | the rod. |
| BoundInto | the welded type whose class handle receives the members — held fixed through the flattening recursion, and handed to the resolution hooks as their bound-into context. |
| Src | a reflection of the (base or derived) type whose members to flatten. |
| Style | the name style each member's name flows through. |
| Cls | the rod's class-handle type (deduced). |
- Parameters
-
| cls | the class handle to register onto. |
Definition at line 491 of file carriage.hpp.
Referenced by welder::carriages::basic_carriage< carriages::marker_resolution >::bind_class_interior().
template<resolution Resolution>
template<rod B, class T, class Style, std::meta::info Decl = std::meta::info{}, class OuterCls>
Register nested class T onto the class handle of its enclosing type — bind_type's class-scope sibling.
Same interior (constructors, fail-safes, members, its own nested types — so nesting recurses), differing only in where the class handle is created: a rod implementing the optional make_nested_class places the new class under outer (the Python rods pass the enclosing class as the registration scope, yielding module.Outer.Inner); one that doesn't falls back to the module-scope make_class — a flat sibling under its usual resolved name, so two outers' same-named nested types then collide (rename with weld_as, or implement the hook).
No participates assert here: participation was the caller's member resolution (a nested type needs no weld).
- Template Parameters
-
| B | the rod. |
| T | the nested class type. |
| Style | the name style. |
| Decl | the declaring entity when it differs from ^^T — the MEMBER ALIAS a type was welded through (the alias is the one spellable name an aliased specialization has, which the text-emitting rods need); a null reflection for the declared-nested route. |
- Parameters
-
| m | the module handle (the flat-placement fallback scope). |
| outer | the enclosing type's class handle. |
| name | the bound name (an alias-resolved override), or nullptr to resolve T's weld_as/styled name. |
Definition at line 998 of file carriage.hpp.
Referenced by welder::carriages::basic_carriage< carriages::marker_resolution >::bind_nested_types().
template<resolution Resolution>
template<rod B, std::meta::info Outer, class Style, class Cls>
Register the participating member types of Outer onto its class handle cls — the nested-class / nested-enum walk.
A nested type resolves like any other class member — the outer's policy plus the type's own exclude/include/only marks (class_member_participates), with the usual access admission — never via its own weld: nested types are interface helpers of their enclosing type, and the enclosing weld is the discovery marker. Deliberately skipped:
- member type aliases (binding one would re-register its target; the alias-welding route is namespace-scope only);
- unions (is_class_type excludes them) — unions never bind anywhere in welder (reading an inactive member is UB; use std::variant), so a nested one is skipped and any member using it fails the gate with the union diagnostic;
- unnamed types (there is nothing to name them by — bind the member* of that type or exclude it), and incomplete member types (nothing to register; a use of one also fails the gate);
- a flattened base's nested types: a nested type registers exactly once, with its DECLARING class — two derived types flattening one mixin would otherwise register it twice (a framework load error). A flattened signature naming one therefore fails the gate until the declaring base is welded (or the member trusted/excluded).
- Template Parameters
-
| B | the rod. |
| Outer | the enclosing (welded) type being bound. |
| Style | the name style. |
- Parameters
-
| m | the module handle (the flat-placement fallback scope). |
| cls | the outer type's class handle. |
Definition at line 892 of file carriage.hpp.
Referenced by welder::carriages::basic_carriage< carriages::marker_resolution >::bind_class_interior().
template<resolution Resolution>
template<rod B, class T, class Cls>
Emit T's operators: member ones (own + flattened bases') and the anchored free operators** of T's enclosing namespace, combined per (operator, arity) slot (detail::operator_entries / operator_slot_set) so a one-value-per-slot backend (the Lua rods) receives each slot's complete overload set in one call — a free operator+ and a member operator+ can never clobber each other, and a flattened base's operator now shares its slot with the derived type's instead of being overwritten.
Three routes out of the combined entry list:
- a spaceship group (operator<=>, member or free) never binds directly — it reaches the rod as add_comparisons, which synthesizes the four relational slots via rewritten expressions (a < b), skipping any slot an explicit participating operator already covers (covered_comparison_slots); only the operand types face the gate (the std::*_ordering return never crosses);
- the free ostream inserter (operator<<(std::ostream&, T)) becomes the rod's stringifier (__str__ / __tostring) via add_stringifier — collected separately, so its std::ostream& never faces the gate;
- every other slot goes to add_operator when the rod exposes it (special_method_name on the slot's leader), each entry gated whole.
- Template Parameters
-
| B | the rod. |
| T | the welded type. |
- Parameters
-
Definition at line 813 of file carriage.hpp.
Referenced by welder::carriages::basic_carriage< carriages::marker_resolution >::bind_class_interior().
template<resolution Resolution>
template<rod B, class T, class Style, class Cls>
template<resolution Resolution>
template<rod B, class T, std::meta::info Decl, auto Bases>
Call the rod's class-creation primitive, preferring the extended declaring-entity-aware form when the rod provides one.
Decl is the entity the type was declared through — ^^T, or the namespace-scope alias welding a class-template specialization. A helper (not a lambda in bind_type): std::meta::info is consteval-only, so a lambda referencing such a constexpr local escalates to consteval (P2564) and cannot take the runtime module handle; template parameters do not.
- Template Parameters
-
| B | the rod. |
| T | the type to bind. |
| Decl | the declaring entity handed to a spelling-aware rod. |
| Bases | the native base reflections. |
- Parameters
-
| m | the module handle to register onto. |
| cls_name | the resolved target-language name. |
| doc | the class docstring, or nullptr. |
- Returns
- the rod's class handle.
Definition at line 1192 of file carriage.hpp.
Referenced by welder::carriages::basic_carriage< carriages::marker_resolution >::make_nested_class_of().
template<resolution Resolution>
template<rod B, class T, std::meta::info Decl, auto Bases, class OuterCls>
| auto welder::carriages::basic_carriage< Resolution >::make_nested_class_of |
( |
typename B::module_type & | m, |
|
|
OuterCls & | outer, |
|
|
const char * | cls_name, |
|
|
const char * | doc ) |
|
inlinestaticprivate |
Call the rod's nested-class primitive when it declares one, else fall back to the module-scope factory (flat placement).
A static helper, not a lambda in bind_nested_type, for the same P2564 reason as make_class_of.
A spelling-aware rod may declare the extended, declaring-entity-aware form make_nested_class<T, Decl, Bases> (preferred when Decl is set — the member alias an unnameable specialization was welded through); the flat fallback likewise threads Decl into make_class_of, so a text-emitting rod's extended make_class receives it too.
- Template Parameters
-
| B | the rod. |
| T | the nested class type. |
| Decl | the declaring member alias, or a null reflection. |
| Bases | the native base reflections. |
- Parameters
-
| m | the module handle. |
| outer | the enclosing type's class handle. |
| cls_name | the resolved target-language name. |
| doc | the class docstring, or nullptr. |
- Returns
- the rod's class handle for T.
Definition at line 1067 of file carriage.hpp.
1.17.0