Struct ZenohBridge 

pub struct ZenohBridge<Tx, Rx>
where
    Tx: BridgeChannelSet + 'static,
    Rx: BridgeChannelSet + 'static,
    Tx::Id: Send + Sync + 'static,
    Rx::Id: Send + Sync + 'static,
{ /* private fields */ }

Trait Implementations

impl<Tx, Rx> CuBridge for ZenohBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, Tx::Id: Debug + Send + Sync + 'static, Rx::Id: Debug + Send + Sync + 'static,

type Tx = Tx

Outgoing channels (Copper -> external world).

type Rx = Rx

Incoming channels (external world -> Copper).

type Resources<'r> = ()

Resources required by the bridge.

fn new( config: Option<&ComponentConfig>, tx_channels: &[BridgeChannelConfig<<Self::Tx as BridgeChannelSet>::Id>], rx_channels: &[BridgeChannelConfig<<Self::Rx as BridgeChannelSet>::Id>], _resources: Self::Resources<'_>, ) -> CuResult<Self>

where Self: Sized,

Constructs a new bridge.

fn start(&mut self, _clock: &RobotClock) -> CuResult<()>

Called before the first send/receive cycle.

fn send<'a, Payload>( &mut self, _clock: &RobotClock, channel: &'static BridgeChannel<<Self::Tx as BridgeChannelSet>::Id, Payload>, msg: &CuMsg<Payload>, ) -> CuResult<()>

where Payload: CuMsgPayload + 'a,

Sends a message on the selected outbound channel.

fn receive<'a, Payload>( &mut self, clock: &RobotClock, channel: &'static BridgeChannel<<Self::Rx as BridgeChannelSet>::Id, Payload>, msg: &mut CuMsg<Payload>, ) -> CuResult<()>

where Payload: CuMsgPayload + 'a,

Receives a message from the selected inbound channel.

fn stop(&mut self, _clock: &RobotClock) -> CuResult<()>

Notifies the bridge that no more I/O will happen until a subsequent [start].

fn preprocess(&mut self, _clock: &RobotClock) -> Result<(), CuError>

Gives the bridge a chance to prepare buffers before I/O.

fn postprocess(&mut self, _clock: &RobotClock) -> Result<(), CuError>

Called once the send/receive pair completed.

impl<Tx, Rx> Freezable for ZenohBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, Tx::Id: Send + Sync + 'static, Rx::Id: Send + Sync + 'static,

fn freeze<E>(&self, encoder: &mut E) -> Result<(), EncodeError>

where E: Encoder,

This method is called by the framework when it wants to save the task state. The default implementation is to encode nothing (stateless). If you have a state, you need to implement this method.

fn thaw<D>(&mut self, _decoder: &mut D) -> Result<(), DecodeError>

where D: Decoder,

This method is called by the framework when it wants to restore the task to a specific state. Here it is similar to Decode but the framework will give you a new instance of the task (the new method will be called)

impl<Tx, Rx> TypePath for ZenohBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, Tx::Id: Send + Sync + 'static, Rx::Id: Send + Sync + 'static,

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>