azure_sdk_cosmos/
to_json_vector.rs

1use azure_sdk_core::errors::AzureError;
2use serde::ser::Serialize;
3use std::borrow::Cow;
4
5#[derive(Debug, Clone, PartialEq, PartialOrd)]
6pub struct ToJsonVector {
7    last_serialized_string: Option<String>,
8    serialized_string: String,
9}
10
11impl ToJsonVector {
12    pub fn new() -> Self {
13        Self {
14            last_serialized_string: None,
15            serialized_string: String::from("["),
16        }
17    }
18
19    // this hack builds the json by hands, concatenating the single json
20    // serialization of the items. Ideally we should collect the &dyn Serialize
21    // trait objects and serialize in one shot at the end but unfortunately
22    // Serialize cannot be made a trait object so no dynamic dispatch :(
23    pub fn push<T>(&mut self, t: T) -> Result<&mut Self, AzureError>
24    where
25        T: Serialize,
26    {
27        if self.serialized_string.len() > 1 {
28            self.serialized_string.push_str(", ");
29        }
30
31        let serialized_string = serde_json::to_string(&t)?;
32        self.serialized_string.push_str(&serialized_string);
33        self.last_serialized_string = Some(serialized_string);
34
35        Ok(self)
36    }
37
38    pub(crate) fn to_json(&self) -> String {
39        format!("{}]", self.serialized_string)
40    }
41
42    #[allow(dead_code)]
43    pub(crate) fn last_serialized_string(&self) -> Option<&str> {
44        match self.last_serialized_string.as_ref() {
45            Some(last_serialized_str) => Some(last_serialized_str),
46            None => None,
47        }
48    }
49}
50
51impl std::default::Default for ToJsonVector {
52    fn default() -> Self {
53        Self::new()
54    }
55}
56
57impl<T> std::convert::TryFrom<&[T]> for ToJsonVector
58where
59    T: Serialize,
60{
61    type Error = AzureError;
62
63    fn try_from(slice: &[T]) -> Result<Self, Self::Error> {
64        let mut to_json_vector = ToJsonVector::new();
65        for item in slice {
66            to_json_vector.push(item)?;
67        }
68        Ok(to_json_vector)
69    }
70}
71
72impl<T> std::convert::TryFrom<&Vec<T>> for ToJsonVector
73where
74    T: Serialize,
75{
76    type Error = AzureError;
77
78    fn try_from(v: &Vec<T>) -> Result<Self, Self::Error> {
79        let mut to_json_vector = ToJsonVector::new();
80        for item in v {
81            to_json_vector.push(item)?;
82        }
83        Ok(to_json_vector)
84    }
85}
86
87impl std::convert::From<&str> for ToJsonVector {
88    fn from(t: &str) -> Self {
89        let mut pk = Self::new();
90        let _ = pk.push(t).unwrap();
91        pk
92    }
93}
94
95impl std::convert::From<Cow<'_, str>> for ToJsonVector {
96    fn from(t: Cow<'_, str>) -> Self {
97        let mut pk = Self::new();
98        let _ = pk.push(t).unwrap();
99        pk
100    }
101}
102
103impl std::convert::From<&Cow<'_, str>> for ToJsonVector {
104    fn from(t: &Cow<'_, str>) -> Self {
105        let mut pk = Self::new();
106        let _ = pk.push(t).unwrap();
107        pk
108    }
109}
110
111impl std::convert::From<&String> for ToJsonVector {
112    fn from(t: &String) -> Self {
113        let mut pk = Self::new();
114        let _ = pk.push(t).unwrap();
115        pk
116    }
117}
118
119impl std::convert::From<u64> for ToJsonVector {
120    fn from(t: u64) -> Self {
121        let mut pk = Self::new();
122        let _ = pk.push(t).unwrap();
123        pk
124    }
125}
126
127impl std::convert::From<i64> for ToJsonVector {
128    fn from(t: i64) -> Self {
129        let mut pk = Self::new();
130        let _ = pk.push(t).unwrap();
131        pk
132    }
133}
134
135impl<'a> std::convert::From<ToJsonVector> for Cow<'a, ToJsonVector> {
136    fn from(t: ToJsonVector) -> Self {
137        Cow::Owned(t)
138    }
139}
140
141impl<'a> std::convert::From<&'a ToJsonVector> for Cow<'a, ToJsonVector> {
142    fn from(t: &'a ToJsonVector) -> Self {
143        Cow::Borrowed(t)
144    }
145}
146
147#[cfg(test)]
148mod tests {
149    use super::*;
150    use std::convert::TryInto;
151
152    #[test]
153    fn serialize() {
154        let owned = "owned".to_owned();
155
156        let serialized = ToJsonVector::new()
157            .push("aaa")
158            .unwrap()
159            .push(&owned)
160            .unwrap()
161            .push(100u64)
162            .unwrap()
163            .to_json();
164        assert_eq!(serialized, "[\"aaa\", \"owned\", 100]");
165
166        let mut vector = vec!["pollo", "arrosto"];
167        let to_json_vector: ToJsonVector = (&vector).try_into().unwrap();
168        assert_eq!(to_json_vector.to_json(), "[\"pollo\", \"arrosto\"]");
169
170        vector.push("limone");
171        let slice: &[&str] = &vector;
172        let to_json_vector: ToJsonVector = slice.try_into().unwrap();
173        assert_eq!(
174            to_json_vector.to_json(),
175            "[\"pollo\", \"arrosto\", \"limone\"]"
176        );
177    }
178}
azure_sdk_cosmos/to_json_vector.rs

azure_sdk_cosmos/
to_json_vector.rs
