rosrust/rosxmlrpc/
response_info.rs

1use super::{Response, ResponseError, ERROR_CODE, FAILURE_CODE, SUCCESS_CODE};
2use xml_rpc::{self, Value};
3
4pub struct ResponseInfo {
5    pub code: i32,
6    pub message: String,
7    pub data: Value,
8}
9
10impl ResponseInfo {
11    #[inline]
12    pub fn new(code: i32, message: String, data: Value) -> Self {
13        Self {
14            code,
15            message,
16            data,
17        }
18    }
19
20    #[inline]
21    pub fn from_array(parameters: &[Value]) -> Response<Self> {
22        match *parameters {
23            [Value::Int(code), Value::String(ref message), ref data] => Ok(Self::new(code, message.clone(), data.clone())),
24            _ => Err(ResponseError::Server(format!(
25                "Response with three parameters (int code, str msg, value) expected from server, received: {:?}",
26                parameters
27            ))),
28        }
29    }
30
31    #[inline]
32    pub fn from_response(response: Response<Value>, message: &str) -> Self {
33        match response {
34            Ok(data) => Self::from_response_success(data, message),
35            Err(err) => Self::from_response_error(err),
36        }
37    }
38
39    #[inline]
40    pub fn from_response_error(err: ResponseError) -> Self {
41        match err {
42            ResponseError::Client(msg) => Self::from_client_error(msg),
43            ResponseError::Server(msg) => Self::from_server_error(msg),
44        }
45    }
46
47    #[inline]
48    pub fn from_client_error(message: String) -> Self {
49        Self::new(ERROR_CODE, message, Value::Int(0))
50    }
51
52    #[inline]
53    pub fn from_server_error(message: String) -> Self {
54        Self::new(FAILURE_CODE, message, Value::Int(0))
55    }
56
57    #[inline]
58    pub fn from_response_success(data: Value, message: &str) -> Self {
59        Self::new(SUCCESS_CODE, message.to_owned(), data)
60    }
61}
62
63impl From<ResponseInfo> for xml_rpc::Response {
64    fn from(src: ResponseInfo) -> xml_rpc::Response {
65        let code = Value::Int(src.code);
66        let message = Value::String(src.message);
67        Ok(vec![Value::Array(vec![code, message, src.data])])
68    }
69}
70
71impl From<ResponseInfo> for Response<Value> {
72    fn from(src: ResponseInfo) -> Response<Value> {
73        match src.code {
74            SUCCESS_CODE => Ok(src.data),
75            ERROR_CODE => Err(ResponseError::Client(src.message)),
76            FAILURE_CODE => Err(ResponseError::Server(src.message)),
77            _ => Err(ResponseError::Server(format!(
78                "Bad response code \"{}\" returned from server",
79                src.code
80            ))),
81        }
82    }
83}