Struct safe_drive::service::server::Server

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

Server.

Implementations

impl<T: ServiceMsg> Server<T>

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

Receive a request. try_recv is a non-blocking function, and this returns RecvResult::RetryLater(self) if there is no available data. So, please retry later if this error is returned.

Return value

RecvResult::Ok((ServerSend<T>, <T as ServiceMsg>::Request, Header)) is returned. T is a type of the request and response. After receiving a request, ServerSend<T> can be used to send a response.

Example

use safe_drive::{
    logger::Logger, msg::common_interfaces::std_srvs, pr_error, pr_info, service::server::Server,
    RecvResult,
};

fn server_fn(mut server: Server<std_srvs::srv::Empty>, logger: Logger) {
    loop {
        match server.try_recv() {
            RecvResult::Ok((sender, request, header)) => {
                pr_info!(logger, "received: header = {:?}", header);
                let msg = std_srvs::srv::EmptyResponse::new().unwrap();
                match sender.send(&msg) {
                    Ok(s) => server = s,                  // Get a new server to handle next request.
                    Err((s, _e)) => server = s.give_up(), // Failed to send.
                }
            }
            RecvResult::RetryLater(s) => {
                pr_info!(logger, "retry later");
                server = s;
            }
            RecvResult::Err(e) => {
                pr_error!(logger, "error: {e}");
                break;
            }
        }
    }
}

Errors

• RCLError::InvalidArgument if any arguments are invalid, or
• RCLError::ServiceInvalid if the service is invalid, or
• RCLError::BadAlloc if allocating memory failed, or
• RCLError::Error if an unspecified error occurs.

pub async fn recv( self ) -> Result<(ServerSend<T>, <T as ServiceMsg>::Request, Header), DynError>

Receive a request asynchronously.

Return value

Ok((ServerSend<T>, <T as ServiceMsg>::Request, T1, Header)) is returned. T is a type of the request and response. After receiving a request, ServerSend<T> can be used to send a response.

Example

use safe_drive::{
    logger::Logger, msg::common_interfaces::std_srvs, pr_error, pr_info, service::server::Server,
};

async fn server_task(mut server: Server<std_srvs::srv::Empty>, logger: Logger) {
    loop {
        // Receive a request.
        let req = server.recv().await;
        match req {
            Ok((sender, request, header)) => {
                pr_info!(logger, "recv: header = {:?}", header);
                let response = std_srvs::srv::EmptyResponse::new().unwrap();
                match sender.send(&response) {
                    Ok(s) => server = s,                  // Get a new server to handle next request.
                    Err((s, _e)) => server = s.give_up(), // Failed to send.
                }
            }
            Err(e) => {
                pr_error!(logger, "error: {e}");
                return;
            }
        }
    }
}

Errors

• RCLError::InvalidArgument if any arguments are invalid, or
• RCLError::ServiceInvalid if the service is invalid, or
• RCLError::BadAlloc if allocating memory failed, or
• RCLError::Error if an unspecified error occurs.

Trait Implementations

impl<T> Send for Server<T>