azure_storage_blob/generated/models/
enums_serde.rs1use super::{
7 AccessTier, AccountKind, ArchiveStatus, BlobCopySourceTags, BlobDeleteType, BlobType,
8 BlockListType, CopyStatus, DeleteSnapshotsOptionType, EncryptionAlgorithmType,
9 FileShareTokenIntent, FilterBlobsIncludeItem, GeoReplicationStatusType, ImmutabilityPolicyMode,
10 LeaseDuration, LeaseState, LeaseStatus, ListBlobsIncludeItem, ListContainersIncludeType,
11 PremiumPageBlobAccessTier, PublicAccessType, RehydratePriority, SequenceNumberActionType,
12 SkuName, StorageErrorCode,
13};
14use serde::{Deserialize, Deserializer, Serialize, Serializer};
15
16impl<'de> Deserialize<'de> for AccessTier {
17 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
18 where
19 D: Deserializer<'de>,
20 {
21 let s = String::deserialize(deserializer)?;
22 s.parse().map_err(serde::de::Error::custom)
23 }
24}
25
26impl Serialize for AccessTier {
27 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
28 where
29 S: Serializer,
30 {
31 s.serialize_str(self.as_ref())
32 }
33}
34
35impl<'de> Deserialize<'de> for AccountKind {
36 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
37 where
38 D: Deserializer<'de>,
39 {
40 let s = String::deserialize(deserializer)?;
41 s.parse().map_err(serde::de::Error::custom)
42 }
43}
44
45impl Serialize for AccountKind {
46 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
47 where
48 S: Serializer,
49 {
50 s.serialize_str(self.as_ref())
51 }
52}
53
54impl<'de> Deserialize<'de> for ArchiveStatus {
55 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
56 where
57 D: Deserializer<'de>,
58 {
59 let s = String::deserialize(deserializer)?;
60 s.parse().map_err(serde::de::Error::custom)
61 }
62}
63
64impl Serialize for ArchiveStatus {
65 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
66 where
67 S: Serializer,
68 {
69 s.serialize_str(self.as_ref())
70 }
71}
72
73impl<'de> Deserialize<'de> for BlobCopySourceTags {
74 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
75 where
76 D: Deserializer<'de>,
77 {
78 let s = String::deserialize(deserializer)?;
79 s.parse().map_err(serde::de::Error::custom)
80 }
81}
82
83impl Serialize for BlobCopySourceTags {
84 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
85 where
86 S: Serializer,
87 {
88 s.serialize_str(self.as_ref())
89 }
90}
91
92impl<'de> Deserialize<'de> for BlobDeleteType {
93 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
94 where
95 D: Deserializer<'de>,
96 {
97 let s = String::deserialize(deserializer)?;
98 s.parse().map_err(serde::de::Error::custom)
99 }
100}
101
102impl Serialize for BlobDeleteType {
103 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
104 where
105 S: Serializer,
106 {
107 s.serialize_str(self.as_ref())
108 }
109}
110
111impl<'de> Deserialize<'de> for BlobType {
112 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
113 where
114 D: Deserializer<'de>,
115 {
116 let s = String::deserialize(deserializer)?;
117 s.parse().map_err(serde::de::Error::custom)
118 }
119}
120
121impl Serialize for BlobType {
122 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
123 where
124 S: Serializer,
125 {
126 s.serialize_str(self.as_ref())
127 }
128}
129
130impl<'de> Deserialize<'de> for BlockListType {
131 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
132 where
133 D: Deserializer<'de>,
134 {
135 let s = String::deserialize(deserializer)?;
136 s.parse().map_err(serde::de::Error::custom)
137 }
138}
139
140impl Serialize for BlockListType {
141 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
142 where
143 S: Serializer,
144 {
145 s.serialize_str(self.as_ref())
146 }
147}
148
149impl<'de> Deserialize<'de> for CopyStatus {
150 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
151 where
152 D: Deserializer<'de>,
153 {
154 let s = String::deserialize(deserializer)?;
155 s.parse().map_err(serde::de::Error::custom)
156 }
157}
158
159impl Serialize for CopyStatus {
160 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
161 where
162 S: Serializer,
163 {
164 s.serialize_str(self.as_ref())
165 }
166}
167
168impl<'de> Deserialize<'de> for DeleteSnapshotsOptionType {
169 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
170 where
171 D: Deserializer<'de>,
172 {
173 let s = String::deserialize(deserializer)?;
174 s.parse().map_err(serde::de::Error::custom)
175 }
176}
177
178impl Serialize for DeleteSnapshotsOptionType {
179 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
180 where
181 S: Serializer,
182 {
183 s.serialize_str(self.as_ref())
184 }
185}
186
187impl<'de> Deserialize<'de> for EncryptionAlgorithmType {
188 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
189 where
190 D: Deserializer<'de>,
191 {
192 let s = String::deserialize(deserializer)?;
193 s.parse().map_err(serde::de::Error::custom)
194 }
195}
196
197impl Serialize for EncryptionAlgorithmType {
198 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
199 where
200 S: Serializer,
201 {
202 s.serialize_str(self.as_ref())
203 }
204}
205
206impl<'de> Deserialize<'de> for FileShareTokenIntent {
207 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
208 where
209 D: Deserializer<'de>,
210 {
211 let s = String::deserialize(deserializer)?;
212 s.parse().map_err(serde::de::Error::custom)
213 }
214}
215
216impl Serialize for FileShareTokenIntent {
217 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
218 where
219 S: Serializer,
220 {
221 s.serialize_str(self.as_ref())
222 }
223}
224
225impl<'de> Deserialize<'de> for FilterBlobsIncludeItem {
226 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
227 where
228 D: Deserializer<'de>,
229 {
230 let s = String::deserialize(deserializer)?;
231 s.parse().map_err(serde::de::Error::custom)
232 }
233}
234
235impl Serialize for FilterBlobsIncludeItem {
236 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
237 where
238 S: Serializer,
239 {
240 s.serialize_str(self.as_ref())
241 }
242}
243
244impl<'de> Deserialize<'de> for GeoReplicationStatusType {
245 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
246 where
247 D: Deserializer<'de>,
248 {
249 let s = String::deserialize(deserializer)?;
250 s.parse().map_err(serde::de::Error::custom)
251 }
252}
253
254impl Serialize for GeoReplicationStatusType {
255 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
256 where
257 S: Serializer,
258 {
259 s.serialize_str(self.as_ref())
260 }
261}
262
263impl<'de> Deserialize<'de> for ImmutabilityPolicyMode {
264 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
265 where
266 D: Deserializer<'de>,
267 {
268 let s = String::deserialize(deserializer)?;
269 s.parse().map_err(serde::de::Error::custom)
270 }
271}
272
273impl Serialize for ImmutabilityPolicyMode {
274 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
275 where
276 S: Serializer,
277 {
278 s.serialize_str(self.as_ref())
279 }
280}
281
282impl<'de> Deserialize<'de> for LeaseDuration {
283 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
284 where
285 D: Deserializer<'de>,
286 {
287 let s = String::deserialize(deserializer)?;
288 s.parse().map_err(serde::de::Error::custom)
289 }
290}
291
292impl Serialize for LeaseDuration {
293 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
294 where
295 S: Serializer,
296 {
297 s.serialize_str(self.as_ref())
298 }
299}
300
301impl<'de> Deserialize<'de> for LeaseState {
302 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
303 where
304 D: Deserializer<'de>,
305 {
306 let s = String::deserialize(deserializer)?;
307 s.parse().map_err(serde::de::Error::custom)
308 }
309}
310
311impl Serialize for LeaseState {
312 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
313 where
314 S: Serializer,
315 {
316 s.serialize_str(self.as_ref())
317 }
318}
319
320impl<'de> Deserialize<'de> for LeaseStatus {
321 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
322 where
323 D: Deserializer<'de>,
324 {
325 let s = String::deserialize(deserializer)?;
326 s.parse().map_err(serde::de::Error::custom)
327 }
328}
329
330impl Serialize for LeaseStatus {
331 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
332 where
333 S: Serializer,
334 {
335 s.serialize_str(self.as_ref())
336 }
337}
338
339impl<'de> Deserialize<'de> for ListBlobsIncludeItem {
340 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
341 where
342 D: Deserializer<'de>,
343 {
344 let s = String::deserialize(deserializer)?;
345 s.parse().map_err(serde::de::Error::custom)
346 }
347}
348
349impl Serialize for ListBlobsIncludeItem {
350 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
351 where
352 S: Serializer,
353 {
354 s.serialize_str(self.as_ref())
355 }
356}
357
358impl<'de> Deserialize<'de> for ListContainersIncludeType {
359 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
360 where
361 D: Deserializer<'de>,
362 {
363 let s = String::deserialize(deserializer)?;
364 s.parse().map_err(serde::de::Error::custom)
365 }
366}
367
368impl Serialize for ListContainersIncludeType {
369 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
370 where
371 S: Serializer,
372 {
373 s.serialize_str(self.as_ref())
374 }
375}
376
377impl<'de> Deserialize<'de> for PremiumPageBlobAccessTier {
378 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
379 where
380 D: Deserializer<'de>,
381 {
382 let s = String::deserialize(deserializer)?;
383 s.parse().map_err(serde::de::Error::custom)
384 }
385}
386
387impl Serialize for PremiumPageBlobAccessTier {
388 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
389 where
390 S: Serializer,
391 {
392 s.serialize_str(self.as_ref())
393 }
394}
395
396impl<'de> Deserialize<'de> for PublicAccessType {
397 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
398 where
399 D: Deserializer<'de>,
400 {
401 let s = String::deserialize(deserializer)?;
402 s.parse().map_err(serde::de::Error::custom)
403 }
404}
405
406impl Serialize for PublicAccessType {
407 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
408 where
409 S: Serializer,
410 {
411 s.serialize_str(self.as_ref())
412 }
413}
414
415impl<'de> Deserialize<'de> for RehydratePriority {
416 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
417 where
418 D: Deserializer<'de>,
419 {
420 let s = String::deserialize(deserializer)?;
421 s.parse().map_err(serde::de::Error::custom)
422 }
423}
424
425impl Serialize for RehydratePriority {
426 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
427 where
428 S: Serializer,
429 {
430 s.serialize_str(self.as_ref())
431 }
432}
433
434impl<'de> Deserialize<'de> for SequenceNumberActionType {
435 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
436 where
437 D: Deserializer<'de>,
438 {
439 let s = String::deserialize(deserializer)?;
440 s.parse().map_err(serde::de::Error::custom)
441 }
442}
443
444impl Serialize for SequenceNumberActionType {
445 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
446 where
447 S: Serializer,
448 {
449 s.serialize_str(self.as_ref())
450 }
451}
452
453impl<'de> Deserialize<'de> for SkuName {
454 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
455 where
456 D: Deserializer<'de>,
457 {
458 let s = String::deserialize(deserializer)?;
459 s.parse().map_err(serde::de::Error::custom)
460 }
461}
462
463impl Serialize for SkuName {
464 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
465 where
466 S: Serializer,
467 {
468 s.serialize_str(self.as_ref())
469 }
470}
471
472impl<'de> Deserialize<'de> for StorageErrorCode {
473 fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
474 where
475 D: Deserializer<'de>,
476 {
477 let s = String::deserialize(deserializer)?;
478 s.parse().map_err(serde::de::Error::custom)
479 }
480}
481
482impl Serialize for StorageErrorCode {
483 fn serialize<S>(&self, s: S) -> ::core::result::Result<S::Ok, S::Error>
484 where
485 S: Serializer,
486 {
487 s.serialize_str(self.as_ref())
488 }
489}