Struct Delay

pub struct Delay<T: Message = Any> {
    pub input: InputPort<T>,
    pub output: OutputPort<T>,
    pub delay: DelayType,
}

A block that passes messages through while delaying them by a fixed or random duration.

Block Diagram

block-beta
    columns 7
    Source space:2 Delay space:2 Sink
    Source-- "input" -->Delay
    Delay-- "output" -->Sink

    classDef block height:48px,padding:8px;
    classDef hidden visibility:none;
    class Delay block
    class Source hidden
    class Sink hidden

Sequence Diagram

sequenceDiagram
    autonumber
    participant BlockA as Another block
    participant Delay.input as Delay.input port
    participant Delay as Delay block
    participant Delay.output as Delay.output port
    participant BlockB as Another block

    BlockA-->>Delay: Connect
    Delay-->>BlockB: Connect

    loop Delay process
        BlockA->>Delay: Message
        Delay->>Delay: Sleep
        Delay->>BlockB: Message
    end

    BlockA-->>Delay: Disconnect
    Delay-->>Delay.input: Close
    Delay-->>Delay.output: Close
    Delay-->>BlockB: Disconnect

Examples

Using the block in a system

System::build(|s| {
    let stdin = s.read_stdin();
    let line_decoder = s.decode_lines();
    let delay = Duration::from_secs(1);
    let delayer = s.delay_by_fixed::<String>(delay);
    let line_encoder = s.encode_lines();
    let stdout = s.write_stdout();
    s.connect(&stdin.output, &line_decoder.input);
    s.connect(&line_decoder.output, &delayer.input);
    s.connect(&delayer.output, &line_encoder.input);
    s.connect(&line_encoder.output, &stdout.input);
});

Running the block via the CLI

$ protoflow execute Delay fixed=2

$ protoflow execute Delay random=1..5

Fields

input: InputPort<T>

The input message stream.

output: OutputPort<T>

The output target for the stream being passed through.

delay: DelayType

A configuration parameter for which type of delay to add.

Implementations

impl<T: Message> Delay<T>

pub fn new(input: InputPort<T>, output: OutputPort<T>) -> Self

pub fn with_params( input: InputPort<T>, output: OutputPort<T>, delay: Option<DelayType>, ) -> Self

impl<T: Message + 'static> Delay<T>

pub fn with_system(system: &System, delay: Option<DelayType>) -> Self

Trait Implementations

impl<T: Message> Block for Delay<T>

fn execute(&mut self, runtime: &dyn BlockRuntime) -> BlockResult

Executes this block’s computation.

fn prepare(&mut self, _runtime: &dyn BlockRuntime) -> Result<(), BlockError>

Prepares this block for execution.

impl<T: Message> BlockDescriptor for Delay<T>

fn inputs(&self) -> Vec<PortDescriptor>

A description of this block’s input ports.

fn outputs(&self) -> Vec<PortDescriptor>

A description of this block’s output ports.

fn parameters(&self) -> Vec<ParameterDescriptor>

A description of this block’s parameters.

fn ports(&self) -> Vec<PortDescriptor>

A description of this block’s I/O ports.

impl<T: Clone + Message> Clone for Delay<T>

fn clone(&self) -> Delay<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Message> MaybeLabeled for Delay<T>

fn label(&self) -> Option<Cow<'_, str>>

Returns the human-readable label, if any, of the object.

fn is_labeled(&self) -> bool

Checks whether the object has a human-readable label.

impl<T: Message> MaybeNamed for Delay<T>

fn name(&self) -> Option<Cow<'_, str>>

Returns the name, if any, of the object.

fn is_named(&self) -> bool

Checks whether the object has a name.

impl<T: Message + FromStr + ToString + 'static> StdioSystem for Delay<T>

fn build_system(config: StdioConfig) -> Result<System, StdioError>