Enum SlotBackend 

pub enum SlotBackend {
    Baseline(SlotTable),
    Chunked(ChunkedSlotStorage),
    Hierarchical(HierarchicalSlotStorage),
    Split(SplitSlotStorage),
}

Unified slot storage backend that can use any implementation.

Variants

Baseline(SlotTable)

Chunked(ChunkedSlotStorage)

Hierarchical(HierarchicalSlotStorage)

Split(SplitSlotStorage)

Implementations

impl SlotBackend

pub fn new(kind: SlotBackendKind) -> Self

Create a new backend of the specified kind.

NOTE: Currently, all backend kinds map to the Baseline implementation since the experimental backends (Chunked, Hierarchical, Split) are still under development and don’t pass all tests. This allows the backend infrastructure to exist while development continues.

impl SlotBackend

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

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

Trait Implementations

impl Default for SlotBackend

fn default() -> Self

Returns the “default value” for a type.

impl SlotStorage for SlotBackend

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.