Struct zenoh_flow_nodes::prelude::Inputs

pub struct Inputs { /* private fields */ }

The Inputs structure contains all the inputs created for a Sink or an Operator.

Each input is indexed by its port identifier: the name that was indicated in the descriptor of the node. These names are case sensitive and should be an exact match to what was written in the descriptor.

Zenoh-Flow provides two flavours of input: InputRaw and Input<T>. An Input<T> conveniently exposes instances of T while an InputRaw exposes messages, allowing to disregard the contained data.

The main way to interact with Inputs is through the take method.

Example

let input_raw = inputs.take("test raw")
    .expect("No input name 'test raw' found")
    .raw();

let input: Input<u64> = inputs.take("test typed")
    .expect("No input name 'test typed' found")
    .typed(
        |bytes| serde_json::from_slice(bytes).map_err(|e| anyhow!(e))
    );

Implementations

impl Inputs

pub fn insert(&mut self, port_id: PortId, rx: Receiver<LinkMessage>)

Insert the flume::Receiver in the Inputs, creating the entry if needed in the internal HashMap.

pub fn take(&mut self, port_id: impl AsRef<str>) -> Option<InputBuilder>

Returns an Input builder for the provided port_id, if an input was declared with this exact name in the descriptor of the node, otherwise returns None.

Usage

This builder can either produce a, typed, Input<T> or an InputRaw. The main difference between both is the type of data they expose: an Input<T> automatically tries to downcast or deserialize the data contained in the message to expose &T, while an InputRaw simply exposes a LinkMessage.

Typed

To obtain an Input<T> one must call typed and provide a deserialiser function. In the example below we rely on the serde_json crate to do the deserialisation.

let input: Input<u64> = inputs.take("test typed")
    .expect("No input name 'test typed' found")
    .typed(
        |bytes| serde_json::from_slice(bytes).map_err(|e| anyhow!(e))
    );

Raw

To obtain an InputRaw one must call raw.

let input_raw = inputs.take("test raw")
    .expect("No input name 'test raw' found")
    .raw();

Methods from Deref<Target = HashMap<PortId, Receiver<LinkMessage>>>

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

This number is a lower bound; the HashMap<K, V> might be able to hold more, but is guaranteed to be able to hold at least this many.

Examples

use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

Examples

use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for key in map.keys() {
    println!("{key}");
}

Performance

In the current implementation, iterating over keys takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

Examples

use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for val in map.values() {
    println!("{val}");
}

Performance

In the current implementation, iterating over values takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

Examples

use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for (key, val) in map.iter() {
    println!("key: {key} val: {val}");
}

Performance

In the current implementation, iterating over map takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use std::collections::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use std::collections::HashMap;

let mut a = HashMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

Examples

use std::collections::HashMap;
use std::hash::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);

pub fn contains_key<Q>(&self, k: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

pub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, S>

🔬This is a nightly-only experimental API. (hash_raw_entry)

Creates a raw immutable entry builder for the HashMap.

Raw entries provide the lowest level of control for searching and manipulating a map. They must be manually initialized with a hash and then manually searched.

This is useful for

• Hash memoization
• Using a search key that doesn’t work with the Borrow trait
• Using custom comparison logic without newtype wrappers

Unless you are in such a situation, higher-level and more foolproof APIs like get should be preferred.

Immutable raw entries have very limited use; you might instead want raw_entry_mut.

Trait Implementations

impl Default for Inputs

fn default() -> Inputs

Returns the “default value” for a type.

impl Deref for Inputs

type Target = HashMap<PortId, Receiver<LinkMessage>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.