Struct Subscription 

pub struct Subscription<M, const RX_BUF: usize = { crate::config::DEFAULT_RX_BUF_SIZE }> { /* private fields */ }

Typed subscription handle with internal receive buffer.

Two methods, both byte-oriented at the wire:

• try_recv / recv — pull bytes from the backend, CDR-decode into M: RosMessage, hand back ownership of the typed message.
• try_recv_raw — copy bytes into the subscription’s internal buffer and return the length, leaving CDR decoding to the caller.

No typed borrow() exists. Borrow lives exclusively on RawSubscription. RecvView is &[u8] semantics; CDR decoding into a typed M requires owning the bytes (or running the decoder in place), which the borrow contract doesn’t fit. See docs/design/0010-zero-copy-raw-api.md decision D7.

Implementations

impl<M: RosMessage, const RX_BUF: usize> Subscription<M, RX_BUF>

pub fn try_recv(&mut self) -> Result<Option<M>, NodeError>

Try to receive a typed message (non-blocking).

pub fn try_recv_raw(&mut self) -> Result<Option<usize>, NodeError>

Try to receive raw CDR-encoded data (non-blocking).

pub fn buffer(&self) -> &[u8]

Get the receive buffer (valid after try_recv_raw).

pub fn supports_event(&self, kind: EventKind) -> bool

true if the active backend can fire the named event for this subscriber.

pub fn on_liveliness_changed<F>(&mut self, cb: F) -> Result<(), NodeError>

where F: FnMut(LivelinessChangedStatus) + Send + 'static,

Register a callback for LivelinessChanged. Fires when a tracked publisher’s liveliness state changes.

pub fn on_requested_deadline_missed<F>( &mut self, deadline: Duration, cb: F, ) -> Result<(), NodeError>

where F: FnMut(CountStatus) + Send + 'static,

Register a callback for RequestedDeadlineMissed. Fires when an expected sample doesn’t arrive within deadline.

pub fn on_message_lost<F>(&mut self, cb: F) -> Result<(), NodeError>

where F: FnMut(CountStatus) + Send + 'static,

Register a callback for MessageLost. Fires when the backend drops a sample (overflow, etc.).

pub fn has_data(&self) -> bool

Check if data is available without consuming it.

pub fn process_in_place( &mut self, f: impl FnOnce(&M), ) -> Result<bool, NodeError>

Process the received message in-place without copying.

pub async fn recv(&mut self) -> Result<M, NodeError>

Async: wait for the next message (no futures dependency needed).

Requires a background task running executor.spin_async() to drive I/O. Returns Ok(msg) on the next received message, or Err if the transport reports an error.

When the stream feature is enabled, prefer StreamExt::next() / TryStreamExt::try_next() for combinator support.

Example

let mut sub = node.create_subscription::<Int32>("/topic")?;
loop {
    let msg = sub.recv().await?;
    /* handle msg */
}

pub fn wait_next( &mut self, executor: &mut Executor, timeout: Duration, ) -> Result<Option<M>, NodeError>

Sync: wait for the next message, spinning the executor.

Returns Ok(Some(msg)) if a message arrives within timeout_ms, or Ok(None) on timeout. Unlike Promise::wait(), timeout is not an error — the caller typically retries in a loop.

Example

while let Some(msg) = sub.wait_next(&mut executor, core::time::Duration::from_millis(1000))? {
    /* handle msg */
}

Trait Implementations

impl<M, const RX_BUF: usize> Drop for Subscription<M, RX_BUF>

fn drop(&mut self)

Executes the destructor for this type.