Struct Count

pub struct Count<T: Message> {
    pub input: InputPort<T>,
    pub output: OutputPort<T>,
    pub count: OutputPort<u64>,
    /* private fields */
}

A block that counts the number of messages it receives, while optionally passing them through.

Block Diagram

block-beta
    columns 7
    Source space:2 Count space:2 Sink
    space:7
    space:7
    space:3 Result space:3
    Source-- "input" -->Count
    Count-- "output" -->Sink
    Count-- "count" -->Result

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

Sequence Diagram

sequenceDiagram
    autonumber
    participant BlockA as Another block
    participant Count.input as Count.input port
    participant Count as Count block
    participant Count.output as Count.output port
    participant BlockB as Another block
    participant Count.count as Count.count port
    participant BlockC as Another block

    BlockA-->>Count: Connect
    Count-->>BlockB: Connect

    loop Count process
        BlockA->>Count: Message
        Count->>Count: Increment counter
        Count->>BlockB: Message
    end

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

    Count-->>BlockC: Connect
    Count->>BlockC: Counter
    Count-->>Count.count: Close
    Count-->>BlockC: Disconnect

    %% TODO

Examples

Using the block in a system

System::build(|s| {
    let stdin = s.read_stdin();
    let line_decoder = s.decode_lines();
    let counter = s.count::<String>();
    let count_encoder = s.encode_lines();
    let stdout = s.write_stdout();
    s.connect(&stdin.output, &line_decoder.input);
    s.connect(&line_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 Count

Fields

input: InputPort<T>

The input message stream.

output: OutputPort<T>

The (optional) output target for the stream being passed through.

count: OutputPort<u64>

The output port for the message count.

Implementations

impl<T: Message> Count<T>

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

Trait Implementations

impl<T: Message> Block for Count<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 Count<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.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Message> Definition for Count<T>

fn is_variation(&self) -> bool

impl<T: Message> Element for Count<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> MaybeLabeled for Count<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 Count<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> Namespace for Count<T>

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

impl<T: Message> OccurrenceDefinition for Count<T>

fn is_individual(&self) -> bool

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

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

impl<T: Message> Type for Count<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> BlockDefinition for Count<T>

impl<T: Message> Class for Count<T>

impl<T: Message> Classifier for Count<T>

impl<T: Message> ItemDefinition for Count<T>

impl<T: Message> PartDefinition for Count<T>

impl<T: Message> Structure for Count<T>