Struct Owner

pub struct Owner {
    pub(crate) inner: Arc<RwLock<OwnerInner>>,
    pub(crate) shared_context: Option<Arc<dyn SharedContext + Send + Sync>>,
}

A reactive owner, which manages

1. the cancellation of Effects,
2. providing and accessing environment data via provide_context and use_context,
3. running cleanup functions defined via Owner::on_cleanup, and
4. an arena storage system to provide Copy handles via ArenaItem, which is what allows types like RwSignal, Memo, and so on to be Copy.

Every effect and computed reactive value has an associated Owner. While it is running, this is marked as the current Owner. Whenever it re-runs, this Owner is cleared by calling Owner::with_cleanup. This runs cleanup functions, cancels any Effects created during the last run, drops signals stored in the arena, and so on, because those effects and signals will be re-created as needed during the next run.

When the owner is ultimately dropped, it will clean up its owned resources in the same way.

The “current owner” is set on the thread-local basis: whenever one of these reactive nodes is running, it will set the current owner on its thread with Owner::with or Owner::set, allowing other reactive nodes implicitly to access the fact that it is currently the owner.

For a longer discussion of the ownership model, see here.

Fields

inner: Arc<RwLock<OwnerInner>>

shared_context: Option<Arc<dyn SharedContext + Send + Sync>>

Implementations

impl Owner

pub fn use_context_bidirectional<T>(&self) -> Option<T>

where T: Clone + 'static,

Searches for items stored in context in either direction, either among parents or among descendants.

impl Owner

pub fn debug_id(&self) -> usize

Returns a unique identifier for this owner, which can be used to identify it for debugging purposes.

Intended for debugging only; this is not guaranteed to be stable between runs.

pub fn ancestry(&self) -> Vec<usize>

Returns the list of parents, grandparents, and ancestors, with values corresponding to Owner::debug_id for each.

Intended for debugging only; this is not guaranteed to be stable between runs.

pub fn new() -> Owner

Creates a new Owner and registers it as a child of the current Owner, if there is one.

pub fn new_root( shared_context: Option<Arc<dyn SharedContext + Send + Sync>>, ) -> Owner

Creates a new “root” context with the given [SharedContext], which allows sharing data between the server and client.

Only one SharedContext needs to be created per request, and will be automatically shared by any other Owners created under this one.

pub fn child(&self) -> Owner

Creates a new Owner that is the child of the current Owner, if any.

pub fn set(&self)

Sets this as the current Owner.

pub fn with<T>(&self, fun: impl FnOnce() -> T) -> T

Runs the given function with this as the current Owner.

pub fn with_cleanup<T>(&self, fun: impl FnOnce() -> T) -> T

Cleans up this owner, the given function with this as the current Owner.

pub fn cleanup(&self)

Cleans up this owner in the following order:

1. Runs cleanup on all children,
2. Runs all cleanup functions registered with Owner::on_cleanup,
3. Drops the values of any arena-allocated ArenaItems.

pub fn on_cleanup(fun: impl FnOnce() + Send + Sync + 'static)

Registers a function to be run the next time the current owner is cleaned up.

Because the ownership model is associated with reactive nodes, each “decision point” in an application tends to have a separate Owner: as a result, these cleanup functions often fill the same need as an “on unmount” function in other UI approaches, etc.

pub fn current() -> Option<Owner>

Returns the current Owner, if any.

pub fn shared_context(&self) -> Option<Arc<dyn SharedContext + Send + Sync>>

Returns the [SharedContext] associated with this owner, if any.

pub fn unset(self)

Removes this from its state as the thread-local owner and drops it.

pub fn current_shared_context() -> Option<Arc<dyn SharedContext + Send + Sync>>

Returns the current [SharedContext], if any.

pub fn with_hydration<T>(fun: impl FnOnce() -> T + 'static) -> T

Runs the given function, after indicating that the current [SharedContext] should be prepared to handle any data created in the function.

pub fn with_no_hydration<T>(fun: impl FnOnce() -> T + 'static) -> T

Runs the given function, after indicating that the current [SharedContext] should /// not handle data created in this function.

pub fn pause(&self)

Pauses the execution of side effects for this owner, and any of its descendants.

If this owner is the owner for an Effect or RenderEffect, this effect will not run until Owner::resume is called. All children of this effects are also paused.

Any notifications will be ignored; effects that are notified will paused will not run when resumed, until they are notified again by a source after being resumed.

pub fn paused(&self) -> bool

Whether this owner has been paused by Owner::pause.

pub fn resume(&self)

Resumes side effects that have been paused by Owner::pause.

All children will also be resumed.

This will not cause side effects that were notified while paused to run, until they are notified again by a source after being resumed.

Trait Implementations

impl Clone for Owner

fn clone(&self) -> Owner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Owner

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

Formats the value using the given formatter.

impl Default for Owner

fn default() -> Owner

Returns the “default value” for a type.

impl PartialEq for Owner

fn eq(&self, other: &Owner) -> 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.