Struct InferenceRegistry 

pub struct InferenceRegistry { /* private fields */ }

A registry mapping (domain, op_type, opset) to an InferenceFn.

Implementations

impl InferenceRegistry

pub fn infer_graph( &self, graph: &mut Graph, opset_imports: &HashMap<String, u64>, policy: MergePolicy, ) -> Result<InferenceReport, ShapeInferError>

Infer shapes for every value in graph, in topological order.

Seeds every explicitly known value type, runs each node’s rule to fill or refine its outputs’ types and shape-data, then writes the resolved shapes back into the graph (lowering symbolic dimension expressions to IR Dims). Graph outputs are reconciled with their declared shapes under policy. Returns an InferenceReport of what resolved.

opset_imports selects the effective operator versions; pass graph.opset_imports.clone() for the model’s own imports.

impl InferenceRegistry

pub fn empty() -> Self

An empty registry (no rules).

pub fn default_registry() -> Self

A registry populated with every built-in rule.

pub fn register( &mut self, domain: &str, op: &str, min_opset: u64, rule: InferenceFn, )

Register rule for (domain, op) applying from opset min_opset upward. A later registration at a higher min_opset supersedes this one for those versions.

pub fn get(&self, domain: &str, op: &str, version: u64) -> Option<InferenceFn>

Look up the rule for (domain, op) effective at opset version: the registration with the greatest min_opset <= version.

pub fn operator_count(&self) -> usize

Number of distinct (domain, operator) keys in the registry.

pub fn entry_count(&self) -> usize

Number of opset-versioned inference rule entries.

pub fn operator_versions(&self) -> Vec<(&str, &str, u64)>

Every registered rule as (domain, operator, min_opset), sorted.

This is the full identity of the catalog — its keys and opset floors, not its handler bodies — and the thing to pin. A swap of the InferenceFn behind an unchanged triple is deliberately out of scope here; that is what the behavioural rule tests cover. Neither count above can see a change that preserves them:

• a rename drops one key and adds another, so operator_count and entry_count both hold;
• an opset move rewrites an existing entry’s min_opset in place, so entry_count holds too.

Both are silent in production rather than loud: Self::get returns None for a key it does not know and for a version below every registration, and Self::infer_node treats None permissively — outputs are left unknown and the model still runs.

pub fn infer_node( &self, node: &Node, opset_imports: &HashMap<String, u64>, inputs: Vec<NodeIo>, policy: MergePolicy, interner: &mut SymbolInterner, ) -> Result<Vec<NodeIo>, ShapeInferError>

Infer a single node’s outputs.

Returns one NodeIo per output slot. An unregistered op (or one whose rule declines to resolve an output) yields empty NodeIos — the permissive “leave it unknown” outcome, never an error.

Trait Implementations

impl Default for InferenceRegistry

fn default() -> InferenceRegistry

Returns the “default value” for a type.