Struct LoweringSession 

pub struct LoweringSession<'a> { /* private fields */ }

A single recursive lowering pass over one shared graph builder.

Family lowerers take &mut LoweringSession and return NodeId. Only the public entry point calls LoweringSession::finish.

Implementations

impl<'a> LoweringSession<'a>

pub fn new(model: &'a Model, units: &'a UnitScale) -> Self

Open a session with the default recursion budget.

pub fn with_limits( model: &'a Model, units: &'a UnitScale, limits: SessionLimits, ) -> Self

Open a session with an explicit recursion budget.

pub fn with_face_policy(self, policy: DegenerateFacePolicy) -> Self

Set what lowering does with a collapsed poly-loop face (#46).

Builder-style so the default constructors stay unchanged: LoweringSession::new(model, units).with_face_policy(policy).

pub fn face_policy(&self) -> DegenerateFacePolicy

The degenerate-face policy in force.

pub fn model(&self) -> &'a Model

The model being lowered.

pub fn units(&self) -> &'a UnitScale

The resolved unit scale for this model.

pub fn node_count(&self) -> usize

Number of nodes appended so far.

Exposed so tests can assert that a memoized hit appends nothing.

pub fn node(&mut self, node: GeometryNode) -> GeometryResult<NodeId>

Append one node, attributing any graph fault to the current entity.

pub fn node_for( &mut self, entity: EntityId, node: GeometryNode, ) -> GeometryResult<NodeId>

Append one node, attributing any graph fault to entity.

pub fn provenance(&self) -> &ProvenanceMap

Source attribution accumulated so far.

pub fn entity( &self, referrer: EntityId, id: EntityId, ) -> GeometryResult<&'a Entity>

Resolve an entity or report the dangling reference against referrer.

pub fn memoized( &self, entity: EntityId, family: &'static str, frame: Transform, ) -> Option<NodeId>

Look up a previously lowered result for entity under frame.

pub fn memoize( &mut self, entity: EntityId, family: &'static str, frame: Transform, node: NodeId, )

Record the lowered result for entity under frame.

pub fn enter( &mut self, entity: EntityId, kind: &'static str, ) -> GeometryResult<()>

Mark entity as active in the current chain.

Returns GeometryError::CyclicChain if the entity is already active and GeometryError::ChainTooDeep once the depth budget is exhausted. Every successful call must be paired with LoweringSession::exit.

pub fn exit(&mut self, entity: EntityId)

Release entity from the active chain.

Sharing is not recursion: once a subtree is complete the entity must be reachable again from a sibling branch.

pub fn slots(&self, entity: EntityId) -> GeometryResult<Slots<'a>>

Borrowed attribute view for entity.

pub fn type_name(&self, entity: EntityId) -> GeometryResult<String>

Upper-cased IFC type name for entity.

Dispatch compares against canonical upper-case names because STEP files are case-insensitive in practice and exporters disagree.

pub fn unsupported( &self, entity: EntityId, type_name: &str, detail: &'static str, ) -> GeometryError

Build a typed Unsupported error naming the offending entity.

pub fn degenerate( &self, entity: EntityId, type_name: &str, detail: impl Into<String>, ) -> GeometryError

Build a typed Degenerate error naming the offending entity.

Structurally impossible geometry is distinct from an unimplemented family: the file is understood and the shape does not exist.

pub fn check_aggregate( &self, entity: EntityId, type_name: &str, what: &'static str, requested: u128, ) -> GeometryResult<usize>

Check a file-declared aggregate size against the element budget.

Takes u128 so an overflowing product (triangles * 3) can be computed in a wider type and reported honestly instead of wrapping to a small number that passes the check. Returns the size as usize only once it is known to fit.

Call this before reserving, not after: the point is to refuse the declaration, not to survive the allocation.

pub fn lower_operand( &mut self, entity: EntityId, frame: Transform, ) -> GeometryResult<NodeId>

Lower a nested operand through the total dispatcher.

Kept on the session so recursive families do not each re-import the dispatcher and risk diverging on cycle/limit handling.

pub fn finish(self, root: NodeId) -> GeometryResult<LoweredGeometry>

Freeze the graph with root as its single output root.

Trait Implementations

impl<'a> Debug for LoweringSession<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.