floxide 3.2.2

A directed graph workflow system in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// examples/nested_workflow_example.rs
// Demonstrates nesting a workflow as a Node via a local CompositeNode in an example

use async_trait::async_trait;
use floxide::{workflow, CompositeNode, FloxideError, Node, Transition, Workflow, WorkflowCtx};

/// A simple node that doubles its input
#[derive(Clone, Debug)]
pub struct DoubleNode;
#[async_trait]
impl Node for DoubleNode {
    type Input = i32;
    type Output = i32;
    async fn process(
        &self,
        _ctx: &(),
        input: i32,
    ) -> Result<Transition<Self::Output>, FloxideError> {
        println!("DoubleNode: {} -> {}", input, input * 2);
        Ok(Transition::Next(input * 2))
    }
}

/// A simple node that adds 10
#[derive(Clone, Debug)]
pub struct AddTenNode;
#[async_trait]
impl Node for AddTenNode {
    type Input = i32;
    type Output = i32;
    async fn process(
        &self,
        _ctx: &(),
        input: i32,
    ) -> Result<Transition<Self::Output>, FloxideError> {
        println!("AddTenNode: {} -> {}", input, input + 10);
        Ok(Transition::Next(input + 10))
    }
}

// Define a sub-workflow: double then add ten
workflow! {
    pub struct InnerWorkflow {
        double: DoubleNode,
        addten: AddTenNode,
    }
    start = double;
    context = ();
    edges {
        double => { [ addten ] };
        addten => {};
    }
}

/// A final node that prints the result and finishes
#[derive(Clone, Debug)]
pub struct PrintNode;
#[async_trait]
impl Node for PrintNode {
    type Input = i32;
    type Output = ();
    async fn process(
        &self,
        _ctx: &(),
        input: i32,
    ) -> Result<Transition<Self::Output>, FloxideError> {
        println!("PrintNode: final output = {}", input);
        Ok(Transition::Next(()))
    }
}

// Outer workflow uses the CompositeNode to embed InnerWorkflow
workflow! {
    pub struct OuterWorkflow {
        sub: CompositeNode<(), InnerWorkflow>,
        print: PrintNode,
    }
    start = sub;
    context = ();
    edges {
        sub => { [ print ] };
        print => {};
    }
}

/// Runs the nested workflow with input 5 and returns Ok(()) if it succeeds
pub async fn run_nested_workflow_example() -> Result<(), Box<dyn std::error::Error>> {
    // Build the inner workflow and wrap it
    let inner = InnerWorkflow {
        double: DoubleNode,
        addten: AddTenNode,
    };
    let ctx = WorkflowCtx::new(());
    let wf = OuterWorkflow {
        sub: CompositeNode::new(inner, &ctx),
        print: PrintNode,
    };
    println!("Running nested workflow starting at 5:");
    wf.run(&ctx, 5).await?;
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();
    run_nested_workflow_example().await
}

#[cfg(test)]
mod tests {
    use super::*;
    #[tokio::test]
    async fn test_nested_workflow_example() {
        run_nested_workflow_example()
            .await
            .expect("nested workflow should run");
    }
}