Struct Closure 

pub(crate) struct Closure {
    pub(crate) blocks: Vec<BlockId>,
    pub(crate) pins: Vec<PinId>,
    pub(crate) routes: Vec<RouteId>,
    pub(crate) labels: Vec<RouteLabelId>,
    pub(crate) texts: Vec<TextId>,
    pub(crate) areas: Vec<AreaId>,
    pub(crate) images: Vec<ImageId>,
}

Everything a set of roots takes with it: the transitive closure over containment (a block’s subtree and its contents) and wire adjacency (a pin’s routes, a route’s labels). Held entities only, each listed once, blocks ordered ancestors first and every other kind by id — so a gesture’s ops read the same on every run.

Shared with the clipboard (10g): copying a selection walks the same closure that deleting it does.

Fields

blocks: Vec<BlockId>

pins: Vec<PinId>

routes: Vec<RouteId>

labels: Vec<RouteLabelId>

texts: Vec<TextId>

areas: Vec<AreaId>

images: Vec<ImageId>

Implementations

impl Closure

pub(crate) fn of(indexed: &IndexedDocument<'_>, roots: &[Target]) -> Self

pub(crate) fn push_deletes(&self, builder: &mut CommitBuilder)

The cascade as ops, each entity dying before whatever owned it: labels, wires, pins, annotations, then blocks children first. The fold is order-tolerant inside one commit — this order is for whoever reads the log.

Trait Implementations

impl Debug for Closure

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

Formats the value using the given formatter.