rusmpp_core/pdus/owned/
query_sm_resp.rs

1use rusmpp_macros::Rusmpp;
2
3use crate::{
4    pdus::owned::Pdu,
5    types::owned::{COctetString, EmptyOrFullCOctetString},
6    values::*,
7};
8
9#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Rusmpp)]
10#[rusmpp(decode = owned, test = skip)]
11#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
12#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
13#[cfg_attr(feature = "serde-deserialize-unchecked", derive(::serde::Deserialize))]
14pub struct QuerySmResp {
15    /// MC Message ID of the message whose
16    /// state is being queried.
17    pub message_id: COctetString<1, 65>,
18    /// Date and time when the queried
19    /// message reached a final state. For
20    /// messages, which have not yet reached
21    /// a final state, this field will contain a
22    /// single NULL octet.
23    pub final_date: EmptyOrFullCOctetString<17>,
24    /// Specifies the status of the queried short
25    /// message.
26    pub message_state: MessageState,
27    /// Where appropriate this holds a network
28    /// error code defining the reason for failure
29    /// of message delivery.
30    ///
31    /// The range of values returned depends
32    /// on the underlying telecommunications
33    /// network.
34    pub error_code: u8,
35}
36
37impl QuerySmResp {
38    pub fn new(
39        message_id: COctetString<1, 65>,
40        final_date: EmptyOrFullCOctetString<17>,
41        message_state: MessageState,
42        error_code: u8,
43    ) -> Self {
44        Self {
45            message_id,
46            final_date,
47            message_state,
48            error_code,
49        }
50    }
51
52    pub fn builder() -> QuerySmRespBuilder {
53        QuerySmRespBuilder::new()
54    }
55}
56
57impl From<QuerySmResp> for Pdu {
58    fn from(value: QuerySmResp) -> Self {
59        Self::QuerySmResp(value)
60    }
61}
62
63#[derive(Debug, Default)]
64pub struct QuerySmRespBuilder {
65    inner: QuerySmResp,
66}
67
68impl QuerySmRespBuilder {
69    pub fn new() -> Self {
70        Self::default()
71    }
72
73    pub fn message_id(mut self, message_id: COctetString<1, 65>) -> Self {
74        self.inner.message_id = message_id;
75        self
76    }
77
78    pub fn final_date(mut self, final_date: EmptyOrFullCOctetString<17>) -> Self {
79        self.inner.final_date = final_date;
80        self
81    }
82
83    pub fn message_state(mut self, message_state: MessageState) -> Self {
84        self.inner.message_state = message_state;
85        self
86    }
87
88    pub fn error_code(mut self, error_code: u8) -> Self {
89        self.inner.error_code = error_code;
90        self
91    }
92
93    pub fn build(self) -> QuerySmResp {
94        self.inner
95    }
96}
97
98#[cfg(test)]
99mod tests {
100    use std::str::FromStr;
101
102    use crate::tests::TestInstance;
103
104    use super::*;
105
106    impl TestInstance for QuerySmResp {
107        fn instances() -> alloc::vec::Vec<Self> {
108            alloc::vec![
109                Self::default(),
110                Self::builder()
111                    .message_id(COctetString::from_str("123456789012345678901234").unwrap())
112                    .final_date(
113                        EmptyOrFullCOctetString::from_static_slice(b"2023-10-01T12:00\0").unwrap()
114                    )
115                    .message_state(MessageState::Delivered)
116                    .error_code(0)
117                    .build(),
118            ]
119        }
120    }
121
122    #[test]
123    fn encode_decode() {
124        crate::tests::owned::encode_decode_test_instances::<QuerySmResp>();
125    }
126}