Struct reax::computed::ComputedVar

#[must_use]pub struct ComputedVar<C> { /* fields omitted */ }

A lazily computed variable that is tracked by the reax runtime.

Implementations

impl<C> ComputedVar<C>

pub fn new_raw(value: C) -> Self

Constructs a computed variable around the given ComputedValue. The dependencies of the variable will be determined from the accesses made by the update function. Note that update will not be executed until someone retrieves the value of this cell.

pub fn node(&self) -> &Node

Returns a handle to this computation's node in the dependency graph.

impl<T, F, C> ComputedVar<FunctionComputed<T, F, C>> where
    F: FnMut(&mut C) -> T, 

pub fn new(func: F) -> Self

Constructs a computed variable. The value of the variable will be the set by the given function when needed. The dependencies of the variable will be determined from the accesses made by the given function. Note that the function will not be executed until someone retrieves the value of this cell.

To reuse buffers from past executions, use new_mutate.

impl<T, F, C> ComputedVar<MutatorComputed<T, F, C>> where
    F: FnMut(&mut T, &mut C), 

pub fn new_mutate(initial: T, func: F) -> Self

Constructs a computed variable. This is identical to new except the value of the variable will be mutated by the given function when needed, not created from scratch.

impl<C: ComputedValue> ComputedVar<C>

pub fn get_contextual(&self, ctx: &mut C::Context) -> Ref<C::Value>

Identical to Variable::get but requires the update context.

pub fn get_contextual_non_reactive(&self, ctx: &mut C::Context) -> Ref<C::Value>

Identical to Variable::get_non_reactive but requires the update context.

pub fn boxed<'a>(self) -> BoxedComputedVar<'a, C::Value, C::Context> where
    Self: 'a, 

Creates a boxed version of this cell who's type does not depend on how the cell is updated.

pub fn force(&self, ctx: &mut C::Context)

Forces the variable to re-compute no matter its current dirty status.

pub fn check(&self, ctx: &mut C::Context)

If changes to upstream variables have made this variable dirty, re-compute it. Otherwise, do nothing.

Trait Implementations

impl<C: ComputedValue<Context = ()>> Debug for ComputedVar<C> where
    C::Value: Debug, 

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

Formats the value using the given formatter.

impl<C: ComputedValue<Context = ()>> Variable for ComputedVar<C>

type Value = C::Value

The type of this variable.

fn node(&self) -> &Node

Returns a handle to this variable's node in the reax runtime's dependency graph.

fn get(&self) -> Ref<C::Value>

Returns the value of this variable.

fn get_non_reactive(&self) -> Ref<C::Value>

Returns the value of this variable without alerting the reax runtime that the variable is used in the current context. See also get.

fn get_copy(&self) -> Self::Value where
    Self::Value: Copy, 

Returns the value of this variable by copy where possible. See also get.

fn map<T, F>(self, func: F) -> ComputedVar<FunctionMapped<Self, T, F>> where
    F: FnMut(&Self::Value) -> T, 

Create a new ComputedVar which depends only on this variable. The value of the returned cell is lazily computed by the given function. That is, the function will not be executed until someone retrieves the value of the cell. This can be used similarly to EagerCompute::watch if the resulting cell is checked frequently. See also ComputedVar::new.

fn map_mutate<T, F>(
    self,
    initial: T,
    func: F
) -> ComputedVar<MutatorMapped<Self, T, F>> where
    F: FnMut(&Self::Value, &mut T), 

Create a new ComputedVar which depends only on this variable. The value of the returned cell is lazily updated by the given function. That is, the function will not be executed until someone retrieves the value of the cell. This can be used similarly to EagerCompute::watch if the resulting cell is checked frequently. See also ComputedVar::new_mutate.

fn with_label(self, label: impl Display) -> Self

Provides the runtime with a variable name to use in debug outputs. This does nothing in release builds.