Struct safe_drive::service::client::ClientRecv

source ·

pub struct ClientRecv<T> { /* private fields */ }

Expand description

Receiver to receive a response.

Implementations§

source §

impl<T: ServiceMsg> ClientRecv<T>

source

pub fn try_recv( self ) -> RecvResult<(Client<T>, <T as ServiceMsg>::Response, Header), Self>

Receive a message. try_recv is a non-blocking function, and this returns RecvResult::RetryLater(self). So, please retry later if this value is returned.

§Errors

RCLError::InvalidArgument if any arguments are invalid, or
RCLError::ClientInvalid if the client is invalid, or
RCLError::Error if an unspecified error occurs.

source

pub fn recv(self) -> AsyncReceiver<T> ⓘ

Receive a response asynchronously. this returns super::Header including some information together.

§Example

use safe_drive::{
    logger::Logger, msg::common_interfaces::std_srvs, pr_error, pr_info, pr_warn, service::client::Client,
};
use std::time::Duration;

async fn run_client(mut client: Client<std_srvs::srv::Empty>, logger: Logger) {
    let dur = Duration::from_millis(100);

    loop {
        let request = std_srvs::srv::EmptyRequest::new().unwrap();
        let mut receiver = client.send(&request).unwrap().recv();
        match async_std::future::timeout(dur, &mut receiver).await {
            Ok(Ok((c, response, header))) => {
                pr_info!(logger, "received: header = {:?}", header);
                client = c;
            }
            Ok(Err(e)) => {
                pr_error!(logger, "error: {e}");
                break;
            }
            Err(_) => {
                pr_warn!(logger, "timeout");
                client = receiver.give_up();
            }
        }
    }
}

§Errors

RCLError::InvalidArgument if any arguments are invalid, or
RCLError::ClientInvalid if the client is invalid, or
RCLError::Error if an unspecified error occurs.

source

pub fn recv_timeout( self, t: Duration, selector: &mut Selector ) -> RecvResult<(Client<T>, <T as ServiceMsg>::Response, Header), Self>

Receive a message.

§Example

use safe_drive::{
    error::DynError,
    logger::Logger,
    msg::common_interfaces::{std_msgs, std_srvs},
    pr_fatal,
    selector::Selector,
    service::client::Client,
    topic::subscriber::Subscriber,
    RecvResult,
};
use std::time::Duration;

fn worker(
    mut selector: Selector,
    mut selector_client: Selector,
    subscriber: Subscriber<std_msgs::msg::Empty>,
    client: Client<std_srvs::srv::Empty>,
) -> Result<(), DynError> {
    let mut client = Some(client);
    let logger = Logger::new("listen_client");

    selector.add_subscriber(
        subscriber,
        Box::new(move |_msg| {
            // Take the client.
            let c = client.take().unwrap();

            let request = std_srvs::srv::EmptyRequest::new().unwrap();

            // Send a request.
            let receiver = c.send(&request).unwrap();

            // Receive a response.
            match receiver.recv_timeout(Duration::from_millis(20), &mut selector_client) {
                RecvResult::Ok((c, _response, _header)) => client = Some(c),
                RecvResult::RetryLater(r) => client = Some(r.give_up()),
                RecvResult::Err(e) => {
                    pr_fatal!(logger, "{e}");
                    panic!()
                }
            }
        }),
    );

    loop {
        selector.wait()?;
    }
}