Struct reax::computed::ComputationHandle

pub struct ComputationHandle(_);

Offers greater control over how the reax runtime sees the computation of a node.

Note that handles are isolated across nested computations. For example,

let a = reax::Node::next();
let b = reax::Node::next();
let c = reax::Node::next();

a.computation(|handle| {
    handle.set_reactive_area(false);
    c.on_read(); // Does not count as dependency of a.

    b.computation(|handle| {
        assert_eq!(handle.is_reactive_area(), true);
        c.on_read(); // Does count as a dependency of b.
    });

    assert_eq!(handle.is_reactive_area(), false);
});

assert_eq!(a.depends_on(&c), false);
assert_eq!(b.depends_on(&c), true);

Implementations

impl ComputationHandle

pub fn set_reactive_area(&self, should_react: bool)

Any node accessed after this method is called will count as a dependency if and only if should_react is true.

pub fn is_reactive_area(&self) -> bool

Checks whether node accesses made around this method call will count as dependencies.

Trait Implementations

impl Drop for ComputationHandle

fn drop(&mut self)

Executes the destructor for this type.