Struct NodeRegistration 

pub struct NodeRegistration {
    pub signatures: fn() -> &'static [FuncSig],
    pub build: NodeBuildFn,
    pub validate: Option<NodeValidator>,
}

A node module’s registration: signatures + builder.

Each node module submits one of these at link time via inventory::submit!. The runtime collects all submissions to build the function registry and dispatch table without any explicit module list.

A registration is a NodeFactory: its build is the factory’s body, and the registry builds its nodes through that factory as it builds every other node (crate::dsl::factory::build_node).

Fields

signatures: fn() -> &'static [FuncSig]

Returns the static slice of FuncSig entries for this module.

build: NodeBuildFn

Builds a node for the given function name: the body of this registration’s NodeFactory::build.

Returns Some(Ok(node)) / Some(Err(msg)) for a name it builds, and None for one it leaves to its signature: a variadic function then gets its signature’s identity element or variadic constructor, and any other name is an unknown function.

wire_types[i] is the resolved crate::ast::PortType of wires[i] — the output type of the upstream node feeding that wire input. Modules that build type-polymorphic nodes (e.g. log_info, whose output type equals its input type) read this to construct the node with the correct port types. Modules whose nodes have type-fixed signatures can ignore the slice. When the assembler can’t resolve a wire’s type (forward reference, dangling), the slot defaults to crate::ast::PortType::U64.

validate: Option<NodeValidator>

Optional assembly-time validator for this module’s constants.

The factory calls this before build whenever the name matches one of this module’s functions. Returning Err makes the compile fail with a structured bad constant error, so the node itself never sees a malformed literal and can keep its constructor and eval() branch-free.

Trait Implementations

impl Collect for NodeRegistration

impl NodeFactory for NodeRegistration

fn build( &self, ctx: &BuildContext, name: &str, wires: &[WireRef], wire_types: &[PortType], consts: &[ConstArg], ) -> Result<Box<dyn PolydatNode>, String>

The registered builder’s node. A builder that declines a name its signatures list leaves a variadic function to its signature: the identity element for no wires, the variadic constructor otherwise.

fn signatures(&self) -> &[FuncSig]

The functions this factory builds. The registry lists them, and a call to one of them is built by this factory.

fn validate(&self, name: &str, consts: &[ConstArg]) -> Result<(), String>

Check a call’s constant arguments before Self::build; an Err fails the compile as a bad constant, so build never sees a malformed literal. The registry has already applied each parameter’s declared ConstConstraint. Accepts everything unless overridden.