rustrade_integration/serde/se/
mod.rs

1use crate::serde::se::error::SeError;
2use serde::ser::SerializeSeq;
3use tracing::debug;
4
5pub mod error;
6
7/// Serialise a generic element T as a `Vec<T>`.
8pub fn se_element_to_vector<T, S>(element: T, serializer: S) -> Result<S::Ok, S::Error>
9where
10    S: serde::Serializer,
11    T: serde::Serialize,
12{
13    let mut sequence = serializer.serialize_seq(Some(1))?;
14    sequence.serialize_element(&element)?;
15    sequence.end()
16}
17
18/// JSON String serialiser.
19#[derive(Debug, Default)]
20pub struct SeJsonString;
21
22impl SeJsonString {
23    /// Serialises the input type into a valid JSON string.
24    pub fn se_string<T>(input: &T) -> Result<String, SeError>
25    where
26        T: std::fmt::Debug + serde::Serialize,
27    {
28        serde_json::to_string(input)
29            .map(|string| {
30                debug!(
31                    payload = %string,
32                    input_type = %std::any::type_name::<T>(),
33                    target_type = "String",
34                    "successfully serialised via Serde"
35                );
36                string
37            })
38            .map_err(|error| {
39                debug!(
40                    %error,
41                    payload = ?input,
42                    target_type = "String",
43                    "failed to serialise via SerDe"
44                );
45                SeError::Serde(error)
46            })
47    }
48}
49
50/// JSON bytes serialiser.
51#[derive(Debug, Default)]
52pub struct SeJsonBytes;
53
54impl SeJsonBytes {
55    /// Serialises the input type into valid JSON bytes.
56    pub fn se_bytes<T>(input: &T) -> Result<bytes::Bytes, SeError>
57    where
58        T: std::fmt::Debug + serde::Serialize,
59    {
60        serde_json::to_vec(input)
61            .map(|bytes| {
62                debug!(
63                    payload = %String::from_utf8_lossy(&bytes),
64                    input_type = %std::any::type_name::<T>(),
65                    target_type = "bytes::Bytes",
66                    "successfully serialised via Serde"
67                );
68                bytes::Bytes::from(bytes)
69            })
70            .map_err(|error| {
71                debug!(
72                    %error,
73                    payload = ?input,
74                    target_type = "bytes::Bytes",
75                    "failed to serialise via SerDe"
76                );
77                SeError::Serde(error)
78            })
79    }
80
81    /// Serialises the input type into the valid JSON byte writer.
82    pub fn se_bytes_writer<T>(writer: impl std::io::Write, input: &T) -> Result<(), SeError>
83    where
84        T: std::fmt::Debug + serde::Serialize,
85    {
86        serde_json::to_writer(writer, input)
87            .map(|_| {
88                debug!(
89                    payload = ?input,
90                    target_type = "std::io::Write",
91                    input_type = %std::any::type_name::<T>(),
92                    "successfully serialised to writer via Serde"
93                );
94            })
95            .map_err(|error| {
96                debug!(
97                    %error,
98                    payload = ?input,
99                    target_type = "std::io::Write",
100                    "failed to serialise to writer via SerDe"
101                );
102                SeError::Serde(error)
103            })
104    }
105}
106
107#[cfg(test)]
108#[allow(clippy::unwrap_used)] // Test code: panics on bad input are acceptable
109mod tests {
110    use super::*;
111
112    #[test]
113    fn test_se_json_string() {
114        let input = serde_json::json!({"key": "value"});
115        let result = SeJsonString::se_string(&input).unwrap();
116        assert_eq!(result, r#"{"key":"value"}"#);
117    }
118
119    #[test]
120    fn test_se_json_bytes() {
121        let input = serde_json::json!({"key": "value"});
122        let result = SeJsonBytes::se_bytes(&input).unwrap();
123        assert_eq!(result.as_ref(), br#"{"key":"value"}"#);
124    }
125
126    #[test]
127    fn test_se_json_bytes_writer() {
128        let input = serde_json::json!({"key": "value"});
129        let mut buf = Vec::new();
130        SeJsonBytes::se_bytes_writer(&mut buf, &input).unwrap();
131        assert_eq!(buf, br#"{"key":"value"}"#);
132    }
133
134    #[test]
135    fn test_se_element_to_vector() {
136        #[derive(serde::Serialize)]
137        struct Wrapper(#[serde(serialize_with = "se_element_to_vector")] u32);
138
139        let json = serde_json::to_string(&Wrapper(42)).unwrap();
140        assert_eq!(json, "[42]");
141    }
142}
rustrade_integration/serde/se/mod.rs

rustrade_integration/serde/se/
mod.rs
