Struct Decode

pub struct Decode<T: Message + FromStr = String> {
    pub input: InputPort<Bytes>,
    pub output: OutputPort<T>,
    pub encoding: Encoding,
}

A block that decodes T messages from a byte stream.

Block Diagram

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

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

Sequence Diagram

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

    BlockA-->>Decode: Connect
    Decode-->>BlockB: Connect

    loop Decode process
        BlockA->>Decode: Message (Bytes)
        Decode->>Decode: Decode message
        Decode->>BlockB: Message
    end

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

Examples

Using the block in a system

System::build(|s| {
    let stdin = s.read_stdin();
    let message_decoder = s.decode_lines();
    let counter = s.count::<String>();
    let count_encoder = s.encode_lines();
    let stdout = s.write_stdout();
    s.connect(&stdin.output, &message_decoder.input);
    s.connect(&message_decoder.output, &counter.input);
    s.connect(&counter.count, &count_encoder.input);
    s.connect(&count_encoder.output, &stdout.input);
});

Running the block via the CLI

$ protoflow execute Decode encoding=text

$ protoflow execute Decode encoding=protobuf

Fields

input: InputPort<Bytes>

The input byte stream.

output: OutputPort<T>

The output message stream.

encoding: Encoding

A configuration parameter for how to decode messages.

Implementations

impl<T: Message + FromStr> Decode<T>

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

pub fn with_params( input: InputPort<Bytes>, output: OutputPort<T>, encoding: Option<Encoding>, ) -> Self

impl<T: Message + FromStr + 'static> Decode<T>

pub fn with_system(system: &System, encoding: Option<Encoding>) -> Self

Trait Implementations

impl<T: Message + FromStr> Block for Decode<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 + FromStr> BlockDescriptor for Decode<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 + FromStr> Clone for Decode<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Message + FromStr> MaybeLabeled for Decode<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 + FromStr> MaybeNamed for Decode<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 StdioSystem for Decode

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