1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
use conjure_object::serde::ser::SerializeStruct as SerializeStruct_; use conjure_object::serde::{de, ser}; use std::fmt; #[doc = "A generic `PERMISSION_DENIED` error."] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Copy)] pub struct PermissionDenied {} impl PermissionDenied { #[doc = r" Constructs a new instance of the type."] #[inline] pub fn new() -> PermissionDenied { PermissionDenied {} } #[doc = r" Returns a new builder."] #[inline] pub fn builder() -> Builder { Default::default() } } #[doc = "A builder for the `PermissionDenied` type."] #[derive(Debug, Clone, Default)] pub struct Builder {} impl Builder { #[doc = r" Constructs a new instance of the type."] #[doc = r""] #[doc = r" # Panics"] #[doc = r""] #[doc = r" Panics if a required field was not set."] #[inline] pub fn build(&self) -> PermissionDenied { PermissionDenied {} } } impl From<PermissionDenied> for Builder { #[inline] fn from(_v: PermissionDenied) -> Builder { Builder {} } } impl ser::Serialize for PermissionDenied { fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error> where S: ser::Serializer, { let size = 0usize; let s = s.serialize_struct("PermissionDenied", size)?; s.end() } } impl<'de> de::Deserialize<'de> for PermissionDenied { fn deserialize<D>(d: D) -> Result<PermissionDenied, D::Error> where D: de::Deserializer<'de>, { d.deserialize_struct("PermissionDenied", &[], Visitor_) } } struct Visitor_; impl<'de> de::Visitor<'de> for Visitor_ { type Value = PermissionDenied; fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.write_str("map") } fn visit_map<A>(self, mut map_: A) -> Result<PermissionDenied, A::Error> where A: de::MapAccess<'de>, { while let Some(field_) = map_.next_key()? { match field_ { Field_::Unknown_ => { map_.next_value::<de::IgnoredAny>()?; } } } Ok(PermissionDenied {}) } } enum Field_ { Unknown_, } impl<'de> de::Deserialize<'de> for Field_ { fn deserialize<D>(d: D) -> Result<Field_, D::Error> where D: de::Deserializer<'de>, { d.deserialize_str(FieldVisitor_) } } struct FieldVisitor_; impl<'de> de::Visitor<'de> for FieldVisitor_ { type Value = Field_; fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.write_str("string") } fn visit_str<E>(self, value: &str) -> Result<Field_, E> where E: de::Error, { let v = match value { _ => Field_::Unknown_, }; Ok(v) } } impl conjure_error::ErrorType for PermissionDenied { #[inline] fn code(&self) -> conjure_error::ErrorCode { conjure_error::ErrorCode::PermissionDenied } #[inline] fn name(&self) -> &str { "Default:PermissionDenied" } #[inline] fn instance_id(&self) -> Option<conjure_object::Uuid> { None } #[inline] fn safe_args(&self) -> &'static [&'static str] { &[] } }