1use 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 azure_core::error::{Error, ErrorKind};
15use std::{
16 convert::{AsRef, From, Infallible},
17 fmt::{Display, Formatter},
18 str::FromStr,
19};
20
21impl<'a> From<&'a AccessTier> for &'a str {
22 fn from(e: &'a AccessTier) -> Self {
23 match e {
24 AccessTier::Archive => "Archive",
25 AccessTier::Cold => "Cold",
26 AccessTier::Cool => "Cool",
27 AccessTier::Hot => "Hot",
28 AccessTier::P10 => "P10",
29 AccessTier::P15 => "P15",
30 AccessTier::P20 => "P20",
31 AccessTier::P30 => "P30",
32 AccessTier::P4 => "P4",
33 AccessTier::P40 => "P40",
34 AccessTier::P50 => "P50",
35 AccessTier::P6 => "P6",
36 AccessTier::P60 => "P60",
37 AccessTier::P70 => "P70",
38 AccessTier::P80 => "P80",
39 AccessTier::Premium => "Premium",
40 AccessTier::UnknownValue(s) => s.as_ref(),
41 }
42 }
43}
44
45impl FromStr for AccessTier {
46 type Err = Infallible;
47 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
48 Ok(match s {
49 "Archive" => AccessTier::Archive,
50 "Cold" => AccessTier::Cold,
51 "Cool" => AccessTier::Cool,
52 "Hot" => AccessTier::Hot,
53 "P10" => AccessTier::P10,
54 "P15" => AccessTier::P15,
55 "P20" => AccessTier::P20,
56 "P30" => AccessTier::P30,
57 "P4" => AccessTier::P4,
58 "P40" => AccessTier::P40,
59 "P50" => AccessTier::P50,
60 "P6" => AccessTier::P6,
61 "P60" => AccessTier::P60,
62 "P70" => AccessTier::P70,
63 "P80" => AccessTier::P80,
64 "Premium" => AccessTier::Premium,
65 _ => AccessTier::UnknownValue(s.to_string()),
66 })
67 }
68}
69
70impl AsRef<str> for AccessTier {
71 fn as_ref(&self) -> &str {
72 match self {
73 AccessTier::Archive => "Archive",
74 AccessTier::Cold => "Cold",
75 AccessTier::Cool => "Cool",
76 AccessTier::Hot => "Hot",
77 AccessTier::P10 => "P10",
78 AccessTier::P15 => "P15",
79 AccessTier::P20 => "P20",
80 AccessTier::P30 => "P30",
81 AccessTier::P4 => "P4",
82 AccessTier::P40 => "P40",
83 AccessTier::P50 => "P50",
84 AccessTier::P6 => "P6",
85 AccessTier::P60 => "P60",
86 AccessTier::P70 => "P70",
87 AccessTier::P80 => "P80",
88 AccessTier::Premium => "Premium",
89 AccessTier::UnknownValue(s) => s.as_str(),
90 }
91 }
92}
93
94impl Display for AccessTier {
95 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
96 match self {
97 AccessTier::Archive => f.write_str("Archive"),
98 AccessTier::Cold => f.write_str("Cold"),
99 AccessTier::Cool => f.write_str("Cool"),
100 AccessTier::Hot => f.write_str("Hot"),
101 AccessTier::P10 => f.write_str("P10"),
102 AccessTier::P15 => f.write_str("P15"),
103 AccessTier::P20 => f.write_str("P20"),
104 AccessTier::P30 => f.write_str("P30"),
105 AccessTier::P4 => f.write_str("P4"),
106 AccessTier::P40 => f.write_str("P40"),
107 AccessTier::P50 => f.write_str("P50"),
108 AccessTier::P6 => f.write_str("P6"),
109 AccessTier::P60 => f.write_str("P60"),
110 AccessTier::P70 => f.write_str("P70"),
111 AccessTier::P80 => f.write_str("P80"),
112 AccessTier::Premium => f.write_str("Premium"),
113 AccessTier::UnknownValue(s) => f.write_str(s.as_str()),
114 }
115 }
116}
117
118impl FromStr for AccountKind {
119 type Err = Error;
120 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
121 Ok(match s {
122 "BlobStorage" => AccountKind::BlobStorage,
123 "BlockBlobStorage" => AccountKind::BlockBlobStorage,
124 "FileStorage" => AccountKind::FileStorage,
125 "Storage" => AccountKind::Storage,
126 "StorageV2" => AccountKind::StorageV2,
127 _ => {
128 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
129 format!("unknown variant of AccountKind found: \"{s}\"")
130 }))
131 }
132 })
133 }
134}
135
136impl AsRef<str> for AccountKind {
137 fn as_ref(&self) -> &str {
138 match self {
139 AccountKind::BlobStorage => "BlobStorage",
140 AccountKind::BlockBlobStorage => "BlockBlobStorage",
141 AccountKind::FileStorage => "FileStorage",
142 AccountKind::Storage => "Storage",
143 AccountKind::StorageV2 => "StorageV2",
144 }
145 }
146}
147
148impl Display for AccountKind {
149 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
150 match self {
151 AccountKind::BlobStorage => Display::fmt("BlobStorage", f),
152 AccountKind::BlockBlobStorage => Display::fmt("BlockBlobStorage", f),
153 AccountKind::FileStorage => Display::fmt("FileStorage", f),
154 AccountKind::Storage => Display::fmt("Storage", f),
155 AccountKind::StorageV2 => Display::fmt("StorageV2", f),
156 }
157 }
158}
159
160impl<'a> From<&'a ArchiveStatus> for &'a str {
161 fn from(e: &'a ArchiveStatus) -> Self {
162 match e {
163 ArchiveStatus::RehydratePendingToCold => "rehydrate-pending-to-cold",
164 ArchiveStatus::RehydratePendingToCool => "rehydrate-pending-to-cool",
165 ArchiveStatus::RehydratePendingToHot => "rehydrate-pending-to-hot",
166 ArchiveStatus::UnknownValue(s) => s.as_ref(),
167 }
168 }
169}
170
171impl FromStr for ArchiveStatus {
172 type Err = Infallible;
173 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
174 Ok(match s {
175 "rehydrate-pending-to-cold" => ArchiveStatus::RehydratePendingToCold,
176 "rehydrate-pending-to-cool" => ArchiveStatus::RehydratePendingToCool,
177 "rehydrate-pending-to-hot" => ArchiveStatus::RehydratePendingToHot,
178 _ => ArchiveStatus::UnknownValue(s.to_string()),
179 })
180 }
181}
182
183impl AsRef<str> for ArchiveStatus {
184 fn as_ref(&self) -> &str {
185 match self {
186 ArchiveStatus::RehydratePendingToCold => "rehydrate-pending-to-cold",
187 ArchiveStatus::RehydratePendingToCool => "rehydrate-pending-to-cool",
188 ArchiveStatus::RehydratePendingToHot => "rehydrate-pending-to-hot",
189 ArchiveStatus::UnknownValue(s) => s.as_str(),
190 }
191 }
192}
193
194impl Display for ArchiveStatus {
195 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
196 match self {
197 ArchiveStatus::RehydratePendingToCold => f.write_str("rehydrate-pending-to-cold"),
198 ArchiveStatus::RehydratePendingToCool => f.write_str("rehydrate-pending-to-cool"),
199 ArchiveStatus::RehydratePendingToHot => f.write_str("rehydrate-pending-to-hot"),
200 ArchiveStatus::UnknownValue(s) => f.write_str(s.as_str()),
201 }
202 }
203}
204
205impl FromStr for BlobCopySourceTags {
206 type Err = Error;
207 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
208 Ok(match s {
209 "COPY" => BlobCopySourceTags::Copy,
210 "REPLACE" => BlobCopySourceTags::Replace,
211 _ => {
212 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
213 format!("unknown variant of BlobCopySourceTags found: \"{s}\"")
214 }))
215 }
216 })
217 }
218}
219
220impl AsRef<str> for BlobCopySourceTags {
221 fn as_ref(&self) -> &str {
222 match self {
223 BlobCopySourceTags::Copy => "COPY",
224 BlobCopySourceTags::Replace => "REPLACE",
225 }
226 }
227}
228
229impl Display for BlobCopySourceTags {
230 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
231 match self {
232 BlobCopySourceTags::Copy => Display::fmt("COPY", f),
233 BlobCopySourceTags::Replace => Display::fmt("REPLACE", f),
234 }
235 }
236}
237
238impl FromStr for BlobDeleteType {
239 type Err = Error;
240 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
241 Ok(match s {
242 "Permanent" => BlobDeleteType::Permanent,
243 _ => {
244 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
245 format!("unknown variant of BlobDeleteType found: \"{s}\"")
246 }))
247 }
248 })
249 }
250}
251
252impl AsRef<str> for BlobDeleteType {
253 fn as_ref(&self) -> &str {
254 match self {
255 BlobDeleteType::Permanent => "Permanent",
256 }
257 }
258}
259
260impl Display for BlobDeleteType {
261 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
262 match self {
263 BlobDeleteType::Permanent => Display::fmt("Permanent", f),
264 }
265 }
266}
267
268impl FromStr for BlobType {
269 type Err = Error;
270 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
271 Ok(match s {
272 "AppendBlob" => BlobType::AppendBlob,
273 "BlockBlob" => BlobType::BlockBlob,
274 "PageBlob" => BlobType::PageBlob,
275 _ => {
276 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
277 format!("unknown variant of BlobType found: \"{s}\"")
278 }))
279 }
280 })
281 }
282}
283
284impl AsRef<str> for BlobType {
285 fn as_ref(&self) -> &str {
286 match self {
287 BlobType::AppendBlob => "AppendBlob",
288 BlobType::BlockBlob => "BlockBlob",
289 BlobType::PageBlob => "PageBlob",
290 }
291 }
292}
293
294impl Display for BlobType {
295 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
296 match self {
297 BlobType::AppendBlob => Display::fmt("AppendBlob", f),
298 BlobType::BlockBlob => Display::fmt("BlockBlob", f),
299 BlobType::PageBlob => Display::fmt("PageBlob", f),
300 }
301 }
302}
303
304impl FromStr for BlockListType {
305 type Err = Error;
306 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
307 Ok(match s {
308 "all" => BlockListType::All,
309 "committed" => BlockListType::Committed,
310 "uncommitted" => BlockListType::Uncommitted,
311 _ => {
312 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
313 format!("unknown variant of BlockListType found: \"{s}\"")
314 }))
315 }
316 })
317 }
318}
319
320impl AsRef<str> for BlockListType {
321 fn as_ref(&self) -> &str {
322 match self {
323 BlockListType::All => "all",
324 BlockListType::Committed => "committed",
325 BlockListType::Uncommitted => "uncommitted",
326 }
327 }
328}
329
330impl Display for BlockListType {
331 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
332 match self {
333 BlockListType::All => Display::fmt("all", f),
334 BlockListType::Committed => Display::fmt("committed", f),
335 BlockListType::Uncommitted => Display::fmt("uncommitted", f),
336 }
337 }
338}
339
340impl FromStr for CopyStatus {
341 type Err = Error;
342 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
343 Ok(match s {
344 "aborted" => CopyStatus::Aborted,
345 "failed" => CopyStatus::Failed,
346 "pending" => CopyStatus::Pending,
347 "success" => CopyStatus::Success,
348 _ => {
349 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
350 format!("unknown variant of CopyStatus found: \"{s}\"")
351 }))
352 }
353 })
354 }
355}
356
357impl AsRef<str> for CopyStatus {
358 fn as_ref(&self) -> &str {
359 match self {
360 CopyStatus::Aborted => "aborted",
361 CopyStatus::Failed => "failed",
362 CopyStatus::Pending => "pending",
363 CopyStatus::Success => "success",
364 }
365 }
366}
367
368impl Display for CopyStatus {
369 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
370 match self {
371 CopyStatus::Aborted => Display::fmt("aborted", f),
372 CopyStatus::Failed => Display::fmt("failed", f),
373 CopyStatus::Pending => Display::fmt("pending", f),
374 CopyStatus::Success => Display::fmt("success", f),
375 }
376 }
377}
378
379impl FromStr for DeleteSnapshotsOptionType {
380 type Err = Error;
381 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
382 Ok(match s {
383 "include" => DeleteSnapshotsOptionType::Include,
384 "only" => DeleteSnapshotsOptionType::Only,
385 _ => {
386 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
387 format!("unknown variant of DeleteSnapshotsOptionType found: \"{s}\"")
388 }))
389 }
390 })
391 }
392}
393
394impl AsRef<str> for DeleteSnapshotsOptionType {
395 fn as_ref(&self) -> &str {
396 match self {
397 DeleteSnapshotsOptionType::Include => "include",
398 DeleteSnapshotsOptionType::Only => "only",
399 }
400 }
401}
402
403impl Display for DeleteSnapshotsOptionType {
404 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
405 match self {
406 DeleteSnapshotsOptionType::Include => Display::fmt("include", f),
407 DeleteSnapshotsOptionType::Only => Display::fmt("only", f),
408 }
409 }
410}
411
412impl FromStr for EncryptionAlgorithmType {
413 type Err = Error;
414 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
415 Ok(match s {
416 "AES256" => EncryptionAlgorithmType::Aes256,
417 _ => {
418 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
419 format!("unknown variant of EncryptionAlgorithmType found: \"{s}\"")
420 }))
421 }
422 })
423 }
424}
425
426impl AsRef<str> for EncryptionAlgorithmType {
427 fn as_ref(&self) -> &str {
428 match self {
429 EncryptionAlgorithmType::Aes256 => "AES256",
430 }
431 }
432}
433
434impl Display for EncryptionAlgorithmType {
435 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
436 match self {
437 EncryptionAlgorithmType::Aes256 => Display::fmt("AES256", f),
438 }
439 }
440}
441
442impl<'a> From<&'a FileShareTokenIntent> for &'a str {
443 fn from(e: &'a FileShareTokenIntent) -> Self {
444 match e {
445 FileShareTokenIntent::Backup => "backup",
446 FileShareTokenIntent::UnknownValue(s) => s.as_ref(),
447 }
448 }
449}
450
451impl FromStr for FileShareTokenIntent {
452 type Err = Infallible;
453 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
454 Ok(match s {
455 "backup" => FileShareTokenIntent::Backup,
456 _ => FileShareTokenIntent::UnknownValue(s.to_string()),
457 })
458 }
459}
460
461impl AsRef<str> for FileShareTokenIntent {
462 fn as_ref(&self) -> &str {
463 match self {
464 FileShareTokenIntent::Backup => "backup",
465 FileShareTokenIntent::UnknownValue(s) => s.as_str(),
466 }
467 }
468}
469
470impl Display for FileShareTokenIntent {
471 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
472 match self {
473 FileShareTokenIntent::Backup => f.write_str("backup"),
474 FileShareTokenIntent::UnknownValue(s) => f.write_str(s.as_str()),
475 }
476 }
477}
478
479impl FromStr for FilterBlobsIncludeItem {
480 type Err = Error;
481 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
482 Ok(match s {
483 "none" => FilterBlobsIncludeItem::None,
484 "versions" => FilterBlobsIncludeItem::Versions,
485 _ => {
486 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
487 format!("unknown variant of FilterBlobsIncludeItem found: \"{s}\"")
488 }))
489 }
490 })
491 }
492}
493
494impl AsRef<str> for FilterBlobsIncludeItem {
495 fn as_ref(&self) -> &str {
496 match self {
497 FilterBlobsIncludeItem::None => "none",
498 FilterBlobsIncludeItem::Versions => "versions",
499 }
500 }
501}
502
503impl Display for FilterBlobsIncludeItem {
504 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
505 match self {
506 FilterBlobsIncludeItem::None => Display::fmt("none", f),
507 FilterBlobsIncludeItem::Versions => Display::fmt("versions", f),
508 }
509 }
510}
511
512impl<'a> From<&'a GeoReplicationStatusType> for &'a str {
513 fn from(e: &'a GeoReplicationStatusType) -> Self {
514 match e {
515 GeoReplicationStatusType::Bootstrap => "bootstrap",
516 GeoReplicationStatusType::Live => "live",
517 GeoReplicationStatusType::Unavailable => "unavailable",
518 GeoReplicationStatusType::UnknownValue(s) => s.as_ref(),
519 }
520 }
521}
522
523impl FromStr for GeoReplicationStatusType {
524 type Err = Infallible;
525 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
526 Ok(match s {
527 "bootstrap" => GeoReplicationStatusType::Bootstrap,
528 "live" => GeoReplicationStatusType::Live,
529 "unavailable" => GeoReplicationStatusType::Unavailable,
530 _ => GeoReplicationStatusType::UnknownValue(s.to_string()),
531 })
532 }
533}
534
535impl AsRef<str> for GeoReplicationStatusType {
536 fn as_ref(&self) -> &str {
537 match self {
538 GeoReplicationStatusType::Bootstrap => "bootstrap",
539 GeoReplicationStatusType::Live => "live",
540 GeoReplicationStatusType::Unavailable => "unavailable",
541 GeoReplicationStatusType::UnknownValue(s) => s.as_str(),
542 }
543 }
544}
545
546impl Display for GeoReplicationStatusType {
547 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
548 match self {
549 GeoReplicationStatusType::Bootstrap => f.write_str("bootstrap"),
550 GeoReplicationStatusType::Live => f.write_str("live"),
551 GeoReplicationStatusType::Unavailable => f.write_str("unavailable"),
552 GeoReplicationStatusType::UnknownValue(s) => f.write_str(s.as_str()),
553 }
554 }
555}
556
557impl FromStr for ImmutabilityPolicyMode {
558 type Err = Error;
559 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
560 Ok(match s {
561 "locked" => ImmutabilityPolicyMode::Locked,
562 "mutable" => ImmutabilityPolicyMode::Mutable,
563 "unlocked" => ImmutabilityPolicyMode::Unlocked,
564 _ => {
565 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
566 format!("unknown variant of ImmutabilityPolicyMode found: \"{s}\"")
567 }))
568 }
569 })
570 }
571}
572
573impl AsRef<str> for ImmutabilityPolicyMode {
574 fn as_ref(&self) -> &str {
575 match self {
576 ImmutabilityPolicyMode::Locked => "locked",
577 ImmutabilityPolicyMode::Mutable => "mutable",
578 ImmutabilityPolicyMode::Unlocked => "unlocked",
579 }
580 }
581}
582
583impl Display for ImmutabilityPolicyMode {
584 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
585 match self {
586 ImmutabilityPolicyMode::Locked => Display::fmt("locked", f),
587 ImmutabilityPolicyMode::Mutable => Display::fmt("mutable", f),
588 ImmutabilityPolicyMode::Unlocked => Display::fmt("unlocked", f),
589 }
590 }
591}
592
593impl FromStr for LeaseDuration {
594 type Err = Error;
595 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
596 Ok(match s {
597 "fixed" => LeaseDuration::Fixed,
598 "infinite" => LeaseDuration::Infinite,
599 _ => {
600 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
601 format!("unknown variant of LeaseDuration found: \"{s}\"")
602 }))
603 }
604 })
605 }
606}
607
608impl AsRef<str> for LeaseDuration {
609 fn as_ref(&self) -> &str {
610 match self {
611 LeaseDuration::Fixed => "fixed",
612 LeaseDuration::Infinite => "infinite",
613 }
614 }
615}
616
617impl Display for LeaseDuration {
618 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
619 match self {
620 LeaseDuration::Fixed => Display::fmt("fixed", f),
621 LeaseDuration::Infinite => Display::fmt("infinite", f),
622 }
623 }
624}
625
626impl FromStr for LeaseState {
627 type Err = Error;
628 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
629 Ok(match s {
630 "available" => LeaseState::Available,
631 "breaking" => LeaseState::Breaking,
632 "broken" => LeaseState::Broken,
633 "expired" => LeaseState::Expired,
634 "leased" => LeaseState::Leased,
635 _ => {
636 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
637 format!("unknown variant of LeaseState found: \"{s}\"")
638 }))
639 }
640 })
641 }
642}
643
644impl AsRef<str> for LeaseState {
645 fn as_ref(&self) -> &str {
646 match self {
647 LeaseState::Available => "available",
648 LeaseState::Breaking => "breaking",
649 LeaseState::Broken => "broken",
650 LeaseState::Expired => "expired",
651 LeaseState::Leased => "leased",
652 }
653 }
654}
655
656impl Display for LeaseState {
657 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
658 match self {
659 LeaseState::Available => Display::fmt("available", f),
660 LeaseState::Breaking => Display::fmt("breaking", f),
661 LeaseState::Broken => Display::fmt("broken", f),
662 LeaseState::Expired => Display::fmt("expired", f),
663 LeaseState::Leased => Display::fmt("leased", f),
664 }
665 }
666}
667
668impl FromStr for LeaseStatus {
669 type Err = Error;
670 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
671 Ok(match s {
672 "locked" => LeaseStatus::Locked,
673 "unlocked" => LeaseStatus::Unlocked,
674 _ => {
675 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
676 format!("unknown variant of LeaseStatus found: \"{s}\"")
677 }))
678 }
679 })
680 }
681}
682
683impl AsRef<str> for LeaseStatus {
684 fn as_ref(&self) -> &str {
685 match self {
686 LeaseStatus::Locked => "locked",
687 LeaseStatus::Unlocked => "unlocked",
688 }
689 }
690}
691
692impl Display for LeaseStatus {
693 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
694 match self {
695 LeaseStatus::Locked => Display::fmt("locked", f),
696 LeaseStatus::Unlocked => Display::fmt("unlocked", f),
697 }
698 }
699}
700
701impl FromStr for ListBlobsIncludeItem {
702 type Err = Error;
703 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
704 Ok(match s {
705 "copy" => ListBlobsIncludeItem::Copy,
706 "deleted" => ListBlobsIncludeItem::Deleted,
707 "deletedwithversions" => ListBlobsIncludeItem::DeletedWithVersions,
708 "immutabilitypolicy" => ListBlobsIncludeItem::ImmutabilityPolicy,
709 "legalhold" => ListBlobsIncludeItem::LegalHold,
710 "metadata" => ListBlobsIncludeItem::Metadata,
711 "snapshots" => ListBlobsIncludeItem::Snapshots,
712 "tags" => ListBlobsIncludeItem::Tags,
713 "uncommittedblobs" => ListBlobsIncludeItem::UncommittedBlobs,
714 "versions" => ListBlobsIncludeItem::Versions,
715 _ => {
716 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
717 format!("unknown variant of ListBlobsIncludeItem found: \"{s}\"")
718 }))
719 }
720 })
721 }
722}
723
724impl AsRef<str> for ListBlobsIncludeItem {
725 fn as_ref(&self) -> &str {
726 match self {
727 ListBlobsIncludeItem::Copy => "copy",
728 ListBlobsIncludeItem::Deleted => "deleted",
729 ListBlobsIncludeItem::DeletedWithVersions => "deletedwithversions",
730 ListBlobsIncludeItem::ImmutabilityPolicy => "immutabilitypolicy",
731 ListBlobsIncludeItem::LegalHold => "legalhold",
732 ListBlobsIncludeItem::Metadata => "metadata",
733 ListBlobsIncludeItem::Snapshots => "snapshots",
734 ListBlobsIncludeItem::Tags => "tags",
735 ListBlobsIncludeItem::UncommittedBlobs => "uncommittedblobs",
736 ListBlobsIncludeItem::Versions => "versions",
737 }
738 }
739}
740
741impl Display for ListBlobsIncludeItem {
742 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
743 match self {
744 ListBlobsIncludeItem::Copy => Display::fmt("copy", f),
745 ListBlobsIncludeItem::Deleted => Display::fmt("deleted", f),
746 ListBlobsIncludeItem::DeletedWithVersions => Display::fmt("deletedwithversions", f),
747 ListBlobsIncludeItem::ImmutabilityPolicy => Display::fmt("immutabilitypolicy", f),
748 ListBlobsIncludeItem::LegalHold => Display::fmt("legalhold", f),
749 ListBlobsIncludeItem::Metadata => Display::fmt("metadata", f),
750 ListBlobsIncludeItem::Snapshots => Display::fmt("snapshots", f),
751 ListBlobsIncludeItem::Tags => Display::fmt("tags", f),
752 ListBlobsIncludeItem::UncommittedBlobs => Display::fmt("uncommittedblobs", f),
753 ListBlobsIncludeItem::Versions => Display::fmt("versions", f),
754 }
755 }
756}
757
758impl FromStr for ListContainersIncludeType {
759 type Err = Error;
760 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
761 Ok(match s {
762 "deleted" => ListContainersIncludeType::Deleted,
763 "metadata" => ListContainersIncludeType::Metadata,
764 "system" => ListContainersIncludeType::System,
765 _ => {
766 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
767 format!("unknown variant of ListContainersIncludeType found: \"{s}\"")
768 }))
769 }
770 })
771 }
772}
773
774impl AsRef<str> for ListContainersIncludeType {
775 fn as_ref(&self) -> &str {
776 match self {
777 ListContainersIncludeType::Deleted => "deleted",
778 ListContainersIncludeType::Metadata => "metadata",
779 ListContainersIncludeType::System => "system",
780 }
781 }
782}
783
784impl Display for ListContainersIncludeType {
785 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
786 match self {
787 ListContainersIncludeType::Deleted => Display::fmt("deleted", f),
788 ListContainersIncludeType::Metadata => Display::fmt("metadata", f),
789 ListContainersIncludeType::System => Display::fmt("system", f),
790 }
791 }
792}
793
794impl<'a> From<&'a PremiumPageBlobAccessTier> for &'a str {
795 fn from(e: &'a PremiumPageBlobAccessTier) -> Self {
796 match e {
797 PremiumPageBlobAccessTier::P10 => "P10",
798 PremiumPageBlobAccessTier::P15 => "P15",
799 PremiumPageBlobAccessTier::P20 => "P20",
800 PremiumPageBlobAccessTier::P30 => "P30",
801 PremiumPageBlobAccessTier::P4 => "P4",
802 PremiumPageBlobAccessTier::P40 => "P40",
803 PremiumPageBlobAccessTier::P50 => "P50",
804 PremiumPageBlobAccessTier::P6 => "P6",
805 PremiumPageBlobAccessTier::P60 => "P60",
806 PremiumPageBlobAccessTier::P70 => "P70",
807 PremiumPageBlobAccessTier::P80 => "P80",
808 PremiumPageBlobAccessTier::UnknownValue(s) => s.as_ref(),
809 }
810 }
811}
812
813impl FromStr for PremiumPageBlobAccessTier {
814 type Err = Infallible;
815 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
816 Ok(match s {
817 "P10" => PremiumPageBlobAccessTier::P10,
818 "P15" => PremiumPageBlobAccessTier::P15,
819 "P20" => PremiumPageBlobAccessTier::P20,
820 "P30" => PremiumPageBlobAccessTier::P30,
821 "P4" => PremiumPageBlobAccessTier::P4,
822 "P40" => PremiumPageBlobAccessTier::P40,
823 "P50" => PremiumPageBlobAccessTier::P50,
824 "P6" => PremiumPageBlobAccessTier::P6,
825 "P60" => PremiumPageBlobAccessTier::P60,
826 "P70" => PremiumPageBlobAccessTier::P70,
827 "P80" => PremiumPageBlobAccessTier::P80,
828 _ => PremiumPageBlobAccessTier::UnknownValue(s.to_string()),
829 })
830 }
831}
832
833impl AsRef<str> for PremiumPageBlobAccessTier {
834 fn as_ref(&self) -> &str {
835 match self {
836 PremiumPageBlobAccessTier::P10 => "P10",
837 PremiumPageBlobAccessTier::P15 => "P15",
838 PremiumPageBlobAccessTier::P20 => "P20",
839 PremiumPageBlobAccessTier::P30 => "P30",
840 PremiumPageBlobAccessTier::P4 => "P4",
841 PremiumPageBlobAccessTier::P40 => "P40",
842 PremiumPageBlobAccessTier::P50 => "P50",
843 PremiumPageBlobAccessTier::P6 => "P6",
844 PremiumPageBlobAccessTier::P60 => "P60",
845 PremiumPageBlobAccessTier::P70 => "P70",
846 PremiumPageBlobAccessTier::P80 => "P80",
847 PremiumPageBlobAccessTier::UnknownValue(s) => s.as_str(),
848 }
849 }
850}
851
852impl Display for PremiumPageBlobAccessTier {
853 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
854 match self {
855 PremiumPageBlobAccessTier::P10 => f.write_str("P10"),
856 PremiumPageBlobAccessTier::P15 => f.write_str("P15"),
857 PremiumPageBlobAccessTier::P20 => f.write_str("P20"),
858 PremiumPageBlobAccessTier::P30 => f.write_str("P30"),
859 PremiumPageBlobAccessTier::P4 => f.write_str("P4"),
860 PremiumPageBlobAccessTier::P40 => f.write_str("P40"),
861 PremiumPageBlobAccessTier::P50 => f.write_str("P50"),
862 PremiumPageBlobAccessTier::P6 => f.write_str("P6"),
863 PremiumPageBlobAccessTier::P60 => f.write_str("P60"),
864 PremiumPageBlobAccessTier::P70 => f.write_str("P70"),
865 PremiumPageBlobAccessTier::P80 => f.write_str("P80"),
866 PremiumPageBlobAccessTier::UnknownValue(s) => f.write_str(s.as_str()),
867 }
868 }
869}
870
871impl<'a> From<&'a PublicAccessType> for &'a str {
872 fn from(e: &'a PublicAccessType) -> Self {
873 match e {
874 PublicAccessType::Blob => "blob",
875 PublicAccessType::Container => "container",
876 PublicAccessType::UnknownValue(s) => s.as_ref(),
877 }
878 }
879}
880
881impl FromStr for PublicAccessType {
882 type Err = Infallible;
883 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
884 Ok(match s {
885 "blob" => PublicAccessType::Blob,
886 "container" => PublicAccessType::Container,
887 _ => PublicAccessType::UnknownValue(s.to_string()),
888 })
889 }
890}
891
892impl AsRef<str> for PublicAccessType {
893 fn as_ref(&self) -> &str {
894 match self {
895 PublicAccessType::Blob => "blob",
896 PublicAccessType::Container => "container",
897 PublicAccessType::UnknownValue(s) => s.as_str(),
898 }
899 }
900}
901
902impl Display for PublicAccessType {
903 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
904 match self {
905 PublicAccessType::Blob => f.write_str("blob"),
906 PublicAccessType::Container => f.write_str("container"),
907 PublicAccessType::UnknownValue(s) => f.write_str(s.as_str()),
908 }
909 }
910}
911
912impl<'a> From<&'a RehydratePriority> for &'a str {
913 fn from(e: &'a RehydratePriority) -> Self {
914 match e {
915 RehydratePriority::High => "High",
916 RehydratePriority::Standard => "Standard",
917 RehydratePriority::UnknownValue(s) => s.as_ref(),
918 }
919 }
920}
921
922impl FromStr for RehydratePriority {
923 type Err = Infallible;
924 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
925 Ok(match s {
926 "High" => RehydratePriority::High,
927 "Standard" => RehydratePriority::Standard,
928 _ => RehydratePriority::UnknownValue(s.to_string()),
929 })
930 }
931}
932
933impl AsRef<str> for RehydratePriority {
934 fn as_ref(&self) -> &str {
935 match self {
936 RehydratePriority::High => "High",
937 RehydratePriority::Standard => "Standard",
938 RehydratePriority::UnknownValue(s) => s.as_str(),
939 }
940 }
941}
942
943impl Display for RehydratePriority {
944 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
945 match self {
946 RehydratePriority::High => f.write_str("High"),
947 RehydratePriority::Standard => f.write_str("Standard"),
948 RehydratePriority::UnknownValue(s) => f.write_str(s.as_str()),
949 }
950 }
951}
952
953impl FromStr for SequenceNumberActionType {
954 type Err = Error;
955 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
956 Ok(match s {
957 "increment" => SequenceNumberActionType::Increment,
958 "max" => SequenceNumberActionType::Max,
959 "update" => SequenceNumberActionType::Update,
960 _ => {
961 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
962 format!("unknown variant of SequenceNumberActionType found: \"{s}\"")
963 }))
964 }
965 })
966 }
967}
968
969impl AsRef<str> for SequenceNumberActionType {
970 fn as_ref(&self) -> &str {
971 match self {
972 SequenceNumberActionType::Increment => "increment",
973 SequenceNumberActionType::Max => "max",
974 SequenceNumberActionType::Update => "update",
975 }
976 }
977}
978
979impl Display for SequenceNumberActionType {
980 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
981 match self {
982 SequenceNumberActionType::Increment => Display::fmt("increment", f),
983 SequenceNumberActionType::Max => Display::fmt("max", f),
984 SequenceNumberActionType::Update => Display::fmt("update", f),
985 }
986 }
987}
988
989impl FromStr for SkuName {
990 type Err = Error;
991 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
992 Ok(match s {
993 "Premium_LRS" => SkuName::PremiumLrs,
994 "Premium_ZRS" => SkuName::PremiumZrs,
995 "Standard_GRS" => SkuName::StandardGrs,
996 "Standard_GZRS" => SkuName::StandardGzrs,
997 "Standard_LRS" => SkuName::StandardLrs,
998 "Standard_RAGRS" => SkuName::StandardRagrs,
999 "Standard_RAGZRS" => SkuName::StandardRagzrs,
1000 "Standard_ZRS" => SkuName::StandardZrs,
1001 _ => {
1002 return Err(Error::with_message_fn(ErrorKind::DataConversion, || {
1003 format!("unknown variant of SkuName found: \"{s}\"")
1004 }))
1005 }
1006 })
1007 }
1008}
1009
1010impl AsRef<str> for SkuName {
1011 fn as_ref(&self) -> &str {
1012 match self {
1013 SkuName::PremiumLrs => "Premium_LRS",
1014 SkuName::PremiumZrs => "Premium_ZRS",
1015 SkuName::StandardGrs => "Standard_GRS",
1016 SkuName::StandardGzrs => "Standard_GZRS",
1017 SkuName::StandardLrs => "Standard_LRS",
1018 SkuName::StandardRagrs => "Standard_RAGRS",
1019 SkuName::StandardRagzrs => "Standard_RAGZRS",
1020 SkuName::StandardZrs => "Standard_ZRS",
1021 }
1022 }
1023}
1024
1025impl Display for SkuName {
1026 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
1027 match self {
1028 SkuName::PremiumLrs => Display::fmt("Premium_LRS", f),
1029 SkuName::PremiumZrs => Display::fmt("Premium_ZRS", f),
1030 SkuName::StandardGrs => Display::fmt("Standard_GRS", f),
1031 SkuName::StandardGzrs => Display::fmt("Standard_GZRS", f),
1032 SkuName::StandardLrs => Display::fmt("Standard_LRS", f),
1033 SkuName::StandardRagrs => Display::fmt("Standard_RAGRS", f),
1034 SkuName::StandardRagzrs => Display::fmt("Standard_RAGZRS", f),
1035 SkuName::StandardZrs => Display::fmt("Standard_ZRS", f),
1036 }
1037 }
1038}
1039
1040impl<'a> From<&'a StorageErrorCode> for &'a str {
1041 fn from(e: &'a StorageErrorCode) -> Self {
1042 match e {
1043 StorageErrorCode::AccountAlreadyExists => "AccountAlreadyExists",
1044 StorageErrorCode::AccountBeingCreated => "AccountBeingCreated",
1045 StorageErrorCode::AccountIsDisabled => "AccountIsDisabled",
1046 StorageErrorCode::AppendPositionConditionNotMet => "AppendPositionConditionNotMet",
1047 StorageErrorCode::AuthenticationFailed => "AuthenticationFailed",
1048 StorageErrorCode::AuthorizationFailure => "AuthorizationFailure",
1049 StorageErrorCode::AuthorizationPermissionMismatch => "AuthorizationPermissionMismatch",
1050 StorageErrorCode::AuthorizationProtocolMismatch => "AuthorizationProtocolMismatch",
1051 StorageErrorCode::AuthorizationResourceTypeMismatch => {
1052 "AuthorizationResourceTypeMismatch"
1053 }
1054 StorageErrorCode::AuthorizationServiceMismatch => "AuthorizationServiceMismatch",
1055 StorageErrorCode::AuthorizationSourceIPMismatch => "AuthorizationSourceIPMismatch",
1056 StorageErrorCode::BlobAccessTierNotSupportedForAccountType => {
1057 "BlobAccessTierNotSupportedForAccountType"
1058 }
1059 StorageErrorCode::BlobAlreadyExists => "BlobAlreadyExists",
1060 StorageErrorCode::BlobArchived => "BlobArchived",
1061 StorageErrorCode::BlobBeingRehydrated => "BlobBeingRehydrated",
1062 StorageErrorCode::BlobImmutableDueToPolicy => "BlobImmutableDueToPolicy",
1063 StorageErrorCode::BlobNotArchived => "BlobNotArchived",
1064 StorageErrorCode::BlobNotFound => "BlobNotFound",
1065 StorageErrorCode::BlobOverwritten => "BlobOverwritten",
1066 StorageErrorCode::BlobTierInadequateForContentLength => {
1067 "BlobTierInadequateForContentLength"
1068 }
1069 StorageErrorCode::BlobUsesCustomerSpecifiedEncryption => {
1070 "BlobUsesCustomerSpecifiedEncryption"
1071 }
1072 StorageErrorCode::BlockCountExceedsLimit => "BlockCountExceedsLimit",
1073 StorageErrorCode::BlockListTooLong => "BlockListTooLong",
1074 StorageErrorCode::CannotChangeToLowerTier => "CannotChangeToLowerTier",
1075 StorageErrorCode::CannotVerifyCopySource => "CannotVerifyCopySource",
1076 StorageErrorCode::ConditionHeadersNotSupported => "ConditionHeadersNotSupported",
1077 StorageErrorCode::ConditionNotMet => "ConditionNotMet",
1078 StorageErrorCode::ContainerAlreadyExists => "ContainerAlreadyExists",
1079 StorageErrorCode::ContainerBeingDeleted => "ContainerBeingDeleted",
1080 StorageErrorCode::ContainerDisabled => "ContainerDisabled",
1081 StorageErrorCode::ContainerNotFound => "ContainerNotFound",
1082 StorageErrorCode::ContentLengthLargerThanTierLimit => {
1083 "ContentLengthLargerThanTierLimit"
1084 }
1085 StorageErrorCode::CopyAcrossAccountsNotSupported => "CopyAcrossAccountsNotSupported",
1086 StorageErrorCode::CopyIdMismatch => "CopyIdMismatch",
1087 StorageErrorCode::EmptyMetadataKey => "EmptyMetadataKey",
1088 StorageErrorCode::FeatureVersionMismatch => "FeatureVersionMismatch",
1089 StorageErrorCode::IncrementalCopyBlobMismatch => "IncrementalCopyBlobMismatch",
1090 StorageErrorCode::IncrementalCopyOfEarlierSnapshotNotAllowed => {
1091 "IncrementalCopyOfEarlierSnapshotNotAllowed"
1092 }
1093 StorageErrorCode::IncrementalCopyOfEarlierVersionSnapshotNotAllowed => {
1094 "IncrementalCopyOfEarlierVersionSnapshotNotAllowed"
1095 }
1096 StorageErrorCode::IncrementalCopySourceMustBeSnapshot => {
1097 "IncrementalCopySourceMustBeSnapshot"
1098 }
1099 StorageErrorCode::InfiniteLeaseDurationRequired => "InfiniteLeaseDurationRequired",
1100 StorageErrorCode::InsufficientAccountPermissions => "InsufficientAccountPermissions",
1101 StorageErrorCode::InternalError => "InternalError",
1102 StorageErrorCode::InvalidAuthenticationInfo => "InvalidAuthenticationInfo",
1103 StorageErrorCode::InvalidBlobOrBlock => "InvalidBlobOrBlock",
1104 StorageErrorCode::InvalidBlobTier => "InvalidBlobTier",
1105 StorageErrorCode::InvalidBlobType => "InvalidBlobType",
1106 StorageErrorCode::InvalidBlockId => "InvalidBlockId",
1107 StorageErrorCode::InvalidBlockList => "InvalidBlockList",
1108 StorageErrorCode::InvalidHeaderValue => "InvalidHeaderValue",
1109 StorageErrorCode::InvalidHttpVerb => "InvalidHttpVerb",
1110 StorageErrorCode::InvalidInput => "InvalidInput",
1111 StorageErrorCode::InvalidMd5 => "InvalidMd5",
1112 StorageErrorCode::InvalidMetadata => "InvalidMetadata",
1113 StorageErrorCode::InvalidOperation => "InvalidOperation",
1114 StorageErrorCode::InvalidPageRange => "InvalidPageRange",
1115 StorageErrorCode::InvalidQueryParameterValue => "InvalidQueryParameterValue",
1116 StorageErrorCode::InvalidRange => "InvalidRange",
1117 StorageErrorCode::InvalidRequestUrl => "InvalidRequestUrl",
1118 StorageErrorCode::InvalidResourceName => "InvalidResourceName",
1119 StorageErrorCode::InvalidSourceBlobType => "InvalidSourceBlobType",
1120 StorageErrorCode::InvalidSourceBlobUrl => "InvalidSourceBlobUrl",
1121 StorageErrorCode::InvalidUri => "InvalidUri",
1122 StorageErrorCode::InvalidVersionForPageBlobOperation => {
1123 "InvalidVersionForPageBlobOperation"
1124 }
1125 StorageErrorCode::InvalidXmlDocument => "InvalidXmlDocument",
1126 StorageErrorCode::InvalidXmlNodeValue => "InvalidXmlNodeValue",
1127 StorageErrorCode::LeaseAlreadyBroken => "LeaseAlreadyBroken",
1128 StorageErrorCode::LeaseAlreadyPresent => "LeaseAlreadyPresent",
1129 StorageErrorCode::LeaseIdMismatchWithBlobOperation => {
1130 "LeaseIdMismatchWithBlobOperation"
1131 }
1132 StorageErrorCode::LeaseIdMismatchWithContainerOperation => {
1133 "LeaseIdMismatchWithContainerOperation"
1134 }
1135 StorageErrorCode::LeaseIdMismatchWithLeaseOperation => {
1136 "LeaseIdMismatchWithLeaseOperation"
1137 }
1138 StorageErrorCode::LeaseIdMissing => "LeaseIdMissing",
1139 StorageErrorCode::LeaseIsBreakingAndCannotBeAcquired => {
1140 "LeaseIsBreakingAndCannotBeAcquired"
1141 }
1142 StorageErrorCode::LeaseIsBreakingAndCannotBeChanged => {
1143 "LeaseIsBreakingAndCannotBeChanged"
1144 }
1145 StorageErrorCode::LeaseIsBrokenAndCannotBeRenewed => "LeaseIsBrokenAndCannotBeRenewed",
1146 StorageErrorCode::LeaseLost => "LeaseLost",
1147 StorageErrorCode::LeaseNotPresentWithBlobOperation => {
1148 "LeaseNotPresentWithBlobOperation"
1149 }
1150 StorageErrorCode::LeaseNotPresentWithContainerOperation => {
1151 "LeaseNotPresentWithContainerOperation"
1152 }
1153 StorageErrorCode::LeaseNotPresentWithLeaseOperation => {
1154 "LeaseNotPresentWithLeaseOperation"
1155 }
1156 StorageErrorCode::MaxBlobSizeConditionNotMet => "MaxBlobSizeConditionNotMet",
1157 StorageErrorCode::Md5Mismatch => "Md5Mismatch",
1158 StorageErrorCode::MetadataTooLarge => "MetadataTooLarge",
1159 StorageErrorCode::MissingContentLengthHeader => "MissingContentLengthHeader",
1160 StorageErrorCode::MissingRequiredHeader => "MissingRequiredHeader",
1161 StorageErrorCode::MissingRequiredQueryParameter => "MissingRequiredQueryParameter",
1162 StorageErrorCode::MissingRequiredXmlNode => "MissingRequiredXmlNode",
1163 StorageErrorCode::MultipleConditionHeadersNotSupported => {
1164 "MultipleConditionHeadersNotSupported"
1165 }
1166 StorageErrorCode::NoAuthenticationInformation => "NoAuthenticationInformation",
1167 StorageErrorCode::NoPendingCopyOperation => "NoPendingCopyOperation",
1168 StorageErrorCode::OperationNotAllowedOnIncrementalCopyBlob => {
1169 "OperationNotAllowedOnIncrementalCopyBlob"
1170 }
1171 StorageErrorCode::OperationTimedOut => "OperationTimedOut",
1172 StorageErrorCode::OutOfRangeInput => "OutOfRangeInput",
1173 StorageErrorCode::OutOfRangeQueryParameterValue => "OutOfRangeQueryParameterValue",
1174 StorageErrorCode::PendingCopyOperation => "PendingCopyOperation",
1175 StorageErrorCode::PreviousSnapshotCannotBeNewer => "PreviousSnapshotCannotBeNewer",
1176 StorageErrorCode::PreviousSnapshotNotFound => "PreviousSnapshotNotFound",
1177 StorageErrorCode::PreviousSnapshotOperationNotSupported => {
1178 "PreviousSnapshotOperationNotSupported"
1179 }
1180 StorageErrorCode::RequestBodyTooLarge => "RequestBodyTooLarge",
1181 StorageErrorCode::RequestUrlFailedToParse => "RequestUrlFailedToParse",
1182 StorageErrorCode::ResourceAlreadyExists => "ResourceAlreadyExists",
1183 StorageErrorCode::ResourceNotFound => "ResourceNotFound",
1184 StorageErrorCode::ResourceTypeMismatch => "ResourceTypeMismatch",
1185 StorageErrorCode::SequenceNumberConditionNotMet => "SequenceNumberConditionNotMet",
1186 StorageErrorCode::SequenceNumberIncrementTooLarge => "SequenceNumberIncrementTooLarge",
1187 StorageErrorCode::ServerBusy => "ServerBusy",
1188 StorageErrorCode::SnapshotCountExceeded => "SnapshotCountExceeded",
1189 StorageErrorCode::SnapshotOperationRateExceeded => "SnapshotOperationRateExceeded",
1190 StorageErrorCode::SnapshotsPresent => "SnapshotsPresent",
1191 StorageErrorCode::SourceConditionNotMet => "SourceConditionNotMet",
1192 StorageErrorCode::SystemInUse => "SystemInUse",
1193 StorageErrorCode::TargetConditionNotMet => "TargetConditionNotMet",
1194 StorageErrorCode::UnauthorizedBlobOverwrite => "UnauthorizedBlobOverwrite",
1195 StorageErrorCode::UnsupportedHeader => "UnsupportedHeader",
1196 StorageErrorCode::UnsupportedHttpVerb => "UnsupportedHttpVerb",
1197 StorageErrorCode::UnsupportedQueryParameter => "UnsupportedQueryParameter",
1198 StorageErrorCode::UnsupportedXmlNode => "UnsupportedXmlNode",
1199 StorageErrorCode::UnknownValue(s) => s.as_ref(),
1200 }
1201 }
1202}
1203
1204impl FromStr for StorageErrorCode {
1205 type Err = Infallible;
1206 fn from_str(s: &str) -> ::core::result::Result<Self, <Self as FromStr>::Err> {
1207 Ok(match s {
1208 "AccountAlreadyExists" => StorageErrorCode::AccountAlreadyExists,
1209 "AccountBeingCreated" => StorageErrorCode::AccountBeingCreated,
1210 "AccountIsDisabled" => StorageErrorCode::AccountIsDisabled,
1211 "AppendPositionConditionNotMet" => StorageErrorCode::AppendPositionConditionNotMet,
1212 "AuthenticationFailed" => StorageErrorCode::AuthenticationFailed,
1213 "AuthorizationFailure" => StorageErrorCode::AuthorizationFailure,
1214 "AuthorizationPermissionMismatch" => StorageErrorCode::AuthorizationPermissionMismatch,
1215 "AuthorizationProtocolMismatch" => StorageErrorCode::AuthorizationProtocolMismatch,
1216 "AuthorizationResourceTypeMismatch" => {
1217 StorageErrorCode::AuthorizationResourceTypeMismatch
1218 }
1219 "AuthorizationServiceMismatch" => StorageErrorCode::AuthorizationServiceMismatch,
1220 "AuthorizationSourceIPMismatch" => StorageErrorCode::AuthorizationSourceIPMismatch,
1221 "BlobAccessTierNotSupportedForAccountType" => {
1222 StorageErrorCode::BlobAccessTierNotSupportedForAccountType
1223 }
1224 "BlobAlreadyExists" => StorageErrorCode::BlobAlreadyExists,
1225 "BlobArchived" => StorageErrorCode::BlobArchived,
1226 "BlobBeingRehydrated" => StorageErrorCode::BlobBeingRehydrated,
1227 "BlobImmutableDueToPolicy" => StorageErrorCode::BlobImmutableDueToPolicy,
1228 "BlobNotArchived" => StorageErrorCode::BlobNotArchived,
1229 "BlobNotFound" => StorageErrorCode::BlobNotFound,
1230 "BlobOverwritten" => StorageErrorCode::BlobOverwritten,
1231 "BlobTierInadequateForContentLength" => {
1232 StorageErrorCode::BlobTierInadequateForContentLength
1233 }
1234 "BlobUsesCustomerSpecifiedEncryption" => {
1235 StorageErrorCode::BlobUsesCustomerSpecifiedEncryption
1236 }
1237 "BlockCountExceedsLimit" => StorageErrorCode::BlockCountExceedsLimit,
1238 "BlockListTooLong" => StorageErrorCode::BlockListTooLong,
1239 "CannotChangeToLowerTier" => StorageErrorCode::CannotChangeToLowerTier,
1240 "CannotVerifyCopySource" => StorageErrorCode::CannotVerifyCopySource,
1241 "ConditionHeadersNotSupported" => StorageErrorCode::ConditionHeadersNotSupported,
1242 "ConditionNotMet" => StorageErrorCode::ConditionNotMet,
1243 "ContainerAlreadyExists" => StorageErrorCode::ContainerAlreadyExists,
1244 "ContainerBeingDeleted" => StorageErrorCode::ContainerBeingDeleted,
1245 "ContainerDisabled" => StorageErrorCode::ContainerDisabled,
1246 "ContainerNotFound" => StorageErrorCode::ContainerNotFound,
1247 "ContentLengthLargerThanTierLimit" => {
1248 StorageErrorCode::ContentLengthLargerThanTierLimit
1249 }
1250 "CopyAcrossAccountsNotSupported" => StorageErrorCode::CopyAcrossAccountsNotSupported,
1251 "CopyIdMismatch" => StorageErrorCode::CopyIdMismatch,
1252 "EmptyMetadataKey" => StorageErrorCode::EmptyMetadataKey,
1253 "FeatureVersionMismatch" => StorageErrorCode::FeatureVersionMismatch,
1254 "IncrementalCopyBlobMismatch" => StorageErrorCode::IncrementalCopyBlobMismatch,
1255 "IncrementalCopyOfEarlierSnapshotNotAllowed" => {
1256 StorageErrorCode::IncrementalCopyOfEarlierSnapshotNotAllowed
1257 }
1258 "IncrementalCopyOfEarlierVersionSnapshotNotAllowed" => {
1259 StorageErrorCode::IncrementalCopyOfEarlierVersionSnapshotNotAllowed
1260 }
1261 "IncrementalCopySourceMustBeSnapshot" => {
1262 StorageErrorCode::IncrementalCopySourceMustBeSnapshot
1263 }
1264 "InfiniteLeaseDurationRequired" => StorageErrorCode::InfiniteLeaseDurationRequired,
1265 "InsufficientAccountPermissions" => StorageErrorCode::InsufficientAccountPermissions,
1266 "InternalError" => StorageErrorCode::InternalError,
1267 "InvalidAuthenticationInfo" => StorageErrorCode::InvalidAuthenticationInfo,
1268 "InvalidBlobOrBlock" => StorageErrorCode::InvalidBlobOrBlock,
1269 "InvalidBlobTier" => StorageErrorCode::InvalidBlobTier,
1270 "InvalidBlobType" => StorageErrorCode::InvalidBlobType,
1271 "InvalidBlockId" => StorageErrorCode::InvalidBlockId,
1272 "InvalidBlockList" => StorageErrorCode::InvalidBlockList,
1273 "InvalidHeaderValue" => StorageErrorCode::InvalidHeaderValue,
1274 "InvalidHttpVerb" => StorageErrorCode::InvalidHttpVerb,
1275 "InvalidInput" => StorageErrorCode::InvalidInput,
1276 "InvalidMd5" => StorageErrorCode::InvalidMd5,
1277 "InvalidMetadata" => StorageErrorCode::InvalidMetadata,
1278 "InvalidOperation" => StorageErrorCode::InvalidOperation,
1279 "InvalidPageRange" => StorageErrorCode::InvalidPageRange,
1280 "InvalidQueryParameterValue" => StorageErrorCode::InvalidQueryParameterValue,
1281 "InvalidRange" => StorageErrorCode::InvalidRange,
1282 "InvalidRequestUrl" => StorageErrorCode::InvalidRequestUrl,
1283 "InvalidResourceName" => StorageErrorCode::InvalidResourceName,
1284 "InvalidSourceBlobType" => StorageErrorCode::InvalidSourceBlobType,
1285 "InvalidSourceBlobUrl" => StorageErrorCode::InvalidSourceBlobUrl,
1286 "InvalidUri" => StorageErrorCode::InvalidUri,
1287 "InvalidVersionForPageBlobOperation" => {
1288 StorageErrorCode::InvalidVersionForPageBlobOperation
1289 }
1290 "InvalidXmlDocument" => StorageErrorCode::InvalidXmlDocument,
1291 "InvalidXmlNodeValue" => StorageErrorCode::InvalidXmlNodeValue,
1292 "LeaseAlreadyBroken" => StorageErrorCode::LeaseAlreadyBroken,
1293 "LeaseAlreadyPresent" => StorageErrorCode::LeaseAlreadyPresent,
1294 "LeaseIdMismatchWithBlobOperation" => {
1295 StorageErrorCode::LeaseIdMismatchWithBlobOperation
1296 }
1297 "LeaseIdMismatchWithContainerOperation" => {
1298 StorageErrorCode::LeaseIdMismatchWithContainerOperation
1299 }
1300 "LeaseIdMismatchWithLeaseOperation" => {
1301 StorageErrorCode::LeaseIdMismatchWithLeaseOperation
1302 }
1303 "LeaseIdMissing" => StorageErrorCode::LeaseIdMissing,
1304 "LeaseIsBreakingAndCannotBeAcquired" => {
1305 StorageErrorCode::LeaseIsBreakingAndCannotBeAcquired
1306 }
1307 "LeaseIsBreakingAndCannotBeChanged" => {
1308 StorageErrorCode::LeaseIsBreakingAndCannotBeChanged
1309 }
1310 "LeaseIsBrokenAndCannotBeRenewed" => StorageErrorCode::LeaseIsBrokenAndCannotBeRenewed,
1311 "LeaseLost" => StorageErrorCode::LeaseLost,
1312 "LeaseNotPresentWithBlobOperation" => {
1313 StorageErrorCode::LeaseNotPresentWithBlobOperation
1314 }
1315 "LeaseNotPresentWithContainerOperation" => {
1316 StorageErrorCode::LeaseNotPresentWithContainerOperation
1317 }
1318 "LeaseNotPresentWithLeaseOperation" => {
1319 StorageErrorCode::LeaseNotPresentWithLeaseOperation
1320 }
1321 "MaxBlobSizeConditionNotMet" => StorageErrorCode::MaxBlobSizeConditionNotMet,
1322 "Md5Mismatch" => StorageErrorCode::Md5Mismatch,
1323 "MetadataTooLarge" => StorageErrorCode::MetadataTooLarge,
1324 "MissingContentLengthHeader" => StorageErrorCode::MissingContentLengthHeader,
1325 "MissingRequiredHeader" => StorageErrorCode::MissingRequiredHeader,
1326 "MissingRequiredQueryParameter" => StorageErrorCode::MissingRequiredQueryParameter,
1327 "MissingRequiredXmlNode" => StorageErrorCode::MissingRequiredXmlNode,
1328 "MultipleConditionHeadersNotSupported" => {
1329 StorageErrorCode::MultipleConditionHeadersNotSupported
1330 }
1331 "NoAuthenticationInformation" => StorageErrorCode::NoAuthenticationInformation,
1332 "NoPendingCopyOperation" => StorageErrorCode::NoPendingCopyOperation,
1333 "OperationNotAllowedOnIncrementalCopyBlob" => {
1334 StorageErrorCode::OperationNotAllowedOnIncrementalCopyBlob
1335 }
1336 "OperationTimedOut" => StorageErrorCode::OperationTimedOut,
1337 "OutOfRangeInput" => StorageErrorCode::OutOfRangeInput,
1338 "OutOfRangeQueryParameterValue" => StorageErrorCode::OutOfRangeQueryParameterValue,
1339 "PendingCopyOperation" => StorageErrorCode::PendingCopyOperation,
1340 "PreviousSnapshotCannotBeNewer" => StorageErrorCode::PreviousSnapshotCannotBeNewer,
1341 "PreviousSnapshotNotFound" => StorageErrorCode::PreviousSnapshotNotFound,
1342 "PreviousSnapshotOperationNotSupported" => {
1343 StorageErrorCode::PreviousSnapshotOperationNotSupported
1344 }
1345 "RequestBodyTooLarge" => StorageErrorCode::RequestBodyTooLarge,
1346 "RequestUrlFailedToParse" => StorageErrorCode::RequestUrlFailedToParse,
1347 "ResourceAlreadyExists" => StorageErrorCode::ResourceAlreadyExists,
1348 "ResourceNotFound" => StorageErrorCode::ResourceNotFound,
1349 "ResourceTypeMismatch" => StorageErrorCode::ResourceTypeMismatch,
1350 "SequenceNumberConditionNotMet" => StorageErrorCode::SequenceNumberConditionNotMet,
1351 "SequenceNumberIncrementTooLarge" => StorageErrorCode::SequenceNumberIncrementTooLarge,
1352 "ServerBusy" => StorageErrorCode::ServerBusy,
1353 "SnapshotCountExceeded" => StorageErrorCode::SnapshotCountExceeded,
1354 "SnapshotOperationRateExceeded" => StorageErrorCode::SnapshotOperationRateExceeded,
1355 "SnapshotsPresent" => StorageErrorCode::SnapshotsPresent,
1356 "SourceConditionNotMet" => StorageErrorCode::SourceConditionNotMet,
1357 "SystemInUse" => StorageErrorCode::SystemInUse,
1358 "TargetConditionNotMet" => StorageErrorCode::TargetConditionNotMet,
1359 "UnauthorizedBlobOverwrite" => StorageErrorCode::UnauthorizedBlobOverwrite,
1360 "UnsupportedHeader" => StorageErrorCode::UnsupportedHeader,
1361 "UnsupportedHttpVerb" => StorageErrorCode::UnsupportedHttpVerb,
1362 "UnsupportedQueryParameter" => StorageErrorCode::UnsupportedQueryParameter,
1363 "UnsupportedXmlNode" => StorageErrorCode::UnsupportedXmlNode,
1364 _ => StorageErrorCode::UnknownValue(s.to_string()),
1365 })
1366 }
1367}
1368
1369impl AsRef<str> for StorageErrorCode {
1370 fn as_ref(&self) -> &str {
1371 match self {
1372 StorageErrorCode::AccountAlreadyExists => "AccountAlreadyExists",
1373 StorageErrorCode::AccountBeingCreated => "AccountBeingCreated",
1374 StorageErrorCode::AccountIsDisabled => "AccountIsDisabled",
1375 StorageErrorCode::AppendPositionConditionNotMet => "AppendPositionConditionNotMet",
1376 StorageErrorCode::AuthenticationFailed => "AuthenticationFailed",
1377 StorageErrorCode::AuthorizationFailure => "AuthorizationFailure",
1378 StorageErrorCode::AuthorizationPermissionMismatch => "AuthorizationPermissionMismatch",
1379 StorageErrorCode::AuthorizationProtocolMismatch => "AuthorizationProtocolMismatch",
1380 StorageErrorCode::AuthorizationResourceTypeMismatch => {
1381 "AuthorizationResourceTypeMismatch"
1382 }
1383 StorageErrorCode::AuthorizationServiceMismatch => "AuthorizationServiceMismatch",
1384 StorageErrorCode::AuthorizationSourceIPMismatch => "AuthorizationSourceIPMismatch",
1385 StorageErrorCode::BlobAccessTierNotSupportedForAccountType => {
1386 "BlobAccessTierNotSupportedForAccountType"
1387 }
1388 StorageErrorCode::BlobAlreadyExists => "BlobAlreadyExists",
1389 StorageErrorCode::BlobArchived => "BlobArchived",
1390 StorageErrorCode::BlobBeingRehydrated => "BlobBeingRehydrated",
1391 StorageErrorCode::BlobImmutableDueToPolicy => "BlobImmutableDueToPolicy",
1392 StorageErrorCode::BlobNotArchived => "BlobNotArchived",
1393 StorageErrorCode::BlobNotFound => "BlobNotFound",
1394 StorageErrorCode::BlobOverwritten => "BlobOverwritten",
1395 StorageErrorCode::BlobTierInadequateForContentLength => {
1396 "BlobTierInadequateForContentLength"
1397 }
1398 StorageErrorCode::BlobUsesCustomerSpecifiedEncryption => {
1399 "BlobUsesCustomerSpecifiedEncryption"
1400 }
1401 StorageErrorCode::BlockCountExceedsLimit => "BlockCountExceedsLimit",
1402 StorageErrorCode::BlockListTooLong => "BlockListTooLong",
1403 StorageErrorCode::CannotChangeToLowerTier => "CannotChangeToLowerTier",
1404 StorageErrorCode::CannotVerifyCopySource => "CannotVerifyCopySource",
1405 StorageErrorCode::ConditionHeadersNotSupported => "ConditionHeadersNotSupported",
1406 StorageErrorCode::ConditionNotMet => "ConditionNotMet",
1407 StorageErrorCode::ContainerAlreadyExists => "ContainerAlreadyExists",
1408 StorageErrorCode::ContainerBeingDeleted => "ContainerBeingDeleted",
1409 StorageErrorCode::ContainerDisabled => "ContainerDisabled",
1410 StorageErrorCode::ContainerNotFound => "ContainerNotFound",
1411 StorageErrorCode::ContentLengthLargerThanTierLimit => {
1412 "ContentLengthLargerThanTierLimit"
1413 }
1414 StorageErrorCode::CopyAcrossAccountsNotSupported => "CopyAcrossAccountsNotSupported",
1415 StorageErrorCode::CopyIdMismatch => "CopyIdMismatch",
1416 StorageErrorCode::EmptyMetadataKey => "EmptyMetadataKey",
1417 StorageErrorCode::FeatureVersionMismatch => "FeatureVersionMismatch",
1418 StorageErrorCode::IncrementalCopyBlobMismatch => "IncrementalCopyBlobMismatch",
1419 StorageErrorCode::IncrementalCopyOfEarlierSnapshotNotAllowed => {
1420 "IncrementalCopyOfEarlierSnapshotNotAllowed"
1421 }
1422 StorageErrorCode::IncrementalCopyOfEarlierVersionSnapshotNotAllowed => {
1423 "IncrementalCopyOfEarlierVersionSnapshotNotAllowed"
1424 }
1425 StorageErrorCode::IncrementalCopySourceMustBeSnapshot => {
1426 "IncrementalCopySourceMustBeSnapshot"
1427 }
1428 StorageErrorCode::InfiniteLeaseDurationRequired => "InfiniteLeaseDurationRequired",
1429 StorageErrorCode::InsufficientAccountPermissions => "InsufficientAccountPermissions",
1430 StorageErrorCode::InternalError => "InternalError",
1431 StorageErrorCode::InvalidAuthenticationInfo => "InvalidAuthenticationInfo",
1432 StorageErrorCode::InvalidBlobOrBlock => "InvalidBlobOrBlock",
1433 StorageErrorCode::InvalidBlobTier => "InvalidBlobTier",
1434 StorageErrorCode::InvalidBlobType => "InvalidBlobType",
1435 StorageErrorCode::InvalidBlockId => "InvalidBlockId",
1436 StorageErrorCode::InvalidBlockList => "InvalidBlockList",
1437 StorageErrorCode::InvalidHeaderValue => "InvalidHeaderValue",
1438 StorageErrorCode::InvalidHttpVerb => "InvalidHttpVerb",
1439 StorageErrorCode::InvalidInput => "InvalidInput",
1440 StorageErrorCode::InvalidMd5 => "InvalidMd5",
1441 StorageErrorCode::InvalidMetadata => "InvalidMetadata",
1442 StorageErrorCode::InvalidOperation => "InvalidOperation",
1443 StorageErrorCode::InvalidPageRange => "InvalidPageRange",
1444 StorageErrorCode::InvalidQueryParameterValue => "InvalidQueryParameterValue",
1445 StorageErrorCode::InvalidRange => "InvalidRange",
1446 StorageErrorCode::InvalidRequestUrl => "InvalidRequestUrl",
1447 StorageErrorCode::InvalidResourceName => "InvalidResourceName",
1448 StorageErrorCode::InvalidSourceBlobType => "InvalidSourceBlobType",
1449 StorageErrorCode::InvalidSourceBlobUrl => "InvalidSourceBlobUrl",
1450 StorageErrorCode::InvalidUri => "InvalidUri",
1451 StorageErrorCode::InvalidVersionForPageBlobOperation => {
1452 "InvalidVersionForPageBlobOperation"
1453 }
1454 StorageErrorCode::InvalidXmlDocument => "InvalidXmlDocument",
1455 StorageErrorCode::InvalidXmlNodeValue => "InvalidXmlNodeValue",
1456 StorageErrorCode::LeaseAlreadyBroken => "LeaseAlreadyBroken",
1457 StorageErrorCode::LeaseAlreadyPresent => "LeaseAlreadyPresent",
1458 StorageErrorCode::LeaseIdMismatchWithBlobOperation => {
1459 "LeaseIdMismatchWithBlobOperation"
1460 }
1461 StorageErrorCode::LeaseIdMismatchWithContainerOperation => {
1462 "LeaseIdMismatchWithContainerOperation"
1463 }
1464 StorageErrorCode::LeaseIdMismatchWithLeaseOperation => {
1465 "LeaseIdMismatchWithLeaseOperation"
1466 }
1467 StorageErrorCode::LeaseIdMissing => "LeaseIdMissing",
1468 StorageErrorCode::LeaseIsBreakingAndCannotBeAcquired => {
1469 "LeaseIsBreakingAndCannotBeAcquired"
1470 }
1471 StorageErrorCode::LeaseIsBreakingAndCannotBeChanged => {
1472 "LeaseIsBreakingAndCannotBeChanged"
1473 }
1474 StorageErrorCode::LeaseIsBrokenAndCannotBeRenewed => "LeaseIsBrokenAndCannotBeRenewed",
1475 StorageErrorCode::LeaseLost => "LeaseLost",
1476 StorageErrorCode::LeaseNotPresentWithBlobOperation => {
1477 "LeaseNotPresentWithBlobOperation"
1478 }
1479 StorageErrorCode::LeaseNotPresentWithContainerOperation => {
1480 "LeaseNotPresentWithContainerOperation"
1481 }
1482 StorageErrorCode::LeaseNotPresentWithLeaseOperation => {
1483 "LeaseNotPresentWithLeaseOperation"
1484 }
1485 StorageErrorCode::MaxBlobSizeConditionNotMet => "MaxBlobSizeConditionNotMet",
1486 StorageErrorCode::Md5Mismatch => "Md5Mismatch",
1487 StorageErrorCode::MetadataTooLarge => "MetadataTooLarge",
1488 StorageErrorCode::MissingContentLengthHeader => "MissingContentLengthHeader",
1489 StorageErrorCode::MissingRequiredHeader => "MissingRequiredHeader",
1490 StorageErrorCode::MissingRequiredQueryParameter => "MissingRequiredQueryParameter",
1491 StorageErrorCode::MissingRequiredXmlNode => "MissingRequiredXmlNode",
1492 StorageErrorCode::MultipleConditionHeadersNotSupported => {
1493 "MultipleConditionHeadersNotSupported"
1494 }
1495 StorageErrorCode::NoAuthenticationInformation => "NoAuthenticationInformation",
1496 StorageErrorCode::NoPendingCopyOperation => "NoPendingCopyOperation",
1497 StorageErrorCode::OperationNotAllowedOnIncrementalCopyBlob => {
1498 "OperationNotAllowedOnIncrementalCopyBlob"
1499 }
1500 StorageErrorCode::OperationTimedOut => "OperationTimedOut",
1501 StorageErrorCode::OutOfRangeInput => "OutOfRangeInput",
1502 StorageErrorCode::OutOfRangeQueryParameterValue => "OutOfRangeQueryParameterValue",
1503 StorageErrorCode::PendingCopyOperation => "PendingCopyOperation",
1504 StorageErrorCode::PreviousSnapshotCannotBeNewer => "PreviousSnapshotCannotBeNewer",
1505 StorageErrorCode::PreviousSnapshotNotFound => "PreviousSnapshotNotFound",
1506 StorageErrorCode::PreviousSnapshotOperationNotSupported => {
1507 "PreviousSnapshotOperationNotSupported"
1508 }
1509 StorageErrorCode::RequestBodyTooLarge => "RequestBodyTooLarge",
1510 StorageErrorCode::RequestUrlFailedToParse => "RequestUrlFailedToParse",
1511 StorageErrorCode::ResourceAlreadyExists => "ResourceAlreadyExists",
1512 StorageErrorCode::ResourceNotFound => "ResourceNotFound",
1513 StorageErrorCode::ResourceTypeMismatch => "ResourceTypeMismatch",
1514 StorageErrorCode::SequenceNumberConditionNotMet => "SequenceNumberConditionNotMet",
1515 StorageErrorCode::SequenceNumberIncrementTooLarge => "SequenceNumberIncrementTooLarge",
1516 StorageErrorCode::ServerBusy => "ServerBusy",
1517 StorageErrorCode::SnapshotCountExceeded => "SnapshotCountExceeded",
1518 StorageErrorCode::SnapshotOperationRateExceeded => "SnapshotOperationRateExceeded",
1519 StorageErrorCode::SnapshotsPresent => "SnapshotsPresent",
1520 StorageErrorCode::SourceConditionNotMet => "SourceConditionNotMet",
1521 StorageErrorCode::SystemInUse => "SystemInUse",
1522 StorageErrorCode::TargetConditionNotMet => "TargetConditionNotMet",
1523 StorageErrorCode::UnauthorizedBlobOverwrite => "UnauthorizedBlobOverwrite",
1524 StorageErrorCode::UnsupportedHeader => "UnsupportedHeader",
1525 StorageErrorCode::UnsupportedHttpVerb => "UnsupportedHttpVerb",
1526 StorageErrorCode::UnsupportedQueryParameter => "UnsupportedQueryParameter",
1527 StorageErrorCode::UnsupportedXmlNode => "UnsupportedXmlNode",
1528 StorageErrorCode::UnknownValue(s) => s.as_str(),
1529 }
1530 }
1531}
1532
1533impl Display for StorageErrorCode {
1534 fn fmt(&self, f: &mut Formatter<'_>) -> ::std::fmt::Result {
1535 match self {
1536 StorageErrorCode::AccountAlreadyExists => f.write_str("AccountAlreadyExists"),
1537 StorageErrorCode::AccountBeingCreated => f.write_str("AccountBeingCreated"),
1538 StorageErrorCode::AccountIsDisabled => f.write_str("AccountIsDisabled"),
1539 StorageErrorCode::AppendPositionConditionNotMet => {
1540 f.write_str("AppendPositionConditionNotMet")
1541 }
1542 StorageErrorCode::AuthenticationFailed => f.write_str("AuthenticationFailed"),
1543 StorageErrorCode::AuthorizationFailure => f.write_str("AuthorizationFailure"),
1544 StorageErrorCode::AuthorizationPermissionMismatch => {
1545 f.write_str("AuthorizationPermissionMismatch")
1546 }
1547 StorageErrorCode::AuthorizationProtocolMismatch => {
1548 f.write_str("AuthorizationProtocolMismatch")
1549 }
1550 StorageErrorCode::AuthorizationResourceTypeMismatch => {
1551 f.write_str("AuthorizationResourceTypeMismatch")
1552 }
1553 StorageErrorCode::AuthorizationServiceMismatch => {
1554 f.write_str("AuthorizationServiceMismatch")
1555 }
1556 StorageErrorCode::AuthorizationSourceIPMismatch => {
1557 f.write_str("AuthorizationSourceIPMismatch")
1558 }
1559 StorageErrorCode::BlobAccessTierNotSupportedForAccountType => {
1560 f.write_str("BlobAccessTierNotSupportedForAccountType")
1561 }
1562 StorageErrorCode::BlobAlreadyExists => f.write_str("BlobAlreadyExists"),
1563 StorageErrorCode::BlobArchived => f.write_str("BlobArchived"),
1564 StorageErrorCode::BlobBeingRehydrated => f.write_str("BlobBeingRehydrated"),
1565 StorageErrorCode::BlobImmutableDueToPolicy => f.write_str("BlobImmutableDueToPolicy"),
1566 StorageErrorCode::BlobNotArchived => f.write_str("BlobNotArchived"),
1567 StorageErrorCode::BlobNotFound => f.write_str("BlobNotFound"),
1568 StorageErrorCode::BlobOverwritten => f.write_str("BlobOverwritten"),
1569 StorageErrorCode::BlobTierInadequateForContentLength => {
1570 f.write_str("BlobTierInadequateForContentLength")
1571 }
1572 StorageErrorCode::BlobUsesCustomerSpecifiedEncryption => {
1573 f.write_str("BlobUsesCustomerSpecifiedEncryption")
1574 }
1575 StorageErrorCode::BlockCountExceedsLimit => f.write_str("BlockCountExceedsLimit"),
1576 StorageErrorCode::BlockListTooLong => f.write_str("BlockListTooLong"),
1577 StorageErrorCode::CannotChangeToLowerTier => f.write_str("CannotChangeToLowerTier"),
1578 StorageErrorCode::CannotVerifyCopySource => f.write_str("CannotVerifyCopySource"),
1579 StorageErrorCode::ConditionHeadersNotSupported => {
1580 f.write_str("ConditionHeadersNotSupported")
1581 }
1582 StorageErrorCode::ConditionNotMet => f.write_str("ConditionNotMet"),
1583 StorageErrorCode::ContainerAlreadyExists => f.write_str("ContainerAlreadyExists"),
1584 StorageErrorCode::ContainerBeingDeleted => f.write_str("ContainerBeingDeleted"),
1585 StorageErrorCode::ContainerDisabled => f.write_str("ContainerDisabled"),
1586 StorageErrorCode::ContainerNotFound => f.write_str("ContainerNotFound"),
1587 StorageErrorCode::ContentLengthLargerThanTierLimit => {
1588 f.write_str("ContentLengthLargerThanTierLimit")
1589 }
1590 StorageErrorCode::CopyAcrossAccountsNotSupported => {
1591 f.write_str("CopyAcrossAccountsNotSupported")
1592 }
1593 StorageErrorCode::CopyIdMismatch => f.write_str("CopyIdMismatch"),
1594 StorageErrorCode::EmptyMetadataKey => f.write_str("EmptyMetadataKey"),
1595 StorageErrorCode::FeatureVersionMismatch => f.write_str("FeatureVersionMismatch"),
1596 StorageErrorCode::IncrementalCopyBlobMismatch => {
1597 f.write_str("IncrementalCopyBlobMismatch")
1598 }
1599 StorageErrorCode::IncrementalCopyOfEarlierSnapshotNotAllowed => {
1600 f.write_str("IncrementalCopyOfEarlierSnapshotNotAllowed")
1601 }
1602 StorageErrorCode::IncrementalCopyOfEarlierVersionSnapshotNotAllowed => {
1603 f.write_str("IncrementalCopyOfEarlierVersionSnapshotNotAllowed")
1604 }
1605 StorageErrorCode::IncrementalCopySourceMustBeSnapshot => {
1606 f.write_str("IncrementalCopySourceMustBeSnapshot")
1607 }
1608 StorageErrorCode::InfiniteLeaseDurationRequired => {
1609 f.write_str("InfiniteLeaseDurationRequired")
1610 }
1611 StorageErrorCode::InsufficientAccountPermissions => {
1612 f.write_str("InsufficientAccountPermissions")
1613 }
1614 StorageErrorCode::InternalError => f.write_str("InternalError"),
1615 StorageErrorCode::InvalidAuthenticationInfo => f.write_str("InvalidAuthenticationInfo"),
1616 StorageErrorCode::InvalidBlobOrBlock => f.write_str("InvalidBlobOrBlock"),
1617 StorageErrorCode::InvalidBlobTier => f.write_str("InvalidBlobTier"),
1618 StorageErrorCode::InvalidBlobType => f.write_str("InvalidBlobType"),
1619 StorageErrorCode::InvalidBlockId => f.write_str("InvalidBlockId"),
1620 StorageErrorCode::InvalidBlockList => f.write_str("InvalidBlockList"),
1621 StorageErrorCode::InvalidHeaderValue => f.write_str("InvalidHeaderValue"),
1622 StorageErrorCode::InvalidHttpVerb => f.write_str("InvalidHttpVerb"),
1623 StorageErrorCode::InvalidInput => f.write_str("InvalidInput"),
1624 StorageErrorCode::InvalidMd5 => f.write_str("InvalidMd5"),
1625 StorageErrorCode::InvalidMetadata => f.write_str("InvalidMetadata"),
1626 StorageErrorCode::InvalidOperation => f.write_str("InvalidOperation"),
1627 StorageErrorCode::InvalidPageRange => f.write_str("InvalidPageRange"),
1628 StorageErrorCode::InvalidQueryParameterValue => {
1629 f.write_str("InvalidQueryParameterValue")
1630 }
1631 StorageErrorCode::InvalidRange => f.write_str("InvalidRange"),
1632 StorageErrorCode::InvalidRequestUrl => f.write_str("InvalidRequestUrl"),
1633 StorageErrorCode::InvalidResourceName => f.write_str("InvalidResourceName"),
1634 StorageErrorCode::InvalidSourceBlobType => f.write_str("InvalidSourceBlobType"),
1635 StorageErrorCode::InvalidSourceBlobUrl => f.write_str("InvalidSourceBlobUrl"),
1636 StorageErrorCode::InvalidUri => f.write_str("InvalidUri"),
1637 StorageErrorCode::InvalidVersionForPageBlobOperation => {
1638 f.write_str("InvalidVersionForPageBlobOperation")
1639 }
1640 StorageErrorCode::InvalidXmlDocument => f.write_str("InvalidXmlDocument"),
1641 StorageErrorCode::InvalidXmlNodeValue => f.write_str("InvalidXmlNodeValue"),
1642 StorageErrorCode::LeaseAlreadyBroken => f.write_str("LeaseAlreadyBroken"),
1643 StorageErrorCode::LeaseAlreadyPresent => f.write_str("LeaseAlreadyPresent"),
1644 StorageErrorCode::LeaseIdMismatchWithBlobOperation => {
1645 f.write_str("LeaseIdMismatchWithBlobOperation")
1646 }
1647 StorageErrorCode::LeaseIdMismatchWithContainerOperation => {
1648 f.write_str("LeaseIdMismatchWithContainerOperation")
1649 }
1650 StorageErrorCode::LeaseIdMismatchWithLeaseOperation => {
1651 f.write_str("LeaseIdMismatchWithLeaseOperation")
1652 }
1653 StorageErrorCode::LeaseIdMissing => f.write_str("LeaseIdMissing"),
1654 StorageErrorCode::LeaseIsBreakingAndCannotBeAcquired => {
1655 f.write_str("LeaseIsBreakingAndCannotBeAcquired")
1656 }
1657 StorageErrorCode::LeaseIsBreakingAndCannotBeChanged => {
1658 f.write_str("LeaseIsBreakingAndCannotBeChanged")
1659 }
1660 StorageErrorCode::LeaseIsBrokenAndCannotBeRenewed => {
1661 f.write_str("LeaseIsBrokenAndCannotBeRenewed")
1662 }
1663 StorageErrorCode::LeaseLost => f.write_str("LeaseLost"),
1664 StorageErrorCode::LeaseNotPresentWithBlobOperation => {
1665 f.write_str("LeaseNotPresentWithBlobOperation")
1666 }
1667 StorageErrorCode::LeaseNotPresentWithContainerOperation => {
1668 f.write_str("LeaseNotPresentWithContainerOperation")
1669 }
1670 StorageErrorCode::LeaseNotPresentWithLeaseOperation => {
1671 f.write_str("LeaseNotPresentWithLeaseOperation")
1672 }
1673 StorageErrorCode::MaxBlobSizeConditionNotMet => {
1674 f.write_str("MaxBlobSizeConditionNotMet")
1675 }
1676 StorageErrorCode::Md5Mismatch => f.write_str("Md5Mismatch"),
1677 StorageErrorCode::MetadataTooLarge => f.write_str("MetadataTooLarge"),
1678 StorageErrorCode::MissingContentLengthHeader => {
1679 f.write_str("MissingContentLengthHeader")
1680 }
1681 StorageErrorCode::MissingRequiredHeader => f.write_str("MissingRequiredHeader"),
1682 StorageErrorCode::MissingRequiredQueryParameter => {
1683 f.write_str("MissingRequiredQueryParameter")
1684 }
1685 StorageErrorCode::MissingRequiredXmlNode => f.write_str("MissingRequiredXmlNode"),
1686 StorageErrorCode::MultipleConditionHeadersNotSupported => {
1687 f.write_str("MultipleConditionHeadersNotSupported")
1688 }
1689 StorageErrorCode::NoAuthenticationInformation => {
1690 f.write_str("NoAuthenticationInformation")
1691 }
1692 StorageErrorCode::NoPendingCopyOperation => f.write_str("NoPendingCopyOperation"),
1693 StorageErrorCode::OperationNotAllowedOnIncrementalCopyBlob => {
1694 f.write_str("OperationNotAllowedOnIncrementalCopyBlob")
1695 }
1696 StorageErrorCode::OperationTimedOut => f.write_str("OperationTimedOut"),
1697 StorageErrorCode::OutOfRangeInput => f.write_str("OutOfRangeInput"),
1698 StorageErrorCode::OutOfRangeQueryParameterValue => {
1699 f.write_str("OutOfRangeQueryParameterValue")
1700 }
1701 StorageErrorCode::PendingCopyOperation => f.write_str("PendingCopyOperation"),
1702 StorageErrorCode::PreviousSnapshotCannotBeNewer => {
1703 f.write_str("PreviousSnapshotCannotBeNewer")
1704 }
1705 StorageErrorCode::PreviousSnapshotNotFound => f.write_str("PreviousSnapshotNotFound"),
1706 StorageErrorCode::PreviousSnapshotOperationNotSupported => {
1707 f.write_str("PreviousSnapshotOperationNotSupported")
1708 }
1709 StorageErrorCode::RequestBodyTooLarge => f.write_str("RequestBodyTooLarge"),
1710 StorageErrorCode::RequestUrlFailedToParse => f.write_str("RequestUrlFailedToParse"),
1711 StorageErrorCode::ResourceAlreadyExists => f.write_str("ResourceAlreadyExists"),
1712 StorageErrorCode::ResourceNotFound => f.write_str("ResourceNotFound"),
1713 StorageErrorCode::ResourceTypeMismatch => f.write_str("ResourceTypeMismatch"),
1714 StorageErrorCode::SequenceNumberConditionNotMet => {
1715 f.write_str("SequenceNumberConditionNotMet")
1716 }
1717 StorageErrorCode::SequenceNumberIncrementTooLarge => {
1718 f.write_str("SequenceNumberIncrementTooLarge")
1719 }
1720 StorageErrorCode::ServerBusy => f.write_str("ServerBusy"),
1721 StorageErrorCode::SnapshotCountExceeded => f.write_str("SnapshotCountExceeded"),
1722 StorageErrorCode::SnapshotOperationRateExceeded => {
1723 f.write_str("SnapshotOperationRateExceeded")
1724 }
1725 StorageErrorCode::SnapshotsPresent => f.write_str("SnapshotsPresent"),
1726 StorageErrorCode::SourceConditionNotMet => f.write_str("SourceConditionNotMet"),
1727 StorageErrorCode::SystemInUse => f.write_str("SystemInUse"),
1728 StorageErrorCode::TargetConditionNotMet => f.write_str("TargetConditionNotMet"),
1729 StorageErrorCode::UnauthorizedBlobOverwrite => f.write_str("UnauthorizedBlobOverwrite"),
1730 StorageErrorCode::UnsupportedHeader => f.write_str("UnsupportedHeader"),
1731 StorageErrorCode::UnsupportedHttpVerb => f.write_str("UnsupportedHttpVerb"),
1732 StorageErrorCode::UnsupportedQueryParameter => f.write_str("UnsupportedQueryParameter"),
1733 StorageErrorCode::UnsupportedXmlNode => f.write_str("UnsupportedXmlNode"),
1734 StorageErrorCode::UnknownValue(s) => f.write_str(s.as_str()),
1735 }
1736 }
1737}