Struct Node 

pub struct Node { /* private fields */ }

Implementations

impl Node

pub async fn create_publisher<T: Sendable>( &self, topic: String, ) -> Result<Publisher<T>>

Examples found in repository

examples/sub.rs (line 13)

async fn main() -> anyhow::Result<()> {
    env_logger::init();

    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 10)

async fn main() -> anyhow::Result<()> {
    env_logger::init();

    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 let Some(_) = useless_subber.next().await {
            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(())
}

pub async fn create_subscriber<T>( &self, topic: String, queue_size: usize, ) -> Result<Subscriber<T>>

where T: Send + Sync + 'static + Archive, T::Archived: for<'a> CheckBytes<HighValidator<'a, Error>> + Deserialize<T, Strategy<Pool, Error>>,

Examples found in repository

examples/sub.rs (line 10)

async fn main() -> anyhow::Result<()> {
    env_logger::init();

    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 13)

async fn main() -> anyhow::Result<()> {
    env_logger::init();

    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 let Some(_) = useless_subber.next().await {
            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(())
}

pub async fn create(name: String) -> Result<Self>

Examples found in repository

examples/sub.rs (line 8)

async fn main() -> anyhow::Result<()> {
    env_logger::init();

    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 8)

async fn main() -> anyhow::Result<()> {
    env_logger::init();

    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 let Some(_) = useless_subber.next().await {
            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 Debug for Node

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

Formats the value using the given formatter.