Struct Subscriber 

pub struct Subscriber<T: Sendable> { /* private fields */ }

Implementations

impl<T: Sendable> Subscriber<T>

pub async fn next(&mut self) -> Option<T>

Examples found in repository

examples/sub.rs (line 36)

async fn main() -> anyhow::Result<()> {
    mt_sea::init_logging();

    let node = Node::create("node2".to_owned()).await?;
    let mut subber = node
        .create_subscriber::<msg::String>("/some_topic".to_owned(), 10)
        .await?;
    let pubber = node
        .create_publisher::<msg::String>("/another_topic".to_owned())
        .await?;
    let pubber2 = node
        .create_publisher::<msg::String>("/boring_topic".to_owned())
        .await?;

    let msg_out = msg::String {
        data: "sup".to_owned(),
    };

    let boring_msg = msg::String {
        data: "🙄".to_owned(),
    };

    let mut pubbing = tokio::time::interval(std::time::Duration::from_millis(4320));

    tokio::spawn(async move {
        loop {
            pubbing.tick().await;
            pubber2.publish(&boring_msg).await.unwrap();
        }
    });

    while let Some(msg) = subber.next().await {
        println!("Got: {}", &msg.data);
        pubber.publish(&msg_out).await.unwrap();
    }

    Ok(())
}

examples/pub.rs (line 27)

async fn main() -> anyhow::Result<()> {
    mt_sea::init_logging();

    let node = Node::create("node1".to_owned()).await?;
    let pubber = node
        .create_publisher::<msg::String>("/some_topic".to_owned())
        .await?;
    let mut subber = node
        .create_subscriber::<msg::String>("/another_topic".to_owned(), 10)
        .await?;
    let mut subber2 = node
        .create_subscriber::<msg::String>("/boring_topic".to_owned(), 10)
        .await?;
    let mut useless_subber = node
        .create_subscriber::<msg::String>("/nothing_here".to_owned(), 10)
        .await?;

    let msg = msg::String {
        data: "heyhio".to_owned(),
    };

    tokio::spawn(async move {
        while useless_subber.next().await.is_some() {
            log::error!("ehh.. no?");
        }
    });

    let mut pubbing = tokio::time::interval(std::time::Duration::from_secs(1));
    loop {
        tokio::select! {
            _ = pubbing.tick() => {
                pubber.publish(&msg).await?;
            }
            msg_in = subber.next() => {
                match msg_in {
                    Some(msg_in) => {
                        println!("Got: {}", msg_in.data);
                    },
                    None => {
                        break;
                    },
                }
            }
            msg_in = subber2.next() => {
                match msg_in {
                    Some(msg_in) => {
                        println!("Got: {}", msg_in.data);
                    },
                    None => {
                        break;
                    },
                }
            }
        }
    }

    Ok(())
}

Trait Implementations

impl<T: Debug + Sendable> Debug for Subscriber<T>

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

Formats the value using the given formatter.