Struct Foreground 

pub struct Foreground {
    shapes: BTreeSet<ShapeId>,
    routes: BTreeSet<RouteId>,
}

What a gesture may write, raised out of the background.

The invariant the background cache depends on:

The foreground is a superset of everything the gesture can write.

If it holds, the background survives the gesture. If it does not, the gesture invalidates its own cache partway through — correct, but with the saving lost, which is why Self::escapees exists to prove it in tests.

Fields

shapes: BTreeSet<ShapeId>

routes: BTreeSet<RouteId>

Implementations

impl Foreground

pub fn raising( shapes: impl IntoIterator<Item = ShapeId>, drawing: &Drawing<'_>, ) -> Self

Raise shapes and everything their movement can disturb: the wires anchored to them, and the wires their current footprints already block or hug. A gesture that moves a shape adds its destination with Self::also_disturbed_by — the footprint it is heading for disturbs wires the one it is leaving never touched.

pub fn written(ops: &[OpCodes], drawing: &Drawing<'_>) -> Self

What a gesture’s own ops touched, raised. Where Self::raising asks what the user selected, this asks what the gesture actually wrote — a subset, and the one the solve is scoped to, so that what a pass may re-solve is derived from the same ops it is riding on.

fn derive( shapes: BTreeSet<ShapeId>, routes: BTreeSet<RouteId>, drawing: &Drawing<'_>, ) -> Self

pub fn also_disturbed_by(&mut self, rect: Rect, drawing: &Drawing<'_>)

Also raise the wires rect blocks or hugs — the footprint a move is heading for, which is not in the document yet and so cannot be derived from it.

pub fn holds_route(&self, id: RouteId) -> bool

Is this wire in the foreground — may this pass re-solve it?

pub fn holds(&self, entity: EntityRef, drawing: &Drawing<'_>) -> bool

Is entity in the foreground?

pub fn escapees<'a>( &'a self, ops: &'a [OpCodes], drawing: &'a Drawing<'_>, ) -> impl Iterator<Item = EntityRef> + 'a

The ops in commit that write routing geometry this foreground does not hold — each one a reason the background cache would have to be dropped. Empty is the invariant holding.

Deliberately conservative about which ops count: any op on a block, pin or route is treated as moving the lattice, though a rename plainly does not. A cheap over-report costs a rebuild; an under-report would solve against occupancy that has silently moved.

pub fn extent(&self, drawing: &Drawing<'_>) -> Rect

The rectangle this foreground occupies: every shape it raised and every wire, grown by the moat a block shapes its channels within.

What a commit disturbed, in other words — which is what the reconstruction after it needs, since a wire outside this rectangle is drawn from geometry nothing moved near.

pub fn shapes(&self) -> impl Iterator<Item = ShapeId> + '_

The shapes raised, for the caller building the background without them.

pub fn routes(&self) -> impl Iterator<Item = RouteId> + '_

The wires raised, for the same reason.

fn anchored_to_a_raised_shape(&self, id: RouteId, drawing: &Drawing<'_>) -> bool

fn footprints(&self, drawing: &Drawing<'_>) -> Vec<Rect>

fn raise_wires_crossing(&mut self, rect: Rect, drawing: &Drawing<'_>)

Every wire rect reaches: the ones it crosses, and the ones running within its moat.

The moat rather than the route gutter, because a block does not only obstruct wires — it shapes the channels around itself, trimming those it spans and seeding five lanes of its own out to MOAT_REACH. A wire running in one of those channels is drawn where it is because of this block, so moving the block can change it even though the wire never touches it.

Trait Implementations

impl Clone for Foreground

fn clone(&self) -> Foreground

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Foreground

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

Formats the value using the given formatter.

impl Default for Foreground

fn default() -> Foreground

Returns the “default value” for a type.

impl PartialEq for Foreground

fn eq(&self, other: &Foreground) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Foreground

impl StructuralPartialEq for Foreground