Struct Encode

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

A block that encodes T messages to a byte stream.

Block Diagram

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

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

Sequence Diagram

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

    BlockA-->>Encode: Connect
    Encode-->>BlockB: Connect

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

    BlockA-->>Encode: Disconnect
    Encode-->>Encode.input: Close
    Encode-->>Encode.output: Close
    Encode-->>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 Encode encoding=text

$ protoflow execute Encode encoding=protobuf

Fields

input: InputPort<T>

The input message stream.

output: OutputPort<Bytes>

The output byte stream.

encoding: Encoding

A configuration parameter for how to encode messages.

Implementations

impl<T: Message + ToString> Encode<T>

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

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

impl<T: Message + ToString + 'static> Encode<T>

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

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Message + ToString> MaybeLabeled for Encode<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 + ToString> MaybeNamed for Encode<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 Encode

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