Struct TestApplierGuard

Source

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

Expand description

Mutable access to the applier of a TestComposition, with the app context of that composition active while the guard lives.

Methods from Deref<Target = MemoryApplier>§

Source

pub fn slots_handle(&self) -> Rc<RefCell<SlotTable>>

The slot table that composition during layout writes to, shared with the layout pass that lends this applier.

Source

pub fn scene_node_attached_to( &mut self, node_id: usize, root: usize, ) -> Option<usize>

Resolves a scene-scope candidate the way structural records are resolved: to its nearest non-virtual ancestor, and only while still attached to root. A node detached after recording must not reach the scoped scene update — an id the graph cannot resolve forces it to give up and rebuild the whole scene.

Source

pub fn scene_nodes_attached_to( &mut self, nodes: impl IntoIterator<Item = usize>, root: usize, ) -> Vec<Option<usize>>

Self::scene_node_attached_to for each of nodes, in order, with every ancestor looked up at most once: a batch costs the distinct ancestors of its nodes, not each node’s depth.

Source

pub fn scene_nodes_attached_to_into( &mut self, nodes: impl IntoIterator<Item = usize>, root: usize, output: &mut Vec<Option<usize>>, scratch: &mut SceneNodeAttachmentScratch, )

Fills output with Self::scene_nodes_attached_to results, reusing its storage and the ancestry cache in scratch across batches.

Each distinct ancestor is inspected at most once per call. The cache is cleared for each call, so graph mutations are observed by the next batch.

use cranpose_core::{MemoryApplier, NodeId, SceneNodeAttachmentScratch};

let mut applier = MemoryApplier::new();
let mut scratch = SceneNodeAttachmentScratch::default();
let mut attached: Vec<Option<NodeId>> = Vec::new();
let root = NodeId::default();
applier.scene_nodes_attached_to_into([], root, &mut attached, &mut scratch);
assert!(attached.is_empty());

Source

pub fn take_structural_change_parents_attached_to( &mut self, root: usize, ) -> Vec<usize>

Drains the parents recorded via Applier::record_structural_change, keeping only nodes still attached to root (a parent that was itself removed is covered by its own surviving ancestor’s record). A virtual parent — a subcompose slot wrapper the render graph never contains — is reported as its nearest non-virtual ancestor: that is the node whose graph child set the change altered, and an id the graph cannot resolve would force the scoped scene update to give up and rebuild.

Source

pub fn take_structural_change_parents_into(&mut self, output: &mut Vec<usize>)

Takes the recorded structural-change candidates into reusable storage. Candidates are not resolved or attachment-filtered; callers that route them into scenes should use Self::scene_nodes_attached_to_into.

use cranpose_core::MemoryApplier;

let mut applier = MemoryApplier::new();
let mut nodes = Vec::new();
applier.take_structural_change_parents_into(&mut nodes);
assert!(nodes.is_empty());

Source