azure_storage_blob/generated/models/
models_serde.rs1use 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}