Struct Composition 

pub struct Composition<A>
where
    A: Applier + 'static,
{ /* private fields */ }

Re-export the UI crate so applications can depend on a single crate.

Implementations

impl<A> Composition<A>

where A: Applier + 'static,

pub fn new(applier: A) -> Composition<A>

pub fn with_runtime(applier: A, runtime: Runtime) -> Composition<A>

pub fn root_key(&self) -> Option<u64>

Returns the root group key captured from the most recent render() call, or None before the first render.

pub fn set_retention_policy(&self, policy: RetentionPolicy)

pub fn take_root_render_request(&mut self) -> bool

pub fn request_root_render(&mut self)

pub fn render( &mut self, key: u64, content: impl FnMut(), ) -> Result<(), NodeError>

pub fn render_stable( &mut self, key: u64, content: impl FnMut(), ) -> Result<(), NodeError>

Perform a root render and continue replaying any resulting root-render requests until the composition reaches a stable fixpoint.

pub fn reconcile( &mut self, key: u64, content: impl FnMut(), ) -> Result<bool, NodeError>

Process invalid scopes and any resulting root-render requests until the composition reaches a stable fixpoint for the supplied root content.

pub fn should_render(&self) -> bool

Returns true if composition needs to process invalid scopes (recompose).

This checks both:

• has_updates(): composition scopes that were invalidated by state changes
• needs_frame(): animation callbacks that may have pending work

Note: For scroll performance, ensure scroll state changes use Cell<T> instead of MutableState<T> to avoid triggering recomposition on every scroll frame.

pub fn should_recompose(&self) -> bool

Whether any composition scope is actually invalid, i.e. whether running the composable tree could produce a different result than last time.

Deliberately excludes Runtime::needs_frame, which Self::should_render includes. An armed frame callback means the runtime owes someone a tick - a future to resume, a dispatcher to drain - and every app with a game loop or a polling effect has one armed at all times. Re-running the composition for it recomposes a tree that nothing invalidated. Callers deciding “should I tick” want Self::should_render; callers deciding “should I recompose” want this.

It is only meaningful after the frame callbacks have been drained: a callback that writes state invalidates its readers as it runs, so the answer is a question about work already discovered, not work still to come.

pub fn runtime_handle(&self) -> RuntimeHandle

pub fn applier_mut(&mut self) -> ApplierGuard<'_, A>

pub fn root(&self) -> Option<usize>

pub fn debug_dump_slot_table_groups( &self, ) -> Vec<(usize, u64, Option<usize>, usize)>

pub fn debug_dump_slot_entries(&self) -> Vec<SlotDebugEntry>

pub fn slot_table_heap_bytes(&self) -> usize

pub fn debug_slot_table_stats(&self) -> SlotTableDebugStats

pub fn debug_slot_snapshot(&self) -> SlotDebugSnapshot

pub fn debug_observer_stats(&self) -> SnapshotStateObserverDebugStats

pub fn debug_last_pass_stats(&self) -> CompositionPassDebugStats

pub fn process_invalid_scopes(&mut self) -> Result<bool, NodeError>

impl<A> Composition<A>

where A: Applier + 'static,

pub fn flush_pending_node_updates(&mut self) -> Result<(), NodeError>

Trait Implementations

impl<A> Drop for Composition<A>

where A: Applier + 'static,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.