Macro ttgraph::macros::mut_node

macro_rules! mut_node {
    ($transaction: expr, $var: path, $idx: expr, $node: ident, $func: block) => { ... };
    ($transaction: expr, $var: path, $idx: expr, | $node: ident | $func: block) => { ... };
    ($transaction: expr, $var: path, $idx: expr, move | $node: ident | $func: block) => { ... };
}

Use the mutate method of the transaction, assume the node is $var variant of the NodeEnum. Panics if the enum does not match.

Overloads:

• Legacy: mut_node!(graph, NodeEnum::Variant, idx, x, { ... })
• Normal closure: mut_node!(graph, NodeEnum::Variant, idx, |x| { ... })
• Move closure: mut_node!(graph, NodeEnum::Variant, idx, move |x| { ... })

Example

use ttgraph::*;

#[derive(TypedNode)]
struct NodeA{
  a: usize
}

node_enum!{
  enum MyNodeEnum{
    A(NodeA)
  }
}

let ctx = Context::new();
let mut graph = Graph::<MyNodeEnum>::new(&ctx);
let mut trans = Transaction::new(&ctx);

let id = trans.insert(MyNodeEnum::A(NodeA{ a: 1 }));
graph.commit(trans);

trans = Transaction::new(&ctx);
// It is similar to this closure |x: &mut NodeA| {x.a =2 }
mut_node!(trans, MyNodeEnum::A, id, |x| {
  x.a = 2;
});
graph.commit(trans);

let a = get_node!(graph, MyNodeEnum::A, id);
assert!(a.is_some());
assert_eq!(a.unwrap().a, 2);