Struct Listener 

pub struct Listener { /* private fields */ }

Listener attached to a Participant.

In the DDS entity hierarchy this composes SubscriberListener, PublisherListener, and TopicListener. When attached to a participant, entities created under it inherit any of the configured callbacks that apply to that entity type.

Examples

use cyclonedds::{Domain, Listener, Participant, Subscriber};

let domain = Domain::default();
let listener = Listener::new().with_subscriber(|subscriber_listener| {
    subscriber_listener
        .with_data_on_readers(|subscriber| println!("{subscriber:?} has data on readers"))
});
let participant = Participant::builder(&domain)
    .with_listener(&listener)
    .build()?;

// This subscriber inherits the callbacks set on the `participant` via the `listener`.
let subscriber = Subscriber::new(&participant)?;

// This subscriber will have the subscriber subset associated with the `listener` directly
// applied to it.
let subscriber = Subscriber::builder(&participant)
    .with_listener(&listener)
    .build()?;

Implementations

impl Listener

pub fn new() -> Self

Creates a new Listener with no callbacks registered.

Examples

use cyclonedds::Listener;

let listener = Listener::new();

pub fn with_subscriber( self, setter: fn(SubscriberListener) -> SubscriberListener, ) -> Self

Configures the SubscriberListener via a setter callback.

Examples

use cyclonedds::Listener;

let listener = Listener::new().with_subscriber(|s| {
    s.with_data_on_readers(|subscriber| {
        println!("data available on a reader");
    })
});

pub fn with_publisher( self, setter: fn(PublisherListener) -> PublisherListener, ) -> Self

Configures the PublisherListener via a setter callback.

Examples

This example does not compile because the PublisherListener does not have its with_writer::<T> setter yet. This is due to the fact that the higher-level listeners are untyped in <T> but the lower-level listeners are typed in <T> and a solution for crossing this boundary still needs to be worked out.

See the module-level warning for more detail.

use cyclonedds::Listener;

let listener = Listener::new().with_publisher(|p| {
    p.with_writer(|w| {
        w.with_publication_matched(|writer, publication_matched| {
            println!("{writer:?} has publication match: {publication_matched:?}")
        })
    })
});

Trait Implementations

impl AsRef<Listener> for Listener

fn as_ref(&self) -> &Listener

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<PublisherListener> for Listener

fn as_ref(&self) -> &PublisherListener

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<SubscriberListener> for Listener

fn as_ref(&self) -> &SubscriberListener

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Listener

fn clone(&self) -> Listener

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Listener

impl Debug for Listener

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Listener

fn default() -> Listener

Returns the “default value” for a type.