Attribute Macro conflagrate::dependency

#[dependency]

Defines a dependency that can be accessed from any node in the graph.

Dependencies are resources shared amongst all nodes in a graph. They can be interfaces to external processes or collections of data shared between disparate parts of the graph. Basically anything a node needs that isn’t provided directly by the preceding node should be provided as a dependency.

Providers

Async functions decorated with #[dependency] macro construct a dependency that shares the name of the function. The first time a node that declares that dependency is executed in a graph, the graph will call the provider function and store the returned object in the dependency cache. The cache is a hash map whose keys are the names of the provider functions and the values are the provided objects.

Shared Resources

Dependencies are only created the first time they are needed. Every node that names the same dependency gets the same object. Because multiple nodes can be running simultaneously on separate threads, nodes only receive the dependency as an immutable reference. If you need mutable access to the dependency, wrap it in a tokio::sync::Mutex.

Examples

use conflagrate::{dependency, graph, nodetype};
use tokio::sync::Mutex;

#[dependency]
async fn messages() -> Mutex<Vec<String>> {
    Mutex::<Vec<String>>::new(Vec::<String>::new())
}

#[nodetype]
pub async fn StoreMessage(messages: &Mutex<Vec<String>>) {
    messages.lock().await.push(String::from("Hello mutable storage!"));
}

#[nodetype]
async fn StoreAnotherMessage(messages: &Mutex<Vec<String>>) {
    messages.lock().await.push(String::from("Here's another message!"));
}

#[nodetype]
pub async fn PrintMessages(messages: &Mutex<Vec<String>>) {
    for msg in messages.lock().await.iter() {
        println!("{}", msg);
    }
}

graph!{
    digraph MessageGraph {
        store[type=StoreMessage, start=true];
        store_another[type=StoreAnotherMessage];
        print[type=PrintMessages];

        store -> store_another -> print;
    }
}

fn main() {
    MessageGraph::run(());
}

See Also

• nodetype – Macro for associating a function with a type of node. Reference types in input arguments are interpreted to be dependencies.