Struct NodeIOBuilder 

pub struct NodeIOBuilder {
    pub layout: NodeLayout,
    pub inputs: HashSet<Uuid>,
    pub outputs: HashSet<Uuid>,
    pub queries: HashSet<Uuid>,
    pub queryables: HashSet<Uuid>,
    pub labels: HashMap<Uuid, String>,
}

This is the object passed to the user’s lambda function to build the node’s IO layout

Fields

layout: NodeLayout

The node layout this io builder is applied to

inputs: HashSet<Uuid>

The runtime only cares about input UUIDs

outputs: HashSet<Uuid>

The runtime only cares about output UUIDs

queries: HashSet<Uuid>

The runtime only cares about query UUIDs

queryables: HashSet<Uuid>

The runtime only cares about queryable UUIDs

labels: HashMap<Uuid, String>

Labels for the node’s IO, useful for debugging and visualization

Implementations

impl NodeIOBuilder

pub fn new(layout: &NodeLayout) -> NodeIOBuilder

pub fn input(&mut self, input: impl Into<String>) -> IOLayout

Creates a new input layout with the given label

Examples found in repository

examples/simple_flows.rs (line 15)

async fn main() -> Result<()> {
    let mut layout = DataflowLayout::new();

    let (_source, output) = layout
        .node("source", async |builder: &mut NodeIOBuilder| {
            builder.output("out")
        })
        .await;

    let (_operator, (op_in, op_out)) = layout
        .node("operator", async |builder: &mut NodeIOBuilder| {
            (builder.input("in"), builder.output("out"))
        })
        .await;

    let (_sink, input) = layout
        .node("sink", async |builder: &mut NodeIOBuilder| {
            builder.input("in")
        })
        .await;

    let layout = layout.build();

    let _flows = Flows::new(layout.clone(), async move |builder: &mut FlowsBuilder| {
        builder.connect(op_in, output, None)?;
        builder.connect(input, op_out, None)?;

        Ok(())
    })
    .await?;

    Ok(())
}

pub fn output(&mut self, output: impl Into<String>) -> IOLayout

Creates a new output layout with the given label

Examples found in repository

examples/simple_flows.rs (line 9)

async fn main() -> Result<()> {
    let mut layout = DataflowLayout::new();

    let (_source, output) = layout
        .node("source", async |builder: &mut NodeIOBuilder| {
            builder.output("out")
        })
        .await;

    let (_operator, (op_in, op_out)) = layout
        .node("operator", async |builder: &mut NodeIOBuilder| {
            (builder.input("in"), builder.output("out"))
        })
        .await;

    let (_sink, input) = layout
        .node("sink", async |builder: &mut NodeIOBuilder| {
            builder.input("in")
        })
        .await;

    let layout = layout.build();

    let _flows = Flows::new(layout.clone(), async move |builder: &mut FlowsBuilder| {
        builder.connect(op_in, output, None)?;
        builder.connect(input, op_out, None)?;

        Ok(())
    })
    .await?;

    Ok(())
}

pub fn query(&mut self, query: impl Into<String>) -> IOLayout

Creates a new query layout with the given label

Examples found in repository

examples/service_flows.rs (line 15)

async fn main() -> Result<()> {
    let mut layout = DataflowLayout::new();

    let (_service, queryable) = layout
        .node("service", async |builder: &mut NodeIOBuilder| {
            builder.queryable("queryable")
        })
        .await;

    let (_client, query) = layout
        .node("client", async |builder: &mut NodeIOBuilder| {
            builder.query("query")
        })
        .await;

    let layout = layout.build();

    let _flows = Flows::new(layout.clone(), async move |builder: &mut FlowsBuilder| {
        builder.connect(query, queryable, None)?;

        Ok(())
    })
    .await?;

    Ok(())
}

pub fn queryable(&mut self, queryable: impl Into<String>) -> IOLayout

Creates a new queryable layout with the given label

Examples found in repository

examples/service_flows.rs (line 9)

async fn main() -> Result<()> {
    let mut layout = DataflowLayout::new();

    let (_service, queryable) = layout
        .node("service", async |builder: &mut NodeIOBuilder| {
            builder.queryable("queryable")
        })
        .await;

    let (_client, query) = layout
        .node("client", async |builder: &mut NodeIOBuilder| {
            builder.query("query")
        })
        .await;

    let layout = layout.build();

    let _flows = Flows::new(layout.clone(), async move |builder: &mut FlowsBuilder| {
        builder.connect(query, queryable, None)?;

        Ok(())
    })
    .await?;

    Ok(())
}