Struct calc_graph::Node [−][src]
pub struct Node<C> { /* fields omitted */ }Represents a value within the graph.
Nodes can calculate their value automatically based on other nondes.
Methods
impl<C: Calc> Node<C> where
C::Value: Clone, [src]
impl<C: Calc> Node<C> where
C::Value: Clone, impl<C: Calc> Node<C>[src]
impl<C: Calc> Node<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>[src]
impl<C: Calc + Send + 'static> Node<C>pub fn boxed(self) -> BoxNode<C::Value>[src]
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
Calctype (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<T: Clone> Node<Const<T>>[src]
impl<T: Clone> Node<Const<T>>impl<T: Clone> Node<Source<T>>[src]
impl<T: Clone> Node<Source<T>>impl<T> Node<Source<T>>[src]
impl<T> Node<Source<T>>pub fn update(
&mut self,
updater: impl FnOnce(T) -> T
)[src]
pub fn update(
&mut self,
updater: impl FnOnce(T) -> T
)Changes the value held within the source node based on the current value.
pub fn set(&mut self, value: T)[src]
pub fn set(&mut self, value: T)Replaces the value held within the source node.
impl<C1: Calc> Node<C1>[src]
impl<C1: Calc> Node<C1>pub fn map<T, F: FnMut(C1::Value) -> T>(self, f: F) -> Node<Func1<C1, T, F>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.
impl<C1: Calc> Node<C1>[src]
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>>[src]
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.