Struct Component

pub struct Component<G> { /* private fields */ }

Storage the component infos:

• Id that indentify a component in a Flow,
• Type of component
• Traits needed to run (ComponentRunnable + Inputs + Outputs)

use rs_flow::prelude::*;
 
struct G;
 
#[outputs { out1 }]
#[inputs { in1, in2 }]
struct A;
 
assert_eq!(A.output("out1"), 0); // first output port
assert_eq!(A.input("in1"), 0); // first input port
assert_eq!(A.input("in2"), 1); // second input port
 
#[async_trait]
impl ComponentRunnable for A {
    type Global = G;
    async fn run(&self, ctx: &mut Ctx<Self::Global>) -> Result<Next> {
        return Ok(Next::Continue);
    }
}
let component1 = Component::new(1, A);   // Type::Lazy
let component2 = Component::eager(2, A); // Type::Eeager
 
assert_eq!(component1.ty(), Type::Lazy);
assert_eq!(component2.ty(), Type::Eager);
 
let c = Connection::by(component1.from("out1"), component2.to("in1"));
assert_eq!(Connection::new(1, 0, 2, 0), c);
 

Implementations

impl<G> Component<G>

pub fn new<T>(id: Id, data: T) -> Self

where T: ComponentRunnable<Global = G>,

Create a component with Type::Lazy

pub fn eager<T>(id: Id, data: T) -> Self

where T: ComponentRunnable<Global = G>,

Create a component with Type::Eager

pub fn id(&self) -> Id

Return id of component

pub fn ty(&self) -> Type

Return type of component

pub fn from(&self, label: &'static str) -> Point

Return a output point for connection

Panics

Panic if could not found a output port by a label

pub fn to(&self, label: &'static str) -> Point

Return a input point for connection

Panics

Panic if could not found a input port by a label