Struct protoflow_blocks::ReadEnv

pub struct ReadEnv<T: Message + FromStr = String> {
    pub name: InputPort<String>,
    pub output: OutputPort<T>,
}

A block that reads the value of an environment variable.

Block Diagram

block-beta
    columns 4
    Config space:3
    space:4
    space:4
    ReadEnv space:2 Sink
    Config-- "name" -->ReadEnv
    ReadEnv-- "output" -->Sink

    classDef block height:48px,padding:8px;
    classDef hidden visibility:none;
    class ReadEnv block
    class Config hidden
    class Sink hidden

Sequence Diagram

sequenceDiagram
    autonumber
    participant BlockA as Another block
    participant ReadEnv.name as ReadEnv.name port
    participant ReadEnv as ReadEnv block
    participant ReadEnv.output as ReadEnv.output port
    participant BlockB as Another block

    BlockA-->>ReadEnv: Connect

    BlockA->>ReadEnv: Message (e.g. "TERM")
    ReadEnv-->>ReadEnv.name: Close
    ReadEnv-->>BlockA: Disconnect
    ReadEnv-->>BlockB: Connect

    ReadEnv->>ReadEnv: Read environment variable
    ReadEnv->>BlockB: Message (e.g. "xterm-256color")

    ReadEnv-->>ReadEnv.output: Close
    ReadEnv-->>BlockB: Disconnect

Examples

Using the block in a system

System::build(|s| {
    let name_param = s.const_string("TERM");
    let env_reader = s.read_env();
    let line_encoder = s.encode_lines();
    let stdout = s.write_stdout();
    s.connect(&name_param.output, &env_reader.name);
    s.connect(&env_reader.output, &line_encoder.input);
    s.connect(&line_encoder.output, &stdout.input);
});

Running the block via the CLI

$ protoflow execute ReadEnv name=TERM

Fields

name: InputPort<String>

The name of the environment variable to read.

output: OutputPort<T>

The output message stream.

Implementations

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

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

Trait Implementations

impl<T: Message + FromStr> Block for ReadEnv<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 ReadEnv<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 name(&self) -> Option<String>

The machine-readable name of this block.

fn label(&self) -> Option<String>

A human-readable label for this block.

impl<T: Clone + Message + FromStr> Clone for ReadEnv<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Message + FromStr> Definition for ReadEnv<T>

fn is_variation(&self) -> bool

impl<T: Message + FromStr> Element for ReadEnv<T>

fn id(&self) -> Option<&str>

The unique element ID, if any.

fn alias_ids(&self) -> Vec<&str>

Various alternative identifiers for this Element.

fn name(&self) -> Option<&str>

The name of the element.

fn short_name(&self) -> Option<&str>

The short name of the element, if any.

fn is_library_element(&self) -> bool

Whether this Element is contained in the ownership tree of a library model.

fn owner(&self) -> Option<&dyn Element>

The owner of this Element, if any.

fn owning_namespace(&self) -> Option<&dyn Namespace>

The Namespace that owns this Element, if any.

fn owning_relationship(&self) -> Option<&dyn Relationship>

The Relationship for which this Element is an owned_related_element, if any.

fn qualified_name(&self) -> Option<QualifiedName>

impl<T: Message + FromStr> Namespace for ReadEnv<T>

fn names_of(&self, _element: &dyn Element) -> Vec<String>

impl<T: Message + FromStr> OccurrenceDefinition for ReadEnv<T>

fn is_individual(&self) -> bool

impl<T: Message + FromStr> StdioSystem for ReadEnv<T>

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

impl<T: Message + FromStr> Type for ReadEnv<T>

fn is_abstract(&self) -> bool

fn is_sufficient(&self) -> bool

fn is_conjugated(&self) -> bool

fn specializes(&self, _supertype: &Self) -> bool

impl<T: Message + FromStr> BlockDefinition for ReadEnv<T>

impl<T: Message + FromStr> Class for ReadEnv<T>

impl<T: Message + FromStr> Classifier for ReadEnv<T>

impl<T: Message + FromStr> ItemDefinition for ReadEnv<T>

impl<T: Message + FromStr> PartDefinition for ReadEnv<T>

impl<T: Message + FromStr> Structure for ReadEnv<T>