Struct SplitSlotStorage 

pub struct SplitSlotStorage { /* private fields */ }

Split slot storage implementation.

Separates slot layout (structural information) from payload data (remembered values), allowing layout changes without data loss.

Implementations

impl SplitSlotStorage

pub fn new() -> Self

impl SplitSlotStorage

pub fn debug_dump_groups(&self) -> Vec<(usize, Key, Option<usize>, usize)>

Debug method to dump all groups.

pub fn debug_dump_all_slots(&self) -> Vec<(usize, String)>

Debug method to dump all slots.

Trait Implementations

impl Default for SplitSlotStorage

fn default() -> SplitSlotStorage

Returns the “default value” for a type.

impl SlotStorage for SplitSlotStorage

type Group = GroupId

Opaque handle to a started group.

type ValueSlot = ValueSlotId

Opaque handle to a value slot.

fn begin_group(&mut self, key: Key) -> StartGroup<Self::Group>

Begin a group with the given key.

fn set_group_scope(&mut self, group: Self::Group, scope: usize)

Associate the runtime recomposition scope with this group.

fn end_group(&mut self)

End the current group.

fn skip_current_group(&mut self)

Skip over the current group (used by the “skip optimization” in the macro).

fn nodes_in_current_group(&self) -> Vec<NodeId>

Return node ids that live in the current group (needed so the composer can reattach them to the parent when skipping).

fn begin_recranpose_at_scope(&mut self, scope: usize) -> Option<Self::Group>

Start recomposing the group that owns scope. Returns the group we started, or None if that scope is gone.

fn end_recompose(&mut self)

Finish the recomposition started with begin_recranpose_at_scope.

fn alloc_value_slot<T: 'static>( &mut self, init: impl FnOnce() -> T, ) -> Self::ValueSlot

Allocate or reuse a value slot at the current cursor.

fn read_value<T: 'static>(&self, slot: Self::ValueSlot) -> &T

Immutable read of a value slot.

fn read_value_mut<T: 'static>(&mut self, slot: Self::ValueSlot) -> &mut T

Mutable read of a value slot.

fn write_value<T: 'static>(&mut self, slot: Self::ValueSlot, value: T)

Overwrite an existing value slot.

fn remember<T: 'static>(&mut self, init: impl FnOnce() -> T) -> Owned<T>

Convenience “remember” built on top of value slots.

fn peek_node(&self) -> Option<NodeId>

Peek a node at the current cursor (don’t advance).

fn record_node(&mut self, id: NodeId)

Record a node at the current cursor (and advance).

fn advance_after_node_read(&mut self)

Advance after we’ve read a node via the applier path.

fn step_back(&mut self)

Step the cursor back by one (used when we probed and need to overwrite).

fn finalize_current_group(&mut self) -> bool

“Finalize” the current group: mark unreachable tail as gaps. Returns true if we marked gaps (which means children are unstable).

fn reset(&mut self)

Reset to the beginning (used by subcompose + top-level render).

fn flush(&mut self)

Flush any deferred anchor rebuilds.