Struct Message 

pub struct Message { /* private fields */ }

Implementations

impl Message

pub fn topic(&self) -> &str

Examples found in repository

examples/pubsub.rs (line 24)

async fn main() {
    let test_topic = "test/topic1";
    // define client configuration
    let config = Config::new("localhost:2873")
        .set_timeout(Duration::from_secs(5))
        .build();
    // connect PSRT client
    let mut client = Client::connect(&config).await.expect("Failed to connect");
    // subscribe to the topic
    client.subscribe(test_topic.to_owned()).await.unwrap();
    // get data channel
    let data_channel = client.take_data_channel().unwrap();
    let receiver_fut = tokio::spawn(async move {
        // receive messages from the server
        while let Ok(message) = data_channel.recv().await {
            println!(
                "topic: {}, data: {}",
                message.topic(),
                message.data_as_str().unwrap()
            );
        }
    });
    for _ in 0..3 {
        // if required, check that the client is still connected
        assert!(client.is_connected());
        // publish a message
        client
            .publish(
                DEFAULT_PRIORITY,
                test_topic.to_owned(),
                "hello".as_bytes().to_vec(),
            )
            .await
            .unwrap();
        sleep(Duration::from_secs(1)).await;
    }
    client.bye().await.unwrap();
    receiver_fut.await.unwrap();
}

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

pub fn data_as_str(&self) -> Result<&str, Utf8Error>

Errors

Will return Err if data is unable to be parsed as utf8

Examples found in repository

examples/pubsub.rs (line 25)

async fn main() {
    let test_topic = "test/topic1";
    // define client configuration
    let config = Config::new("localhost:2873")
        .set_timeout(Duration::from_secs(5))
        .build();
    // connect PSRT client
    let mut client = Client::connect(&config).await.expect("Failed to connect");
    // subscribe to the topic
    client.subscribe(test_topic.to_owned()).await.unwrap();
    // get data channel
    let data_channel = client.take_data_channel().unwrap();
    let receiver_fut = tokio::spawn(async move {
        // receive messages from the server
        while let Ok(message) = data_channel.recv().await {
            println!(
                "topic: {}, data: {}",
                message.topic(),
                message.data_as_str().unwrap()
            );
        }
    });
    for _ in 0..3 {
        // if required, check that the client is still connected
        assert!(client.is_connected());
        // publish a message
        client
            .publish(
                DEFAULT_PRIORITY,
                test_topic.to_owned(),
                "hello".as_bytes().to_vec(),
            )
            .await
            .unwrap();
        sleep(Duration::from_secs(1)).await;
    }
    client.bye().await.unwrap();
    receiver_fut.await.unwrap();
}

pub fn from_buf(buf: &mut Vec<u8>, priority: u8) -> Result<Self, Error>

Errors

Will return Err on buffer parse errors

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.