Skip to main content

azure_storage_blob/generated/models/
models_serde.rs

1// Copyright (c) Microsoft Corporation. All rights reserved.
2// Licensed under the MIT License.
3//
4// Code generated by Microsoft (R) Rust Code Generator. DO NOT EDIT.
5
6use super::ObjectReplicationMetadata;
7use serde::{Deserialize, Serialize};
8use std::collections::HashMap;
9
10impl<'de> Deserialize<'de> for ObjectReplicationMetadata {
11    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
12    where
13        D: serde::Deserializer<'de>,
14    {
15        struct AdditionalPropertiesVisitor;
16        impl<'de> serde::de::Visitor<'de> for AdditionalPropertiesVisitor {
17            type Value = ObjectReplicationMetadata;
18            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
19                formatter.write_str("a ObjectReplicationMetadata struct definition")
20            }
21            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
22            where
23                A: serde::de::MapAccess<'de>,
24            {
25                let mut additional_properties = HashMap::new();
26                while let Some(key) = map.next_key::<String>()? {
27                    let value: String = map.next_value()?;
28                    additional_properties.insert(key, value);
29                }
30                let additional_properties = match additional_properties.len() {
31                    0 => None,
32                    _ => Some(additional_properties),
33                };
34                Ok(ObjectReplicationMetadata {
35                    additional_properties,
36                })
37            }
38        }
39        deserializer.deserialize_map(AdditionalPropertiesVisitor)
40    }
41}
42
43impl Serialize for ObjectReplicationMetadata {
44    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
45    where
46        S: serde::Serializer,
47    {
48        use serde::ser::SerializeMap;
49        let mut map = serializer.serialize_map(Some(match &self.additional_properties {
50            Some(additional_properties) => additional_properties.len(),
51            None => 0,
52        }))?;
53        if let Some(additional_properties) = &self.additional_properties {
54            for (k, v) in additional_properties {
55                map.serialize_entry(k, v)?;
56            }
57        }
58        map.end()
59    }
60}
61
62pub mod option_offset_date_time_rfc3339 {
63    #![allow(clippy::type_complexity)]
64    use azure_core::time::{parse_rfc3339, OffsetDateTime};
65    use serde::{Deserialize, Deserializer};
66    use std::result::Result;
67
68    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<OffsetDateTime>, D::Error>
69    where
70        D: Deserializer<'de>,
71    {
72        let to_deserialize = <Option<String>>::deserialize(deserializer)?;
73        match to_deserialize {
74            Some(to_deserialize) => {
75                let decoded0 = parse_rfc3339(&to_deserialize).map_err(serde::de::Error::custom)?;
76                Ok(Some(decoded0))
77            }
78            None => Ok(None),
79        }
80    }
81}
82
83pub mod option_offset_date_time_rfc3339_fixed_width {
84    #![allow(clippy::type_complexity)]
85    use azure_core::time::{parse_rfc3339, OffsetDateTime};
86    use serde::{Deserialize, Deserializer, Serialize, Serializer};
87    use std::{num::NonZero, result::Result};
88    use time::format_description::well_known::{iso8601, Iso8601};
89
90    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<OffsetDateTime>, D::Error>
91    where
92        D: Deserializer<'de>,
93    {
94        let to_deserialize = <Option<String>>::deserialize(deserializer)?;
95        match to_deserialize {
96            Some(to_deserialize) => {
97                let decoded0 = parse_rfc3339(&to_deserialize).map_err(serde::de::Error::custom)?;
98                Ok(Some(decoded0))
99            }
100            None => Ok(None),
101        }
102    }
103
104    pub fn serialize<S>(
105        to_serialize: &Option<OffsetDateTime>,
106        serializer: S,
107    ) -> Result<S::Ok, S::Error>
108    where
109        S: Serializer,
110    {
111        let format = Iso8601::<
112            {
113                iso8601::Config::DEFAULT
114                    .set_time_precision(iso8601::TimePrecision::Second {
115                        decimal_digits: NonZero::new(7),
116                    })
117                    .encode()
118            },
119        >;
120        if let Some(to_serialize) = to_serialize {
121            let encoded0 = to_serialize
122                .format(&format)
123                .map_err(serde::ser::Error::custom)?;
124            <Option<String>>::serialize(&Some(encoded0), serializer)
125        } else {
126            serializer.serialize_none()
127        }
128    }
129}
130
131pub mod option_vec_encoded_bytes_std {
132    #![allow(clippy::type_complexity)]
133    use azure_core::base64;
134    use serde::{Deserialize, Deserializer, Serialize, Serializer};
135    use std::result::Result;
136
137    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Vec<Vec<u8>>>, D::Error>
138    where
139        D: Deserializer<'de>,
140    {
141        let to_deserialize = <Option<Vec<String>>>::deserialize(deserializer)?;
142        match to_deserialize {
143            Some(to_deserialize) => {
144                let mut decoded0 = <Vec<Vec<u8>>>::new();
145                for v in to_deserialize {
146                    decoded0.push(base64::decode(v).map_err(serde::de::Error::custom)?);
147                }
148                Ok(Some(decoded0))
149            }
150            None => Ok(None),
151        }
152    }
153
154    pub fn serialize<S>(
155        to_serialize: &Option<Vec<Vec<u8>>>,
156        serializer: S,
157    ) -> Result<S::Ok, S::Error>
158    where
159        S: Serializer,
160    {
161        if let Some(to_serialize) = to_serialize {
162            let encoded0 = to_serialize.iter().map(base64::encode).collect();
163            <Option<Vec<String>>>::serialize(&Some(encoded0), serializer)
164        } else {
165            serializer.serialize_none()
166        }
167    }
168}