Struct Graph

pub struct Graph { /* private fields */ }

The graph class itself. It holds the static information about the tasks (Nodes) and how they depend on each other by waiting on resources (Assets)

Implementations

impl Graph

pub fn new() -> Graph

Examples found in repository

examples/seq10k.rs (line 7)

fn main() {
    let mut g = Graph::new();

    let max = 10000;

    // generate 10000 nodes
    for i in 1..max {
        let name: String = format!("task{}", i);
        g.add_node(create_node!(name: name, ( input : u32) -> (output : u32)
                                 { 
                                     output = input +1 ;
                                 }))
            .unwrap();
    }


    // add sequential linking
    for i in 1..max - 1 {
        let src = format!("task{}::output", i);
        let sink = format!("task{}::input", i + 1);
        g.bind_asset(src.as_str(), sink.as_str())
            .expect("binding must be doable");
    }

    g.define_freestanding_asset("start", 0u32).expect("could not create asset");
        g.bind_asset("start", "task1::input")
            .expect("could not bind first tast to start value");

    let mut cache = ValuesCache::new();
    let mut solver = GraphSolver::new(&g, &mut cache);

    let last_task = format!("task{}", max-1);
    solver.execute(last_task.as_str()).expect("this should run");
}

examples/simple.rs (line 7)

fn main() {
    let mut g = Graph::new();

    g.add_node(create_node!(
                gen_one () -> (one: u32) {
                    println!("              gen one");
                    one = 1u32;
                }
            )).unwrap();

    g.add_node(create_node!(
                plus_one (one: u32) -> (plusone : u32) {
                    println!("              plusone");
                    plusone = one + 1u32;
                }
            )).unwrap();

    g.add_node(create_node!(
                the_one_task  (one: u32, plusone : u32) ->
                              (last_value: f32) {
                    println!("              the one task");
                    last_value = (one + plusone) as f32;
                }
            )).unwrap();

    g.add_node(create_node!(
                list (list : Vec<u32>) -> () {
                    println!("             list");
                }
            )).unwrap();

    g.bind_asset("gen_one::one", "plus_one::one")
        .expect("binding must be doable");
    g.bind_asset("gen_one::one", "the_one_task::one")
        .expect("binding must be doable");
    g.bind_asset("plus_one::plusone", "the_one_task::plusone")
        .expect("binding must be doable");

    let mut cache = ValuesCache::new();

    for _ in 0..10 {
        {
            let mut solver = GraphSolver::new(&g, &mut cache);
            assert!(solver.execute("nop").is_err());

            solver.execute("the_one_task").expect("could not execute");

            println!("{:?}", solver.get_values());

            assert!(
                solver
                    .get_value::<u32>("gen_one::one")
                    .expect("never created?") == 1
            );
            assert!(
                solver
                    .get_value::<u32>("plus_one::plusone")
                    .expect("never created?") == 2
            );
            assert!(
                (solver
                    .get_value::<f32>("the_one_task::last_value")
                    .expect("not cached?") - 3.0)
                    .abs() < 0.01
            );
        }

        assert!(cache.get_value::<u32>("gen_one::one").expect("not cached?") == 1);
        assert!(
            cache
                .get_value::<u32>("plus_one::plusone")
                .expect("not cached?") == 2
        );
        assert!(
            (cache
                .get_value::<f32>("the_one_task::last_value")
                .expect("not cached?") - 3.0)
                .abs() < 0.01
        );
    }
}

pub fn add_node<F>(&mut self, node: Node<F>) -> Result<(), GraphError>

where F: Fn(&mut GraphSolver<'_, '_>) -> Result<SolverStatus, SolverError> + 'static,

Examples found in repository

examples/seq10k.rs (lines 14-17)

fn main() {
    let mut g = Graph::new();

    let max = 10000;

    // generate 10000 nodes
    for i in 1..max {
        let name: String = format!("task{}", i);
        g.add_node(create_node!(name: name, ( input : u32) -> (output : u32)
                                 { 
                                     output = input +1 ;
                                 }))
            .unwrap();
    }


    // add sequential linking
    for i in 1..max - 1 {
        let src = format!("task{}::output", i);
        let sink = format!("task{}::input", i + 1);
        g.bind_asset(src.as_str(), sink.as_str())
            .expect("binding must be doable");
    }

    g.define_freestanding_asset("start", 0u32).expect("could not create asset");
        g.bind_asset("start", "task1::input")
            .expect("could not bind first tast to start value");

    let mut cache = ValuesCache::new();
    let mut solver = GraphSolver::new(&g, &mut cache);

    let last_task = format!("task{}", max-1);
    solver.execute(last_task.as_str()).expect("this should run");
}

examples/simple.rs (lines 9-14)

fn main() {
    let mut g = Graph::new();

    g.add_node(create_node!(
                gen_one () -> (one: u32) {
                    println!("              gen one");
                    one = 1u32;
                }
            )).unwrap();

    g.add_node(create_node!(
                plus_one (one: u32) -> (plusone : u32) {
                    println!("              plusone");
                    plusone = one + 1u32;
                }
            )).unwrap();

    g.add_node(create_node!(
                the_one_task  (one: u32, plusone : u32) ->
                              (last_value: f32) {
                    println!("              the one task");
                    last_value = (one + plusone) as f32;
                }
            )).unwrap();

    g.add_node(create_node!(
                list (list : Vec<u32>) -> () {
                    println!("             list");
                }
            )).unwrap();

    g.bind_asset("gen_one::one", "plus_one::one")
        .expect("binding must be doable");
    g.bind_asset("gen_one::one", "the_one_task::one")
        .expect("binding must be doable");
    g.bind_asset("plus_one::plusone", "the_one_task::plusone")
        .expect("binding must be doable");

    let mut cache = ValuesCache::new();

    for _ in 0..10 {
        {
            let mut solver = GraphSolver::new(&g, &mut cache);
            assert!(solver.execute("nop").is_err());

            solver.execute("the_one_task").expect("could not execute");

            println!("{:?}", solver.get_values());

            assert!(
                solver
                    .get_value::<u32>("gen_one::one")
                    .expect("never created?") == 1
            );
            assert!(
                solver
                    .get_value::<u32>("plus_one::plusone")
                    .expect("never created?") == 2
            );
            assert!(
                (solver
                    .get_value::<f32>("the_one_task::last_value")
                    .expect("not cached?") - 3.0)
                    .abs() < 0.01
            );
        }

        assert!(cache.get_value::<u32>("gen_one::one").expect("not cached?") == 1);
        assert!(
            cache
                .get_value::<u32>("plus_one::plusone")
                .expect("not cached?") == 2
        );
        assert!(
            (cache
                .get_value::<f32>("the_one_task::last_value")
                .expect("not cached?") - 3.0)
                .abs() < 0.01
        );
    }
}

pub fn get_node(&self, name: &str) -> Option<&dyn NodeRunner>

pub fn get_terminals(&self) -> &[Rc<dyn NodeRunner>]

pub fn get_binding(&self, name: &String) -> Option<&String>

pub fn get_binding_str(&self, name: &str) -> Option<&String>

pub fn define_freestanding_asset<T: 'static + Clone>( &mut self, name: &str, val: T, ) -> Result<(), GraphError>

declares and initializes a freestanding asset, this assets are defined as global inputs to the graph and can be used to feed initial values in the system

Examples found in repository

examples/seq10k.rs (line 30)

fn main() {
    let mut g = Graph::new();

    let max = 10000;

    // generate 10000 nodes
    for i in 1..max {
        let name: String = format!("task{}", i);
        g.add_node(create_node!(name: name, ( input : u32) -> (output : u32)
                                 { 
                                     output = input +1 ;
                                 }))
            .unwrap();
    }


    // add sequential linking
    for i in 1..max - 1 {
        let src = format!("task{}::output", i);
        let sink = format!("task{}::input", i + 1);
        g.bind_asset(src.as_str(), sink.as_str())
            .expect("binding must be doable");
    }

    g.define_freestanding_asset("start", 0u32).expect("could not create asset");
        g.bind_asset("start", "task1::input")
            .expect("could not bind first tast to start value");

    let mut cache = ValuesCache::new();
    let mut solver = GraphSolver::new(&g, &mut cache);

    let last_task = format!("task{}", max-1);
    solver.execute(last_task.as_str()).expect("this should run");
}

pub fn bind_asset(&mut self, src: &str, sink: &str) -> Result<(), GraphError>

Binds two nodes. An asset satisfied by a task, will be the input for another task under a different asset name. One output asset can be used in one or more inputs. If the input is already bound, the link will be overwritten

Examples found in repository

examples/seq10k.rs (line 26)

fn main() {
    let mut g = Graph::new();

    let max = 10000;

    // generate 10000 nodes
    for i in 1..max {
        let name: String = format!("task{}", i);
        g.add_node(create_node!(name: name, ( input : u32) -> (output : u32)
                                 { 
                                     output = input +1 ;
                                 }))
            .unwrap();
    }


    // add sequential linking
    for i in 1..max - 1 {
        let src = format!("task{}::output", i);
        let sink = format!("task{}::input", i + 1);
        g.bind_asset(src.as_str(), sink.as_str())
            .expect("binding must be doable");
    }

    g.define_freestanding_asset("start", 0u32).expect("could not create asset");
        g.bind_asset("start", "task1::input")
            .expect("could not bind first tast to start value");

    let mut cache = ValuesCache::new();
    let mut solver = GraphSolver::new(&g, &mut cache);

    let last_task = format!("task{}", max-1);
    solver.execute(last_task.as_str()).expect("this should run");
}

examples/simple.rs (line 37)

fn main() {
    let mut g = Graph::new();

    g.add_node(create_node!(
                gen_one () -> (one: u32) {
                    println!("              gen one");
                    one = 1u32;
                }
            )).unwrap();

    g.add_node(create_node!(
                plus_one (one: u32) -> (plusone : u32) {
                    println!("              plusone");
                    plusone = one + 1u32;
                }
            )).unwrap();

    g.add_node(create_node!(
                the_one_task  (one: u32, plusone : u32) ->
                              (last_value: f32) {
                    println!("              the one task");
                    last_value = (one + plusone) as f32;
                }
            )).unwrap();

    g.add_node(create_node!(
                list (list : Vec<u32>) -> () {
                    println!("             list");
                }
            )).unwrap();

    g.bind_asset("gen_one::one", "plus_one::one")
        .expect("binding must be doable");
    g.bind_asset("gen_one::one", "the_one_task::one")
        .expect("binding must be doable");
    g.bind_asset("plus_one::plusone", "the_one_task::plusone")
        .expect("binding must be doable");

    let mut cache = ValuesCache::new();

    for _ in 0..10 {
        {
            let mut solver = GraphSolver::new(&g, &mut cache);
            assert!(solver.execute("nop").is_err());

            solver.execute("the_one_task").expect("could not execute");

            println!("{:?}", solver.get_values());

            assert!(
                solver
                    .get_value::<u32>("gen_one::one")
                    .expect("never created?") == 1
            );
            assert!(
                solver
                    .get_value::<u32>("plus_one::plusone")
                    .expect("never created?") == 2
            );
            assert!(
                (solver
                    .get_value::<f32>("the_one_task::last_value")
                    .expect("not cached?") - 3.0)
                    .abs() < 0.01
            );
        }

        assert!(cache.get_value::<u32>("gen_one::one").expect("not cached?") == 1);
        assert!(
            cache
                .get_value::<u32>("plus_one::plusone")
                .expect("not cached?") == 2
        );
        assert!(
            (cache
                .get_value::<f32>("the_one_task::last_value")
                .expect("not cached?") - 3.0)
                .abs() < 0.01
        );
    }
}

pub fn what_provides(&self, name: &str) -> AssetProvider<'_>

For a given asset name, identifies which node generates the it

pub fn get_unbound_assets(&self) -> Vec<&String>

reports a collection of input assets which are not currenty bound, this elements are disconnected and will have no value satisfied during execution.

pub fn get_freestanding_assets(&self) -> &Vec<String>

Trait Implementations

impl Default for Graph

fn default() -> Graph

Returns the “default value” for a type.

impl<'a> GraphWalk<'a, &'a str, (&'a str, &'a str, &'a str, &'a str)> for Graph

fn nodes(&'a self) -> Nodes<'a, &'a str>

Returns all the nodes in this graph.

fn edges(&'a self) -> Edges<'a, (&'a str, &'a str, &'a str, &'a str)>

Returns all of the edges in this graph.

fn source(&self, e: &(&'a str, &'a str, &'a str, &'a str)) -> &'a str

The source node for edge.

fn target(&self, e: &(&'a str, &'a str, &'a str, &'a str)) -> &'a str

The target node for edge.

impl<'a> Labeller<'a, &'a str, (&'a str, &'a str, &'a str, &'a str)> for Graph

fn graph_id(&'a self) -> Id<'a>

Must return a DOT compatible identifier naming the graph.

fn node_id(&'a self, n: &&'_ str) -> Id<'a>

Maps n to a unique identifier with respect to self. The implementer is responsible for ensuring that the returned name is a valid DOT identifier.

fn edge_label<'b>( &'b self, edge: &(&'_ str, &'_ str, &'_ str, &'_ str), ) -> LabelText<'b>

Maps e to a label that will be used in the rendered output. The label need not be unique, and may be the empty string; the default is in fact the empty string.

fn node_shape(&'a self, _node: &N) -> Option<LabelText<'a>>

Maps n to one of the graphviz shape names. If None is returned, no shape attribute is specified.

fn node_label(&'a self, n: &N) -> LabelText<'a>

Maps n to a label that will be used in the rendered output. The label need not be unique, and may be the empty string; the default is just the output from node_id.

fn node_style(&'a self, _n: &N) -> Style

Maps n to a style that will be used in the rendered output.

fn node_color(&'a self, _node: &N) -> Option<LabelText<'a>>

Maps n to one of the graphviz color names. If None is returned, no color attribute is specified.

fn edge_end_arrow(&'a self, _e: &E) -> Arrow

Maps e to arrow style that will be used on the end of an edge. Defaults to default arrow style.

fn edge_start_arrow(&'a self, _e: &E) -> Arrow

Maps e to arrow style that will be used on the end of an edge. Defaults to default arrow style.

fn edge_style(&'a self, _e: &E) -> Style

Maps e to a style that will be used in the rendered output.

fn edge_color(&'a self, _e: &E) -> Option<LabelText<'a>>

Maps e to one of the graphviz color names. If None is returned, no color attribute is specified.

fn kind(&self) -> Kind

The kind of graph, defaults to Kind::Digraph.