Struct DataflowLayout 

pub struct DataflowLayout {
    pub inputs: HashSet<Uuid>,
    pub outputs: HashSet<Uuid>,
    pub queries: HashSet<Uuid>,
    pub queryables: HashSet<Uuid>,
    pub labels: HashMap<Uuid, String>,
    pub nodes: HashMap<Uuid, HashSet<Uuid>>,
}

Represents a flattened dataflow layout

Fields

inputs: HashSet<Uuid>

Inputs present in the dataflow

outputs: HashSet<Uuid>

Outputs present in the dataflow

queries: HashSet<Uuid>

Queries present in the dataflow

queryables: HashSet<Uuid>

Queryables present in the dataflow

labels: HashMap<Uuid, String>

Labels for nodes and IO, useful for debugging and visualization

nodes: HashMap<Uuid, HashSet<Uuid>>

Nodes representation with their IO, useful for debugging and visualization

Implementations

impl DataflowLayout

pub fn new() -> DataflowLayout

Creates a new empty dataflow layout

Examples found in repository

examples/service_flows.rs (line 5)

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(())
}

examples/simple_flows.rs (line 5)

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 async fn node<T>( &mut self, label: impl Into<String>, builder_function: impl AsyncFnOnce(&mut NodeIOBuilder) -> T, ) -> (NodeLayout, T)

Adds a new node to the dataflow layout, providing its label and a builder function for its IO. For convenience, the node layout is returned, together with the result of the builder function.

Examples found in repository

examples/service_flows.rs (lines 8-10)

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(())
}

examples/simple_flows.rs (lines 8-10)

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 label(&self, uuid: impl Into<Uuid>) -> String

Access the label of an entity in the dataflow layout (node, input, output, query, queryable)

pub fn build(self) -> Arc<DataflowLayout>

Build the dataflow layout by making it immutable and returning an Arc

Examples found in repository

examples/service_flows.rs (line 19)

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(())
}

examples/simple_flows.rs (line 25)

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(())
}

Trait Implementations

impl Debug for DataflowLayout

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for DataflowLayout

fn default() -> DataflowLayout

Returns the “default value” for a type.