The pybind11 rod: a stateless policy type satisfying welder::rod. More...

#include <welder/rods/python/pybind11/rod.hpp>

Classes
struct	enum_handle
	Owning handle for a py::native_enum<E>, plus the scope + name to reach the finalized enum object. More...

Public Types
using	module_type = py::module_
	pybind11's module handle.
template<class T>
using	construction_type
	The type welder constructs when binding T — its registered trampoline if one exists, else T — so an abstract base with a trampoline stays constructible from a Python subclass.
template<class T>
using	class_handle_type
	The class / enum handles the per-class / per-enum hooks operate on — exactly what make_class / make_enum yield.
template<class E>
using	enum_handle_type = enum_handle<E>

Static Public Member Functions
static consteval const char *	special_method_name (std::meta::info op_fn)
	Map a member operator to its Python dunder (nullptr = not exposed).
template<class T, auto Bases, std::size_t... I>
static auto	make_class (module_type &m, const char name, const char doc, std::index_sequence< I... > seq)
	Create the py::class_<T, Bases…> handle, weaving in a trampoline when T is a welded virtual type with a registered welder::rods::python::trampoline_for.
template<class T, auto Bases, std::size_t... I>
static auto	make_nested_class (module_type &, auto &outer_cls, const char name, const char doc, std::index_sequence< I... > seq)
	Create the py::class_ for a nested member type T, registered under its enclosing type's class handle rather than the module — Python then sees it as module.Outer.Inner (and __qualname__ nests), exactly like a hand-written py::class_<Outer::Inner>(outer_cls, "Inner").
template<class T, auto Ctors, bool HasDefault, bool Aggregate, bool Copyable, class Style = ::welder::naming::none>
static void	add_constructors (auto &cls)
	Bind T's whole constructor set (a chained-def framework just loops it): the default constructor when HasDefault, a py::init<…> per member of Ctors, and the synthesized aggregate field constructor when Aggregate.
template<std::meta::info Mem, class Style = ::welder::naming::none>
static void	add_field (auto &cls)
	Bind data member Mem as an attribute.
template<class T, std::meta::info Getter, std::meta::info Setter>
static void	add_property (auto &cls, const char *name)
	Bind the resolved property (Getter + optional Setter) as a Python property named name (driver-resolved).
template<auto Fns, class Style = ::welder::naming::none>
static void	add_method (auto &cls)
	Bind method overload group Fns (name from Fns[0]; pybind11 chains one .def per overload and dispatches at call time).
template<auto Fns, class Style = ::welder::naming::none>
static void	add_static_method (auto &cls)
	Bind static-method overload group Fns.
template<class T, auto Fns>
static void	add_operator (auto &cls)
	Bind operator slot group Fns — one (operator, arity) slot whole, member and anchored free entries mixed.
template<class T, auto Fns, auto Covered>
static void	add_comparisons (auto &cls)
	Synthesize the relational dunders from operator<=> group Fns: for each spaceship overload's operand type, bind plain rewritten expressions (a < b, …) — C++'s own rewriting rules pick the right overload, so Python comparisons match C++ exactly, heterogeneous operands included (the reversed direction rides Python's reflected protocol: 5 < obj → obj.__gt__(5)).
template<class T, std::meta::info Fn>
static void	add_stringifier (auto &cls)
	Bind the swept free ostream inserter Fn as __str__ (via welder::detail::stringify).
template<class T>
static class_handle_type< T >	reopen_class (module_type &scope, const char *name)
	Retrieve the ALREADY-registered class T as a fillable handle — the two-phase binding hook (welder::caster_oracle-adjacent, optional).
template<class T>
static class_handle_type< T >	reopen_nested_class (module_type &, auto &outer, const char *name)
	The nested-scope form of reopen_class — retrieve T from its enclosing type's class handle (outer.attr(name)) rather than the module.
static std::string	_enum_docstring (const ::welder::detail::enum_doc &ed)
	Assemble ed — the enum summary plus its documented enumerators — into the enum's class docstring under this rod's DocStyle: the summary, then an Attributes section listing each enumerator's doc.
template<class E>
static enum_handle< E >	make_enum (module_type &m, const char *name, const ::welder::detail::enum_doc &ed)
	Create the enum_handle for E; ed's summary + enumerator docs become its class docstring (see _enum_docstring).
template<class E>
static enum_handle< E >	make_nested_enum (module_type &, auto &outer_cls, const char *name, const ::welder::detail::enum_doc &ed)
	Create the enum_handle for a nested member enum E, scoped to its enclosing type's class handle — Python sees module.Outer.Mode, and an unscoped* nested enum's export_values() lands its enumerators on the class (mirroring C++'s Outer::red).
template<std::meta::info Enum, class Style = ::welder::naming::none>
static void	add_enumerator (auto &e)
	Add enumerator Enum to the enum handle.
template<class E>
static void	finish_enum (auto &e)
	Finalize enum E: export an unscoped enum's values into the enclosing scope, then commit the enum to the module.
static py::dict	open_module (module_type &)
	Open a per-module session: a dict accumulating live (mutable-variable) properties; _install_live_properties() applies them in one __class__ swap at close.
static void	set_module_doc (module_type &m, const char *doc)
	Set the (sub)module docstring.
template<auto Fns, class Style = ::welder::naming::none>
static py::object	add_function (module_type &m, const char *name=nullptr)
	Bind free-function overload group Fns as one module-level function (name from Fns[0]; one chained .def per overload).
template<std::meta::info Var, class Style = ::welder::naming::none>
static void	add_variable (module_type &m, py::dict &live, const char *name_override=nullptr)
	Bind namespace variable Var as a module attribute.
static module_type	add_submodule (module_type &m, const char *name)
	Create a submodule named name under m.
template<class Container, class Style = ::welder::naming::none>
static void	bind_container (module_type &m, const char *name)
	Bind STL Container opaquely — by reference, with live mutation — under name, the driver's route for a welded container alias (see <welder/containers.hpp>).
template<class Container>
static void	_bind_array (module_type &m, const char *name)
	Bind fixed-size sequence Container (std::array<T, N>) opaquely — by reference, with element write-through — under name.
static std::size_t	_wrap_index (py::ssize_t i, std::size_t n)
	Normalize a Python index i (allowing one level of negative wrap-around) against length n, raising IndexError when out of range — the fixed-array __getitem__/__setitem__ bounds check.
static void	close_module (module_type &m, py::dict &live)
	Close the session: apply any accumulated live properties.

Static Public Attributes
static constexpr lang	language {lang::py}
	welder::lang::py.
template<class T>
static constexpr bool	has_native_caster = !_needs_registration<T>
	caster_oracle: T is convertible without welder registering a class for it iff pybind11 does not fall back to runtime class registration.

Protected Types
template<class T, std::size_t I>
using	_init_param
	The synthesized constructor's parameter type for field I of T: std::optional<F> for a lazy default, else the field type itself.

Static Protected Member Functions
static consteval py::return_value_policy	_return_value_policy (::welder::rv_kind k)
	Map welder's neutral welder::rv_kind to pybind11's return_value_policy.
template<std::meta::info Fn, class Def, std::size_t... I, std::size_t... K>
static void	_def_function (const char *name, Def def_into, std::index_sequence< I... >, std::index_sequence< K... >)
	Register the function/method reflected by Fn onto a pybind11 target.
template<std::meta::info Fn, class Self, class Def, std::size_t... I>
static void	_def_truncated (const char *name, Def def_into, std::index_sequence< I... >)
	Bind ONE truncated overload of Fn taking its first sizeof...(I) parameters — the pybind11 mirror of the nanobind rod's _def_truncated: the wrapper calls the C++ function with fewer arguments and the LANGUAGE applies the real default(s), because reflection can see that a default exists but not its value.
template<std::meta::info Fn, class Self, class Def, std::size_t... K>
static void	_def_default_truncations (const char *name, Def def_into, std::index_sequence< K... >)
	Bind every omissible arity of Fn — arities P-D .
template<std::meta::info Fn, class Def>
static void	_def_function (const char *name, Def def_into)
	Convenience overload: derive the parameter and keep_alive index sequences from Fn.
template<std::meta::info Ctor, std::size_t D, std::size_t... K>
static void	_def_init_truncations (auto &cls, std::index_sequence< K... >)
	Register py::init<P0, P1, …>() for constructor Ctor.
template<std::meta::info Ctor, std::size_t... I>
static void	_def_init (auto &cls, std::index_sequence< I... >)
template<class T>
static py::object	_copy_instance (py::handle self, py::object *memo)
	The subclass-faithful engine behind __copy__/__deepcopy__.
template<class T, std::size_t I>
static consteval bool	_lazy_default ()
	Whether field I of aggregate T binds its NSDMI default LAZILY — the same rule (and reason) as the nanobind rod: a registration-needed default instance in a function record holds its type through an edge the GC cannot traverse, and chains of such defaults become uncollectable shutdown leaks.
template<class T, std::size_t I>
static auto	_init_value (_init_param< T, I > &&arg)
	The value brace-initializing field I of T from constructor argument arg: the argument itself for a plain parameter; for a lazy-default optional, the engaged value or — when disengaged — the field's NSDMI value read off a fresh T{}.
template<class T, std::size_t I>
static auto	_aggregate_arg (const T &probe)
	The py::arg for field I of aggregate T: named after the field and, for the defaultable NSDMI suffix (see welder::detail::aggregate_defaults_from), carrying the field's NSDMI value — read off the value-initialized probe — as a real keyword default, so Python may omit it or skip past it by keyword.
template<class T, std::size_t... I>
static void	_def_aggregate_init (auto &cls, std::index_sequence< I... >)
	Synthesize a field constructor for a baseless aggregate T.
static void	_install_live_properties (py::module_ &m, py::dict props)
	Give module m live get/set semantics for the names in props.
template<class T, class Trampoline, auto Bases, std::size_t... I>
static auto	_make_class (py::handle scope, const char name, const char doc, std::index_sequence< I... >)
	Construct py::class_<T, NativeBases...> from a reflected base-type array.
template<class T, auto Bases, std::size_t... I>
static auto	_make_class_at (py::handle scope, const char name, const char doc, std::index_sequence< I... > seq)
	The trampoline-aware class factory over an arbitrary registration scope — the shared body of make_class (scope = the module) and make_nested_class (scope = the enclosing class handle).
template<class Container, class Elem, class Cls>
static void	_def_sizing (Cls &cls)
	Give the opaque sequence class cls the reserve(n) / resize(n) sizing methods (which bind_vector does not provide).
template<class Container, class Elem, class Cls>
static void	_def_new (Cls &cls)
	Give the opaque std::vector<Elem> class cls a new() method that default-constructs an element in place at the back and returns a live reference to it (reference_internal, kept alive to the container) — so generic Python code can grow a container of welded structs without importing the element type just to construct one (e = v.new(); e.field = x).
template<class Container, class Elem, class Cls>
static void	_array_interface (Cls &cls)
	Give the opaque std::vector<Elem> class cls a __array_interface__ property — the numpy array-interface dict (numpy.asarray(v) reads it), yielding a structured, zero-copy, writable view of data().

Static Protected Attributes
template<class T>
static constexpr bool	_needs_registration
	Whether pybind11 can only convert T via runtime class registration.

Static Private Member Functions
template<std::meta::info Fn, bool NotImpl, class Cls, std::size_t... K>
static void	_def_operator (const char *name, Cls &cls, std::index_sequence< K... >)
	Def operator Fn (member, or free with the anchor on the left) under dunder name.
template<class T, std::meta::info Fn>
static void	_def_reflected_operator (auto &cls)
	Bind reflected free operator Fn (T is its right operand) under its reflected dunder, swapping the operands back into declaration order for the C++ call.

Detailed Description

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>
struct welder::rods::pybind11::rod< DocStyle >

The pybind11 rod: a stateless policy type satisfying welder::rod.

Its public static members are the pybind11 emission primitives welder's driver calls; the driver supplies all the reflection-derived decisions. Each implements the correspondingly-named hook of the welder::rod contract (and welder::caster_oracle) — every one carries a @see back to it, where the shared parameter and return-value semantics are documented once rather than repeated on each backend's mirror. The protected members below are pybind11-specific implementation helpers (prefixed _), not part of the contract.

Template Parameters

DocStyle the docstring convention this rod folds function/parameter/ return docs into (a welder::doc_style). Defaults to welder::rods::python::google_style; pass welder::rods::python::numpy_style or welder::rods::python::sphinx_style to emit those dialects. Defaulted, so rod<> is the Google-style rod and code that wants a different dialect names rod<numpy_style>.

Definition at line 87 of file rod.hpp.

Member Typedef Documentation

◆ _init_param

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::size_t I>

using welder::rods::pybind11::rod< DocStyle >::_init_param

protected

Initial value:

std::conditional_t<
       _lazy_default<T, I>(),
       std::optional<std::remove_const_t<
           typename [:std::meta::type_of(::welder::detail::aggregate_fields<T>()[I]):]>>,
       std::remove_const_t<
           typename [:std::meta::type_of(::welder::detail::aggregate_fields<T>()[I]):]>>

The synthesized constructor's parameter type for field I of T: std::optional<F> for a lazy default, else the field type itself.

Definition at line 381 of file rod.hpp.

◆ class_handle_type

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

using welder::rods::pybind11::rod< DocStyle >::class_handle_type

Initial value:

decltype(make_class<T, std::array<std::meta::info, 0>{}>(

std::declval<module_type&>(), nullptr, nullptr, std::index_sequence<>{}))

welder::rods::nanobind::rod::make_class

static auto make_class(module_type &m, const char *name, const char *doc, std::index_sequence< I... > seq)

Create the nb::class_<T, Bases…> handle, weaving in a trampoline when T is a welded virtual type with...

Definition rod.hpp:639

The class / enum handles the per-class / per-enum hooks operate on — exactly what make_class / make_enum yield.

class_handle_type<T> tracks make_class itself (so it captures the woven-in trampoline for a virtual T); it is its return type for a base-less T — welded bases, chosen by the carriage's resolution* rather than by T, are appended by make_class and so cannot be a function of T alone. Named as associated types so the welder::rod concept can shape-check the per-handle hooks against them. (Co-located with enum_handle, its definition.)

Definition at line 1006 of file rod.hpp.

◆ construction_type

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

using welder::rods::pybind11::rod< DocStyle >::construction_type

Initial value:

[: ::welder::rods::python::construction_type_of<T>() :]

welder::rods::python::construction_type_of

consteval std::meta::info construction_type_of()

The type welder constructs when binding T: its registered/annotated trampoline if one exists,...

Definition trampoline.hpp:152

The type welder constructs when binding T — its registered trampoline if one exists, else T — so an abstract base with a trampoline stays constructible from a Python subclass.

The driver reads this to decide default constructibility.

See also: welder::rods::python::construction_type_of

Definition at line 600 of file rod.hpp.

◆ enum_handle_type

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class E>

using welder::rods::pybind11::rod< DocStyle >::enum_handle_type = enum_handle<E>

Definition at line 1008 of file rod.hpp.

◆ module_type

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

using welder::rods::pybind11::rod< DocStyle >::module_type = py::module_

pybind11's module handle.

Definition at line 89 of file rod.hpp.

Member Function Documentation

◆ _aggregate_arg()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::size_t I>

auto welder::rods::pybind11::rod< DocStyle >::_aggregate_arg ( const T & probe )

inlinestaticprotected

The py::arg for field I of aggregate T: named after the field and, for the defaultable NSDMI suffix (see welder::detail::aggregate_defaults_from), carrying the field's NSDMI value — read off the value-initialized probe — as a real keyword default, so Python may omit it or skip past it by keyword.

A LAZY default (registration-needed type) binds = None with an ... signature; the C++ side materializes the NSDMI value.

Template Parameters

T	the aggregate type.
I	the field index.

Parameters

probe a value-initialized instance supplying the default values (unused for a required or lazy-default field).

Definition at line 419 of file rod.hpp.

References _lazy_default(), welder::detail::aggregate_defaults_from(), and welder::detail::aggregate_fields().

Referenced by _def_aggregate_init().

◆ _array_interface()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class Container, class Elem, class Cls>

void welder::rods::pybind11::rod< DocStyle >::_array_interface ( Cls & cls )

inlinestaticprotected

Give the opaque std::vector<Elem> class cls a __array_interface__ property — the numpy array-interface dict (numpy.asarray(v) reads it), yielding a structured, zero-copy, writable view of data().

numpy-free (a plain Python attribute); the field descr is reflected from Elem's POD layout (welder::rods::python::ai_descr).

Template Parameters

Elem	the POD element.

Definition at line 1348 of file rod.hpp.

Referenced by _bind_array(), and bind_container().

◆ _bind_array()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class Container>

void welder::rods::pybind11::rod< DocStyle >::_bind_array	(	module_type &	m,
		const char *	name )

inlinestatic

Bind fixed-size sequence Container (std::array<T, N>) opaquely — by reference, with element write-through — under name.

pybind11 ships no bind_array, so this hand-writes the bind_vector surface minus the size-changing ops**: __len__ (the constant N), __getitem__ / __setitem__ (a welded-class element handed out as a live return_value_policy::reference_internal alias so a[i].field = x writes through; a scalar returned by value), __iter__, and the same zero-copy view as a scalar/POD vector — the buffer protocol for an arithmetic element (so numpy.asarray(a) / memoryview(a) see data()), the __array_interface__ dict for a POD-struct element (_array_interface). There is deliberately no** append/insert/pop/extend/clear. Whole-attribute assignment from a length-N sequence still works: a py::init from any sequence (length checked — a wrong length raises ValueError) is registered as an implicit conversion, so obj.arr = [...] rebinds through def_readwrite. Only integer subscripts are bound, so a length-changing slice assignment raises TypeError.

See also: welder::rod

Definition at line 1233 of file rod.hpp.

References _array_interface(), _wrap_index(), and welder::rods::python::pod_array_eligible().

Referenced by bind_container().

◆ _copy_instance()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

py::object welder::rods::pybind11::rod< DocStyle >::_copy_instance	(	py::handle	self,
		py::object *	memo )

inlinestaticprotected

The subclass-faithful engine behind __copy__/__deepcopy__.

Mirrors what Python's own copy machinery does for a pure-Python object — state transfer, never __init__: an uninitialized shell of the instance's dynamic type (type(self).__new__(type(self)), so a Python subclass copies as itself), the C++ payload copy-constructed in place on the shell (for a subclass shell the alias (trampoline) payload — which is why the trampoline needs a copy-from-base constructor — so the copy keeps dispatching virtuals into Python), then the instance __dict__ carried over. With memo (the __deepcopy__ path) the fresh object is recorded under id(self) before the __dict__ is deep-copied through it, so shared references dedup and reference cycles terminate, exactly per the copy module's contract. __slots__-declared state carries over too: slot names are collected by copyreg._slotnames — the stdlib's own MRO-walking collector (what pickle uses), private-name mangling included — so a subclass keeping its state out of __dict__ still copies whole.

Template Parameters

T	the registered type.

Parameters

self	the instance being copied (possibly of a Python subclass).
memo	the __deepcopy__ memo dict, or nullptr for __copy__.

Returns: the new instance, same dynamic type as self.

Definition at line 322 of file rod.hpp.

Referenced by add_constructors().

◆ _def_aggregate_init()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::size_t... I>

void welder::rods::pybind11::rod< DocStyle >::_def_aggregate_init	(	auto &	cls,
		std::index_sequence< I... >	)

inlinestaticprotected

Synthesize a field constructor for a baseless aggregate T.

Emits py::init([](…) { … }) so Python can build it from field values (T(f0, f1)) rather than only default-construct then assign. Fields in the NSDMI suffix become keyword parameters with real defaults (_aggregate_arg) — except registration-needed ones, which bind Optional[F] = None and default in C++ (_lazy_default), so no bound-class instance ever lives in the function record.

Template Parameters

T	the aggregate type.
I	the field index pack.

Parameters

cls	the class handle.

Definition at line 448 of file rod.hpp.

References _aggregate_arg(), _init_value(), welder::detail::aggregate_defaults_from(), and welder::detail::aggregate_fields().

Referenced by add_constructors().

◆ _def_default_truncations()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Fn, class Self, class Def, std::size_t... K>

void welder::rods::pybind11::rod< DocStyle >::_def_default_truncations	(	const char *	name,
		Def	def_into,
		std::index_sequence< K... >	)

inlinestaticprotected

Bind every omissible arity of Fn — arities P-D .

. P-1; the full-arity def is _def_function's.

Definition at line 249 of file rod.hpp.

References _def_truncated().

Referenced by add_function(), add_method(), and add_static_method().

◆ _def_function() [1/2]

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Fn, class Def>

void welder::rods::pybind11::rod< DocStyle >::_def_function	(	const char *	name,
		Def	def_into )

inlinestaticprotected

Convenience overload: derive the parameter and keep_alive index sequences from Fn.

Definition at line 261 of file rod.hpp.

References _def_function(), and welder::detail::keep_alive_pairs().

◆ _def_function() [2/2]

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Fn, class Def, std::size_t... I, std::size_t... K>

void welder::rods::pybind11::rod< DocStyle >::_def_function	(	const char *	name,
		Def	def_into,
		std::index_sequence< I... >	,
		std::index_sequence< K... >	)

inlinestaticprotected

Register the function/method reflected by Fn onto a pybind11 target.

The folded docstring is passed when non-empty, and py::arg(name)... when every parameter is named (so Python callers see real keyword arguments, not arg0/arg1). Two call policies ride along as trailing .def extras: the [[=welder::return_policy]] (mapped to return_value_policy, always passed — automatic is pybind11's default, so an unannotated call is unchanged) and each [[=welder::keep_alive]] (spliced as py::keep_alive<nurse, patient>()). A reference-category policy on a by-value return is rejected first (welder::validate_return_policy).

Template Parameters

Fn	a reflection of the function.
Def	the target-adapter callable type.
I	the parameter index pack.
K	the keep_alive-dependency index pack.

Parameters

name	the Python name.
def_into	adapts the target — cls.def, cls.def_static, or m.def.

Definition at line 179 of file rod.hpp.

References _return_value_policy(), welder::detail::all_params_named(), welder::doc(), welder::function_docstring(), welder::detail::keep_alive_pairs(), language, welder::none, welder::detail::param_names(), welder::return_policy_of(), and welder::validate_return_policy().

Referenced by _def_function(), add_function(), add_method(), and add_static_method().

◆ _def_init()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Ctor, std::size_t... I>

void welder::rods::pybind11::rod< DocStyle >::_def_init	(	auto &	cls,
		std::index_sequence< I... >	)

inlinestaticprotected

Definition at line 291 of file rod.hpp.

References welder::detail::all_params_named(), welder::detail::param_names(), and welder::detail::param_types().

Referenced by _def_init_truncations(), and add_constructors().

◆ _def_init_truncations()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Ctor, std::size_t D, std::size_t... K>

void welder::rods::pybind11::rod< DocStyle >::_def_init_truncations	(	auto &	cls,
		std::index_sequence< K... >	)

inlinestaticprotected

Register py::init<P0, P1, …>() for constructor Ctor.

Names the parameters (py::arg) when all are named, otherwise positional.

Template Parameters

Ctor	a reflection of the constructor.
I	the parameter index pack.

Parameters

cls the class handle. Bind every omissible arity of constructor Ctor (arities P-D .. P-1): _def_init already takes the parameter index sequence, so each omissible arity is just a shorter one — the init calls the constructor with fewer arguments and the LANGUAGE applies the real defaults. A named template (not an immediately-invoked lambda): a lambda whose body touches std::meta::parameters_of is escalated to an immediate function, and the runtime _def_init call inside would then be ill-formed.

Definition at line 285 of file rod.hpp.

References _def_init().

Referenced by add_constructors().

◆ _def_new()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class Container, class Elem, class Cls>

void welder::rods::pybind11::rod< DocStyle >::_def_new ( Cls & cls )

inlinestaticprotected

Give the opaque std::vector<Elem> class cls a new() method that default-constructs an element in place at the back and returns a live reference to it (reference_internal, kept alive to the container) — so generic Python code can grow a container of welded structs without importing the element type just to construct one (e = v.new(); e.field = x).

Class elements only (guarded here): a scalar would come back by value (a dead copy), a footgun, so it's omitted — use append(value). Standard bind_vector caveat: a later append/clear may reallocate and invalidate the reference.

Definition at line 1332 of file rod.hpp.

Referenced by bind_container().

◆ _def_operator()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Fn, bool NotImpl, class Cls, std::size_t... K>

void welder::rods::pybind11::rod< DocStyle >::_def_operator	(	const char *	name,
		Cls &	cls,
		std::index_sequence< K... >	)

inlinestaticprivate

Def operator Fn (member, or free with the anchor on the left) under dunder name.

Unlike _def_function, never passes py::arg names — Python's operator protocol is positional-only (and pybind11 rejects per-parameter annotations on a free binary function bound as a method slot). Docstring, return_policy and keep_alives ride along as usual; NotImpl appends py::is_operator() (see add_operator).

Template Parameters

Fn	the operator.
K	the keep_alive index pack.

Definition at line 908 of file rod.hpp.

References _return_value_policy(), welder::doc(), welder::function_docstring(), welder::detail::keep_alive_pairs(), language, welder::none, welder::return_policy_of(), and welder::validate_return_policy().

Referenced by add_operator().

◆ _def_reflected_operator()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::meta::info Fn>

void welder::rods::pybind11::rod< DocStyle >::_def_reflected_operator ( auto & cls )

inlinestaticprivate

Bind reflected free operator Fn (T is its right operand) under its reflected dunder, swapping the operands back into declaration order for the C++ call.

Template Parameters

T	the anchor type.
Fn	the operator.

Definition at line 938 of file rod.hpp.

References welder::rods::python::reflected_dunder(), and welder::validate_return_policy().

Referenced by add_operator().

◆ _def_sizing()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class Container, class Elem, class Cls>

void welder::rods::pybind11::rod< DocStyle >::_def_sizing ( Cls & cls )

inlinestaticprotected

Give the opaque sequence class cls the reserve(n) / resize(n) sizing methods (which bind_vector does not provide).

reserve pre-grows capacity so a following run of append/new neither reallocates nor invalidates references — the efficient bulk-populate path; it is defined only where the container has reserve (std::vector; std::deque has none). resize grows or shrinks to exactly n, value-initializing new tail elements, and is defined only where the element is default-constructible (the requires-clause gates it).

Definition at line 1308 of file rod.hpp.

Referenced by bind_container().

◆ _def_truncated()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Fn, class Self, class Def, std::size_t... I>

void welder::rods::pybind11::rod< DocStyle >::_def_truncated	(	const char *	name,
		Def	def_into,
		std::index_sequence< I... >	)

inlinestaticprotected

Bind ONE truncated overload of Fn taking its first sizeof...(I) parameters — the pybind11 mirror of the nanobind rod's _def_truncated: the wrapper calls the C++ function with fewer arguments and the LANGUAGE applies the real default(s), because reflection can see that a default exists but not its value.

Self is the bound class for a nonstatic member, void for free/static. Arg names ride along (kwargs keep working); the docstring stays on the full-arity def; keep_alives are not repeated (an omitted argument cannot nurse anything).

Definition at line 217 of file rod.hpp.

References _return_value_policy(), welder::detail::all_params_named(), language, welder::detail::param_names(), welder::detail::param_types(), and welder::return_policy_of().

Referenced by _def_default_truncations().

◆ _enum_docstring()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

std::string welder::rods::pybind11::rod< DocStyle >::_enum_docstring ( const ::welder::detail::enum_doc & ed )

inlinestatic

Assemble ed — the enum summary plus its documented enumerators — into the enum's class docstring under this rod's DocStyle: the summary, then an Attributes section listing each enumerator's doc.

An enum has no per-enumerator docstring slot pybind11-stubgen surfaces, so this class docstring is the one place a [[=welder::doc]] on an enumerator rides into the generated .pyi. Empty when the enum is wholly undocumented.

Definition at line 1039 of file rod.hpp.

Referenced by make_enum(), and make_nested_enum().

◆ _init_value()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::size_t I>

auto welder::rods::pybind11::rod< DocStyle >::_init_value ( _init_param< T, I > && arg )

inlinestaticprotected

The value brace-initializing field I of T from constructor argument arg: the argument itself for a plain parameter; for a lazy-default optional, the engaged value or — when disengaged — the field's NSDMI value read off a fresh T{}.

Yielding VALUES (rather than assigning into an NSDMI-initialized instance) keeps aggregate semantics intact for const-qualified members.

Definition at line 395 of file rod.hpp.

References _lazy_default(), welder::detail::aggregate_fields(), and welder::field.

Referenced by _def_aggregate_init().

◆ _install_live_properties()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

void welder::rods::pybind11::rod< DocStyle >::_install_live_properties	(	py::module_ &	m,
		py::dict	props )

inlinestaticprotected

Give module m live get/set semantics for the names in props.

Reassigns m's Python class to a fresh subclass of its current class carrying props (name → property). Python modules don't support properties directly, but a module's __class__ may be swapped for a ModuleType subclass. Used only when a (sub)module exposes a mutable variable.

Subclassing the module's current class — rather than ModuleType outright — means repeated installs onto the same handle accumulate: welding a standalone variable and then a whole namespace onto the same module each add a layer, and the earlier properties survive in the MRO instead of being clobbered.

Parameters

m	the module handle.
props	a dict of name → property.

Definition at line 484 of file rod.hpp.

Referenced by close_module().

◆ _lazy_default()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::size_t I>

consteval bool welder::rods::pybind11::rod< DocStyle >::_lazy_default ( )

inlinestaticconstevalprotected

Whether field I of aggregate T binds its NSDMI default LAZILY — the same rule (and reason) as the nanobind rod: a registration-needed default instance in a function record holds its type through an edge the GC cannot traverse, and chains of such defaults become uncollectable shutdown leaks.

See the nanobind rod's _lazy_default.

Definition at line 368 of file rod.hpp.

References welder::detail::aggregate_defaults_from(), welder::detail::aggregate_fields(), and has_native_caster.

Referenced by _aggregate_arg(), and _init_value().

◆ _make_class()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, class Trampoline, auto Bases, std::size_t... I>

auto welder::rods::pybind11::rod< DocStyle >::_make_class	(	py::handle	scope,
		const char *	name,
		const char *	doc,
		std::index_sequence< I... >	)

inlinestaticprotected

Construct py::class_<T, NativeBases...> from a reflected base-type array.

A non-null doc becomes the class docstring (pybind11 treats a bare const char* extra as the doc); nullptr is branched out rather than passed, since pybind11 would strdup it.

Template Parameters

T	the class type.
Bases	the static array of native base type reflections.
I	the base index pack.

Parameters

scope	the registration scope — the module, or (for a nested type) the enclosing class handle; pybind11 accepts any handle.
name	the Python class name.
doc	the class docstring, or nullptr.

Definition at line 514 of file rod.hpp.

References welder::doc().

Referenced by _make_class_at().

◆ _make_class_at()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, auto Bases, std::size_t... I>

auto welder::rods::pybind11::rod< DocStyle >::_make_class_at	(	py::handle	scope,
		const char *	name,
		const char *	doc,
		std::index_sequence< I... >	seq )

inlinestaticprotected

The trampoline-aware class factory over an arbitrary registration scope — the shared body of make_class (scope = the module) and make_nested_class (scope = the enclosing class handle).

A type carrying virtual methods is bound overridable — it must register a trampoline (so Python subclasses can override those virtuals) or opt out with [[=welder::bind_flat]]. When a trampoline is present, its coverage of T's virtuals is checked at compile time.

See also: welder::rods::python::trampoline_for

Definition at line 539 of file rod.hpp.

References _make_class(), welder::bound_flat(), welder::doc(), and welder::has_virtual_methods().

Referenced by make_class(), and make_nested_class().

◆ _return_value_policy()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

consteval py::return_value_policy welder::rods::pybind11::rod< DocStyle >::_return_value_policy ( ::welder::rv_kind k )

inlinestaticconstevalprotected

Map welder's neutral welder::rv_kind to pybind11's return_value_policy.

pybind11 has no analogue of nanobind's none, so rv_kind::none is rejected at the bind site (a static_assert in _def_function) rather than mapped here; it falls through to automatic only to keep this total.

Parameters

k	the neutral policy.

Returns: the pybind11 policy.

Definition at line 147 of file rod.hpp.

Referenced by _def_function(), _def_operator(), _def_truncated(), and add_property().

◆ _wrap_index()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

std::size_t welder::rods::pybind11::rod< DocStyle >::_wrap_index	(	py::ssize_t	i,
		std::size_t	n )

inlinestatic

Normalize a Python index i (allowing one level of negative wrap-around) against length n, raising IndexError when out of range — the fixed-array __getitem__/__setitem__ bounds check.

Definition at line 1290 of file rod.hpp.

Referenced by _bind_array().

◆ add_comparisons()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, auto Fns, auto Covered>

void welder::rods::pybind11::rod< DocStyle >::add_comparisons ( auto & cls )

inlinestatic

Synthesize the relational dunders from operator<=> group Fns: for each spaceship overload's operand type, bind plain rewritten expressions (a < b, …) — C++'s own rewriting rules pick the right overload, so Python comparisons match C++ exactly, heterogeneous operands included (the reversed direction rides Python's reflected protocol: 5 < obj → obj.__gt__(5)).

A slot an explicit participating operator already covers is skipped (Covered — explicit beats synthesis). __eq__ is never synthesized: C++ itself only rewrites == from operator==, and the member a defaulted spaceship implicitly declares binds through the ordinary operator path.

See also: welder::rod

Definition at line 885 of file rod.hpp.

References welder::rods::python::synthesize_comparisons().

◆ add_constructors()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, auto Ctors, bool HasDefault, bool Aggregate, bool Copyable, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::add_constructors ( auto & cls )

inlinestatic

Bind T's whole constructor set (a chained-def framework just loops it): the default constructor when HasDefault, a py::init<…> per member of Ctors, and the synthesized aggregate field constructor when Aggregate.

Copyable (the carriage-admitted copy constructor) becomes the copy protocol alone — __copy__ and __deepcopy__(memo), both subclass-faithful** via _copy_instance — a Python subclass instance copies as its own type, __dict__ and virtual dispatch intact, with the C++ payload duplicated by the copy constructor (whose deep/shallow distinction is its own: value members duplicate, a pointer member copies as a pointer). It is deliberately NOT exposed as a T(other) init overload: that C++-ism is unidiomatic in Python (copying goes through the copy module) and would clash with a one-arg user constructor. The memo parameter is typed object, not dict — a bare dict in the generated stub fails strict mypy (disallow_any_generics).

See also: _def_init; _def_aggregate_init; welder::rod

Definition at line 649 of file rod.hpp.

References _copy_instance(), _def_aggregate_init(), _def_init(), _def_init_truncations(), welder::detail::aggregate_fields(), and welder::detail::trailing_default_count().

◆ add_enumerator()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Enum, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::add_enumerator ( auto & e )

inlinestatic

Add enumerator Enum to the enum handle.

See also: welder::rod

Definition at line 1075 of file rod.hpp.

References welder::name_of().

◆ add_field()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Mem, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::add_field ( auto & cls )

inlinestatic

Bind data member Mem as an attribute.

pybind11 data members are already Python properties (data descriptors on the class), so a [[=welder::doc]] on the member rides along as the property's __doc__ — and thus reaches .pyi stubs. A const member — or one marked [[=welder::mark::no_reassign]] — is read-only (def_readonly); an otherwise-mutable member is read/write (def_readwrite). The doc, when present, is passed as the property docstring. There is deliberately no setter docstring: a Python property surfaces only the getter's __doc__, so one would be pure overhead.

See also: welder::rod

Definition at line 704 of file rod.hpp.

References welder::doc(), welder::doc_of(), language, welder::member_no_reassign(), and welder::name_of().

◆ add_function()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<auto Fns, class Style = ::welder::naming::none>

py::object welder::rods::pybind11::rod< DocStyle >::add_function	(	module_type &	m,
		const char *	name = nullptr )

inlinestatic

Bind free-function overload group Fns as one module-level function (name from Fns[0]; one chained .def per overload).

A non-null name overrides the resolved name (including any weld_as), used verbatim; nullptr falls back to the styled/weld_as name.

Returns: the bound function object (m.attr(name)) — the handle for further hand-registration.

See also: welder::rod

Definition at line 1111 of file rod.hpp.

References _def_default_truncations(), _def_function(), welder::function, language, welder::name_of_or(), and welder::detail::trailing_default_count().

◆ add_method()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<auto Fns, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::add_method ( auto & cls )

inlinestatic

Bind method overload group Fns (name from Fns[0]; pybind11 chains one .def per overload and dispatches at call time).

See also: welder::rod

Definition at line 809 of file rod.hpp.

References _def_default_truncations(), _def_function(), welder::name_of(), and welder::detail::trailing_default_count().

◆ add_operator()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, auto Fns>

void welder::rods::pybind11::rod< DocStyle >::add_operator ( auto & cls )

inlinestatic

Bind operator slot group Fns — one (operator, arity) slot whole, member and anchored free entries mixed.

A member (or T-on-the-left free) entry binds under the slot's dunder; a free entry with T as the RIGHT operand binds under the REFLECTED dunder (__rmul__, or the mirrored comparison) through an operand-swapping wrapper, so 2.0 * v works from Python exactly as from C++. Binary arithmetic/comparison defs carry py::is_operator(): a failed operand conversion returns NotImplemented (Python then tries the other operand's reflected method) instead of raising TypeError.

See also: welder::rod

Definition at line 860 of file rod.hpp.

References _def_operator(), _def_reflected_operator(), welder::rods::python::dunder_uses_not_implemented(), welder::detail::free_operator_reflected(), welder::detail::keep_alive_pairs(), and welder::rods::python::operator_dunder().

◆ add_property()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::meta::info Getter, std::meta::info Setter>

void welder::rods::pybind11::rod< DocStyle >::add_property	(	auto &	cls,
		const char *	name )

inlinestatic

Bind the resolved property (Getter + optional Setter) as a Python property named name (driver-resolved).

def_property / def_property_readonly over the spliced member pointers; the getter's [[=welder::doc]] becomes the property __doc__ (a Python property surfaces only the getter's doc, so a setter doc would be pure overhead — exactly the add_field rationale). A [[=welder::return_policy]] on the getter is honored; unannotated, the framework's own property default applies (pybind11 invokes property getters with reference_internal, forced to move on a by-value return — matching def_readwrite semantics).

See also: welder::rod

Definition at line 763 of file rod.hpp.

References _return_value_policy(), welder::automatic, welder::doc(), welder::doc_of(), language, welder::none, welder::return_policy_of(), and welder::validate_return_policy().

◆ add_static_method()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<auto Fns, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::add_static_method ( auto & cls )

inlinestatic

Bind static-method overload group Fns.

See also: welder::rod

Definition at line 830 of file rod.hpp.

References _def_default_truncations(), _def_function(), language, welder::name_of(), welder::static_method, and welder::detail::trailing_default_count().

◆ add_stringifier()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, std::meta::info Fn>

void welder::rods::pybind11::rod< DocStyle >::add_stringifier ( auto & cls )

inlinestatic

Bind the swept free ostream inserter Fn as __str__ (via welder::detail::stringify).

See also: welder::rod

Definition at line 895 of file rod.hpp.

References welder::detail::stringify().

◆ add_submodule()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

module_type welder::rods::pybind11::rod< DocStyle >::add_submodule	(	module_type &	m,
		const char *	name )

inlinestatic

Create a submodule named name under m.

See also: welder::rod

Definition at line 1156 of file rod.hpp.

◆ add_variable()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<std::meta::info Var, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::add_variable	(	module_type &	m,
		py::dict &	live,
		const char *	name_override = nullptr )

inlinestatic

Bind namespace variable Var as a module attribute.

A const/constexpr variable becomes a value snapshot; a mutable one becomes a live get/set property over the C++ global (accumulated in live). A non-null name_override is used verbatim (beating any weld_as); nullptr falls back to the styled/weld_as name.

See also: welder::rod

Definition at line 1135 of file rod.hpp.

References welder::name_of_or().

◆ bind_container()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class Container, class Style = ::welder::naming::none>

void welder::rods::pybind11::rod< DocStyle >::bind_container	(	module_type &	m,
		const char *	name )

inlinestatic

Bind STL Container opaquely — by reference, with live mutation — under name, the driver's route for a welded container alias (see <welder/containers.hpp>).

A sequence (std::vector/std::deque) becomes a py::bind_vector class: append (=push_back), __getitem__/__setitem__, slicing, extend, pop, __len__, __iter__ — mutation writes through to the C++ object (a def_readwrite member of it hands out a live reference, so obj.v.append(x) persists). For a welded-class element, __getitem__ / __iter__ themselves hand out a live reference aliasing the C++ element (pybind11's own return_value_policy::reference_internal), so v[i].field = x writes through; a scalar element is returned by value (a copy). For a scalar element type (arithmetic, not bool) the class also carries py::buffer_protocol(), so numpy.asarray(v) / memoryview(v) / ctypes.*.from_buffer(v) view the raw data() zero-copy. A map (std::map/std::unordered_map) becomes a py::bind_map class whose __getitem__ likewise hands out a live reference to the mapped value.

The container must be declared opaque (WELDER_OPAQUE(Container)) at namespace scope, or pybind11's copy caster still wins for it.

See also: welder::rod

Definition at line 1181 of file rod.hpp.

References _array_interface(), _bind_array(), _def_new(), _def_sizing(), welder::container_is_contiguous(), welder::container_kind_of(), welder::fixed_sequence, welder::rods::python::pod_array_eligible(), and welder::sequence.

◆ close_module()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

void welder::rods::pybind11::rod< DocStyle >::close_module	(	module_type &	m,
		py::dict &	live )

inlinestatic

Close the session: apply any accumulated live properties.

See also: welder::rod

Definition at line 1369 of file rod.hpp.

References _install_live_properties().

◆ finish_enum()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class E>

void welder::rods::pybind11::rod< DocStyle >::finish_enum ( auto & e )

inlinestatic

Finalize enum E: export an unscoped enum's values into the enclosing scope, then commit the enum to the module.

See also: welder::rod

Definition at line 1084 of file rod.hpp.

◆ make_class()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, auto Bases, std::size_t... I>

auto welder::rods::pybind11::rod< DocStyle >::make_class	(	module_type &	m,
		const char *	name,
		const char *	doc,
		std::index_sequence< I... >	seq )

inlinestatic

Create the py::class_<T, Bases…> handle, weaving in a trampoline when T is a welded virtual type with a registered welder::rods::python::trampoline_for.

A type carrying virtual methods is bound overridable — it must register a trampoline (so Python subclasses can override those virtuals) or opt out with [[=welder::bind_flat]]. When a trampoline is present, its coverage of T's virtuals is checked at compile time.

See also: _make_class; welder::rods::python::trampoline_for; welder::rod

Definition at line 613 of file rod.hpp.

References _make_class_at(), and welder::doc().

◆ make_enum()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class E>

enum_handle< E > welder::rods::pybind11::rod< DocStyle >::make_enum	(	module_type &	m,
		const char *	name,
		const ::welder::detail::enum_doc &	ed )

inlinestatic

Create the enum_handle for E; ed's summary + enumerator docs become its class docstring (see _enum_docstring).

See also: welder::rod

Definition at line 1046 of file rod.hpp.

References _enum_docstring(), and welder::doc().

◆ make_nested_class()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T, auto Bases, std::size_t... I>

auto welder::rods::pybind11::rod< DocStyle >::make_nested_class	(	module_type &	,
		auto &	outer_cls,
		const char *	name,
		const char *	doc,
		std::index_sequence< I... >	seq )

inlinestatic

Create the py::class_ for a nested member type T, registered under its enclosing type's class handle rather than the module — Python then sees it as module.Outer.Inner (and __qualname__ nests), exactly like a hand-written py::class_<Outer::Inner>(outer_cls, "Inner").

Same trampoline weaving as make_class.

See also: welder::rod

Definition at line 624 of file rod.hpp.

References _make_class_at(), and welder::doc().

◆ make_nested_enum()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class E>

enum_handle< E > welder::rods::pybind11::rod< DocStyle >::make_nested_enum	(	module_type &	,
		auto &	outer_cls,
		const char *	name,
		const ::welder::detail::enum_doc &	ed )

inlinestatic

Create the enum_handle for a nested member enum E, scoped to its enclosing type's class handle — Python sees module.Outer.Mode, and an unscoped* nested enum's export_values() lands its enumerators on the class (mirroring C++'s Outer::red).

ed folds in as for make_enum.

See also: welder::rod

Definition at line 1063 of file rod.hpp.

References _enum_docstring(), and welder::doc().

◆ open_module()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

py::dict welder::rods::pybind11::rod< DocStyle >::open_module ( module_type & )

inlinestatic

Open a per-module session: a dict accumulating live (mutable-variable) properties; _install_live_properties() applies them in one __class__ swap at close.

See also: welder::rod

Definition at line 1098 of file rod.hpp.

◆ reopen_class()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

class_handle_type< T > welder::rods::pybind11::rod< DocStyle >::reopen_class	(	module_type &	scope,
		const char *	name )

inlinestatic

Retrieve the ALREADY-registered class T as a fillable handle — the two-phase binding hook (welder::caster_oracle-adjacent, optional).

The driver's name-pre-registration phase creates the py::class_<T,…> (so scope.attr(name) is it); reinterpret_borrow re-wraps that object as the same handle type make_class yields, so subsequent add_* calls target the same registered type. This lets the driver register every type's NAME (and the opaque containers that use them) BEFORE filling any member, so a container-typed member/signature never spells a raw C++ name in a docstring (a def-time-ordering artifact stubgen rejects). Declaring this hook is a rod's opt-in to the driver's two-phase namespace sweep.

See also: welder::rod

Definition at line 1021 of file rod.hpp.

◆ reopen_nested_class()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

class_handle_type< T > welder::rods::pybind11::rod< DocStyle >::reopen_nested_class	(	module_type &	,
		auto &	outer,
		const char *	name )

inlinestatic

The nested-scope form of reopen_class — retrieve T from its enclosing type's class handle (outer.attr(name)) rather than the module.

See also: welder::rod

Definition at line 1028 of file rod.hpp.

◆ set_module_doc()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

void welder::rods::pybind11::rod< DocStyle >::set_module_doc	(	module_type &	m,
		const char *	doc )

inlinestatic

Set the (sub)module docstring.

See also: welder::rod

Definition at line 1101 of file rod.hpp.

References welder::doc().

◆ special_method_name()

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

consteval const char * welder::rods::pybind11::rod< DocStyle >::special_method_name ( std::meta::info op_fn )

inlinestaticconsteval

Map a member operator to its Python dunder (nullptr = not exposed).

See also: welder::rod

Definition at line 589 of file rod.hpp.

Member Data Documentation

◆ _needs_registration

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

bool welder::rods::pybind11::rod< DocStyle >::_needs_registration

staticconstexprprotected

Initial value:

                                      =
std::is_enum_v<std::remove_cvref_t<T>> ||
std::is_base_of_v<py::detail::type_caster_base<py::detail::intrinsic_t<T>>,
                  py::detail::make_caster<T>>

Whether pybind11 can only convert T via runtime class registration.

True iff T's caster is (or derives from) the generic type_caster_base fallback, which looks T up in pybind11's registered-types map. True for program-defined classes and enums; false for scalars, strings and the pybind11 wrapper types (py::object, py::dict, …). This is the one bindability fact welder's core cannot know on its own; it drives has_native_caster below.

Two things it deliberately does NOT see through — both making it conservative* (it may over-report needs-registration, never under-report):

It reads T's caster type at compile time, so it reports whether T needs* a class_/native_enum — never whether one will actually exist at runtime. A class the user hand-registers with py::class_ (or a third-party library registers) but does not weld still reads true, so welder requires welded_for and rejects it: a false positive, resolved by the deferred trust_bindable escape hatch, since the out-of-band registration is invisible here.
"native" is relative to the TU's includes: std::complex / std::function / std::chrono / std::filesystem::path are native only when their converter header (<pybind11/complex.h>, functional.h, chrono.h, stl/filesystem.h) is included; otherwise they fall to the class-registration fallback. That is correct — without the header pybind11 genuinely cannot convert them.

A user type_caster is trusted (reads false) only when it is self-contained* — it does not itself derive from type_caster_base (e.g. a PYBIND11_TYPE_CASTER caster). One that derives from type_caster_base still needs T registered, so it correctly still reads true.

Enums are forced into the needs-registration bucket**: pybind11 3's dedicated enum caster does not derive type_caster_base, but it converts only once the enum is registered (py::native_enum / legacy py::enum_) — an unregistered enum raises at call time and renders raw C++ names in docstrings/stubs. Forcing it keeps welder's gate honest (a welded enum's registration is required) and matches every other rod.

Template Parameters

T	the type whose caster to classify.

Definition at line 134 of file rod.hpp.

◆ has_native_caster

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

template<class T>

bool welder::rods::pybind11::rod< DocStyle >::has_native_caster = !_needs_registration<T>

staticconstexpr

caster_oracle: T is convertible without welder registering a class for it iff pybind11 does not fall back to runtime class registration.

Template Parameters

T	the type to classify.

See also: welder::caster_oracle

Definition at line 585 of file rod.hpp.

Referenced by _lazy_default().

◆ language

template<::welder::doc_style DocStyle = ::welder::rods::python::google_style>

lang welder::rods::pybind11::rod< DocStyle >::language {lang::py}

staticconstexpr

welder::lang::py.

Definition at line 88 of file rod.hpp.

Referenced by _def_function(), _def_operator(), _def_truncated(), add_field(), add_function(), add_property(), and add_static_method().

The documentation for this struct was generated from the following file:

src/welder/rods/python/pybind11/rod.hpp

Classes

Public Types

Static Public Member Functions

Static Public Attributes

Protected Types

Static Protected Member Functions

Static Protected Attributes

Static Private Member Functions

Detailed Description

Member Typedef Documentation

◆ _init_param

◆ class_handle_type

◆ construction_type

◆ enum_handle_type

◆ module_type

Member Function Documentation

◆ _aggregate_arg()

◆ _array_interface()

◆ _bind_array()

◆ _copy_instance()

◆ _def_aggregate_init()

◆ _def_default_truncations()

◆ _def_function() [1/2]

◆ _def_function() [2/2]

◆ _def_init()

◆ _def_init_truncations()

◆ _def_new()

◆ _def_operator()

◆ _def_reflected_operator()

◆ _def_sizing()

◆ _def_truncated()

◆ _enum_docstring()

◆ _init_value()

◆ _install_live_properties()

◆ _lazy_default()

◆ _make_class()

◆ _make_class_at()

◆ _return_value_policy()

◆ _wrap_index()

◆ add_comparisons()

◆ add_constructors()

◆ add_enumerator()

◆ add_field()

◆ add_function()

◆ add_method()

◆ add_operator()

◆ add_property()

◆ add_static_method()

◆ add_stringifier()

◆ add_submodule()

◆ add_variable()

◆ bind_container()

◆ close_module()

◆ finish_enum()

◆ make_class()

◆ make_enum()

◆ make_nested_class()

◆ make_nested_enum()

◆ open_module()

◆ reopen_class()

◆ reopen_nested_class()

◆ set_module_doc()

◆ special_method_name()

Member Data Documentation

◆ _needs_registration

◆ has_native_caster

◆ language