Struct Flows

pub struct Flows {
    pub inputs_receivers: Arc<Mutex<HashMap<Uuid, MessageReceiver>>>,
    pub outputs_senders: Arc<Mutex<HashMap<Uuid, Vec<MessageSender>>>>,
    pub queries_senders: Arc<Mutex<HashMap<Uuid, MessageSender>>>,
    pub queries_receivers: Arc<Mutex<HashMap<Uuid, MessageReceiver>>>,
    pub queryables_senders: Arc<Mutex<HashMap<Uuid, HashMap<Uuid, MessageSender>>>>,
    pub queryables_receivers: Arc<Mutex<HashMap<Uuid, MessageReceiver>>>,
}

Represents the collection of flows in the system (all the MPSC channels)

Fields

inputs_receivers: Arc<Mutex<HashMap<Uuid, MessageReceiver>>>

outputs_senders: Arc<Mutex<HashMap<Uuid, Vec<MessageSender>>>>

queries_senders: Arc<Mutex<HashMap<Uuid, MessageSender>>>

queries_receivers: Arc<Mutex<HashMap<Uuid, MessageReceiver>>>

queryables_senders: Arc<Mutex<HashMap<Uuid, HashMap<Uuid, MessageSender>>>>

queryables_receivers: Arc<Mutex<HashMap<Uuid, MessageReceiver>>>

Implementations

impl Flows

pub async fn new( layout: Arc<DataflowLayout>, flows: impl AsyncFnOnce(&mut FlowsBuilder) -> Result<()>, ) -> Result<Self>

Creates a new Flows instance with a Building async closure

Examples found in repository

examples/service_flows.rs (lines 23-27)

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 29-34)

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 node_io( &self, clock: Arc<HLC>, source: NodeLayout, ) -> (Inputs, Outputs, Queries, Queryables)

This is intended to be used only by the Runtime when loading nodes

Trait Implementations

impl Clone for Flows

fn clone(&self) -> Flows

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Flows

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

Formats the value using the given formatter.