Struct calc_graph::Node

pub struct Node<C> { /* private fields */ }

Represents a value within the graph.

Nodes can calculate their value automatically based on other nondes.

Implementations

impl<C: Calc> Node<C>where
    C::Value: Clone,

pub fn get_mut(&mut self) -> C::Value

Returns the node’s value, recalculating it if needed.

impl<C: Calc> Node<C>

pub fn shared(self) -> SharedNode<C>

Wraps this node so that it can be used as an input to two or more dependent nodes.

impl<C: Calc + Send + 'static> Node<C>

pub fn boxed(self) -> BoxNode<C::Value>

Wraps this node so that its Calc type is hidden.

Boxing is needed when:

• you need to write the type of the node, but you can’t write the name of the concrete Calc type (for instance, it’s a func node involving a closure)
• you have a choice of types for a node (for instance, if a { a_node.boxed() } else { b_node.boxed() })

impl<C: Calc> Node<Arc<Mutex<RawMutex, C>>>

pub fn get(&self) -> C::Value

Returns the shared node’s value, recalculating it if needed.

impl<T: Clone> Node<Const<T>>

pub fn get(&self) -> T

Returns the const node’s value.

impl<T: Clone> Node<Source<T>>

pub fn get(&self) -> T

Returns the source node’s value.

impl<T> Node<Source<T>>

pub fn update(&self, updater: impl FnOnce(&mut T) -> bool)

Changes the value held within the source node based on the current value.

pub fn set(&self, value: T)

Replaces the value held within the source node.

impl<C: Calc> Node<C>

pub fn inspect<F: FnMut(&C::Value)>(self, f: F) -> Node<Inspect<C, F>>

Wraps the node with a function, whicih can inspect the node’s value each time it is calculated.

impl<C1: Calc> Node<C1>

pub fn map<T, F: FnMut(C1::Value) -> T>(self, f: F) -> Node<Func1<C1, T, F>>

Returns a new node whose value is calculated from this node.

pub fn map_update<T, F: FnMut(&mut T, C1::Value) -> bool>(
    self,
    initial_value: T,
    f: F
) -> Node<Update1<C1, T, F>>

Returns a new node whose value is calculated from this node. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip<C2: Calc, T, F: FnMut(C1::Value, C2::Value) -> T>(
    self,
    prec2: Node<C2>,
    f: F
) -> Node<Func2<C1, C2, T, F>>

Returns a new node whose value is calculated from this node and another node.

pub fn zip_update<C2: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value) -> bool>(
    self,
    prec2: Node<C2>,
    initial_value: T,
    f: F
) -> Node<Update2<C1, C2, T, F>>

Returns a new node whose value is calculated from this node and another node. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip3<C2: Calc, C3: Calc, T, F: FnMut(C1::Value, C2::Value, C3::Value) -> T>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    f: F
) -> Node<Func3<C1, C2, C3, T, F>>

Returns a new node whose value is calculated from this node and 2 other nodes.

pub fn zip3_update<C2: Calc, C3: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value, C3::Value) -> bool>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    initial_value: T,
    f: F
) -> Node<Update3<C1, C2, C3, T, F>>

Returns a new node whose value is calculated from this node and 2 other nodes. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip4<C2: Calc, C3: Calc, C4: Calc, T, F: FnMut(C1::Value, C2::Value, C3::Value, C4::Value) -> T>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    f: F
) -> Node<Func4<C1, C2, C3, C4, T, F>>

Returns a new node whose value is calculated from this node and 3 other nodes.

pub fn zip4_update<C2: Calc, C3: Calc, C4: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value, C3::Value, C4::Value) -> bool>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    initial_value: T,
    f: F
) -> Node<Update4<C1, C2, C3, C4, T, F>>

Returns a new node whose value is calculated from this node and 3 other nodes. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip5<C2: Calc, C3: Calc, C4: Calc, C5: Calc, T, F: FnMut(C1::Value, C2::Value, C3::Value, C4::Value, C5::Value) -> T>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    f: F
) -> Node<Func5<C1, C2, C3, C4, C5, T, F>>

Returns a new node whose value is calculated from this node and 4 other nodes.

pub fn zip5_update<C2: Calc, C3: Calc, C4: Calc, C5: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value, C3::Value, C4::Value, C5::Value) -> bool>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    initial_value: T,
    f: F
) -> Node<Update5<C1, C2, C3, C4, C5, T, F>>

Returns a new node whose value is calculated from this node and 4 other nodes. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip6<C2: Calc, C3: Calc, C4: Calc, C5: Calc, C6: Calc, T, F: FnMut(C1::Value, C2::Value, C3::Value, C4::Value, C5::Value, C6::Value) -> T>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    prec6: Node<C6>,
    f: F
) -> Node<Func6<C1, C2, C3, C4, C5, C6, T, F>>

Returns a new node whose value is calculated from this node and 5 other nodes.

pub fn zip6_update<C2: Calc, C3: Calc, C4: Calc, C5: Calc, C6: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value, C3::Value, C4::Value, C5::Value, C6::Value) -> bool>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    prec6: Node<C6>,
    initial_value: T,
    f: F
) -> Node<Update6<C1, C2, C3, C4, C5, C6, T, F>>

Returns a new node whose value is calculated from this node and 5 other nodes. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip7<C2: Calc, C3: Calc, C4: Calc, C5: Calc, C6: Calc, C7: Calc, T, F: FnMut(C1::Value, C2::Value, C3::Value, C4::Value, C5::Value, C6::Value, C7::Value) -> T>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    prec6: Node<C6>,
    prec7: Node<C7>,
    f: F
) -> Node<Func7<C1, C2, C3, C4, C5, C6, C7, T, F>>

Returns a new node whose value is calculated from this node and 6 other nodes.

pub fn zip7_update<C2: Calc, C3: Calc, C4: Calc, C5: Calc, C6: Calc, C7: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value, C3::Value, C4::Value, C5::Value, C6::Value, C7::Value) -> bool>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    prec6: Node<C6>,
    prec7: Node<C7>,
    initial_value: T,
    f: F
) -> Node<Update7<C1, C2, C3, C4, C5, C6, C7, T, F>>

Returns a new node whose value is calculated from this node and 6 other nodes. The FnMut that performs the calculation can update the value in place.

impl<C1: Calc> Node<C1>

pub fn zip8<C2: Calc, C3: Calc, C4: Calc, C5: Calc, C6: Calc, C7: Calc, C8: Calc, T, F: FnMut(C1::Value, C2::Value, C3::Value, C4::Value, C5::Value, C6::Value, C7::Value, C8::Value) -> T>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    prec6: Node<C6>,
    prec7: Node<C7>,
    prec8: Node<C8>,
    f: F
) -> Node<Func8<C1, C2, C3, C4, C5, C6, C7, C8, T, F>>

Returns a new node whose value is calculated from this node and 7 other nodes.

pub fn zip8_update<C2: Calc, C3: Calc, C4: Calc, C5: Calc, C6: Calc, C7: Calc, C8: Calc, T, F: FnMut(&mut T, C1::Value, C2::Value, C3::Value, C4::Value, C5::Value, C6::Value, C7::Value, C8::Value) -> bool>(
    self,
    prec2: Node<C2>,
    prec3: Node<C3>,
    prec4: Node<C4>,
    prec5: Node<C5>,
    prec6: Node<C6>,
    prec7: Node<C7>,
    prec8: Node<C8>,
    initial_value: T,
    f: F
) -> Node<Update8<C1, C2, C3, C4, C5, C6, C7, C8, T, F>>

Returns a new node whose value is calculated from this node and 7 other nodes. The FnMut that performs the calculation can update the value in place.

Trait Implementations

impl<C: Clone> Clone for Node<C>

fn clone(&self) -> Node<C>

Returns a copy of the value.

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

Performs copy-assignment from source.