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
use conjure_object::serde::{de, ser}; use std::fmt; use std::str; #[doc = "This enumerates the numbers 1:2."] #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum EnumExample { One, Two, #[doc = r" An unknown variant."] Unknown(Unknown), } impl EnumExample { #[doc = r" Returns the string representation of the enum."] #[inline] pub fn as_str(&self) -> &str { match self { EnumExample::One => "ONE", EnumExample::Two => "TWO", EnumExample::Unknown(v) => &*v, } } } impl fmt::Display for EnumExample { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self.as_str(), fmt) } } impl conjure_object::Plain for EnumExample { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { conjure_object::Plain::fmt(self.as_str(), fmt) } } impl str::FromStr for EnumExample { type Err = conjure_object::plain::ParseEnumError; #[inline] fn from_str(v: &str) -> Result<EnumExample, conjure_object::plain::ParseEnumError> { match v { "ONE" => Ok(EnumExample::One), "TWO" => Ok(EnumExample::Two), v => { if conjure_object::private::valid_enum_variant(v) { Ok(EnumExample::Unknown(Unknown( v.to_string().into_boxed_str(), ))) } else { Err(conjure_object::plain::ParseEnumError::new()) } } } } } impl conjure_object::FromPlain for EnumExample { type Err = conjure_object::plain::ParseEnumError; #[inline] fn from_plain(v: &str) -> Result<EnumExample, conjure_object::plain::ParseEnumError> { v.parse() } } impl ser::Serialize for EnumExample { fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error> where S: ser::Serializer, { s.serialize_str(self.as_str()) } } impl<'de> de::Deserialize<'de> for EnumExample { fn deserialize<D>(d: D) -> Result<EnumExample, D::Error> where D: de::Deserializer<'de>, { d.deserialize_str(Visitor_) } } struct Visitor_; impl<'de> de::Visitor<'de> for Visitor_ { type Value = EnumExample; fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.write_str("a string") } fn visit_str<E>(self, v: &str) -> Result<EnumExample, E> where E: de::Error, { match v.parse() { Ok(e) => Ok(e), Err(_) => Err(de::Error::unknown_variant(v, &["ONE", "TWO"])), } } } #[doc = "An unknown variant of the EnumExample enum."] #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Unknown(Box<str>); impl std::ops::Deref for Unknown { type Target = str; #[inline] fn deref(&self) -> &str { &self.0 } } impl fmt::Display for Unknown { #[inline] fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.0, fmt) } }