nominal_api_conjure/conjure/objects/scout/checks/api/
unresolved_check_condition.rs

1use conjure_object::serde::{ser, de};
2use conjure_object::serde::ser::SerializeMap as SerializeMap_;
3use conjure_object::private::{UnionField_, UnionTypeField_};
4use std::fmt;
5#[derive(Debug, Clone, conjure_object::private::DeriveWith)]
6#[derive_with(PartialEq, Eq, PartialOrd, Ord, Hash)]
7pub enum UnresolvedCheckCondition {
8    NumRangesV2(super::UnresolvedNumRangesConditionV2),
9    NumRangesV3(super::UnresolvedNumRangesConditionV3),
10    ParameterizedNumRangesV1(super::UnresolvedParameterizedNumRangesConditionV1),
11    /// An unknown variant.
12    Unknown(Unknown),
13}
14impl ser::Serialize for UnresolvedCheckCondition {
15    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
16    where
17        S: ser::Serializer,
18    {
19        let mut map = s.serialize_map(Some(2))?;
20        match self {
21            UnresolvedCheckCondition::NumRangesV2(value) => {
22                map.serialize_entry(&"type", &"numRangesV2")?;
23                map.serialize_entry(&"numRangesV2", value)?;
24            }
25            UnresolvedCheckCondition::NumRangesV3(value) => {
26                map.serialize_entry(&"type", &"numRangesV3")?;
27                map.serialize_entry(&"numRangesV3", value)?;
28            }
29            UnresolvedCheckCondition::ParameterizedNumRangesV1(value) => {
30                map.serialize_entry(&"type", &"parameterizedNumRangesV1")?;
31                map.serialize_entry(&"parameterizedNumRangesV1", value)?;
32            }
33            UnresolvedCheckCondition::Unknown(value) => {
34                map.serialize_entry(&"type", &value.type_)?;
35                map.serialize_entry(&value.type_, &value.value)?;
36            }
37        }
38        map.end()
39    }
40}
41impl<'de> de::Deserialize<'de> for UnresolvedCheckCondition {
42    fn deserialize<D>(d: D) -> Result<UnresolvedCheckCondition, D::Error>
43    where
44        D: de::Deserializer<'de>,
45    {
46        d.deserialize_map(Visitor_)
47    }
48}
49struct Visitor_;
50impl<'de> de::Visitor<'de> for Visitor_ {
51    type Value = UnresolvedCheckCondition;
52    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
53        fmt.write_str("union UnresolvedCheckCondition")
54    }
55    fn visit_map<A>(self, mut map: A) -> Result<UnresolvedCheckCondition, A::Error>
56    where
57        A: de::MapAccess<'de>,
58    {
59        let v = match map.next_key::<UnionField_<Variant_>>()? {
60            Some(UnionField_::Type) => {
61                let variant = map.next_value()?;
62                let key = map.next_key()?;
63                match (variant, key) {
64                    (Variant_::NumRangesV2, Some(Variant_::NumRangesV2)) => {
65                        let value = map.next_value()?;
66                        UnresolvedCheckCondition::NumRangesV2(value)
67                    }
68                    (Variant_::NumRangesV3, Some(Variant_::NumRangesV3)) => {
69                        let value = map.next_value()?;
70                        UnresolvedCheckCondition::NumRangesV3(value)
71                    }
72                    (
73                        Variant_::ParameterizedNumRangesV1,
74                        Some(Variant_::ParameterizedNumRangesV1),
75                    ) => {
76                        let value = map.next_value()?;
77                        UnresolvedCheckCondition::ParameterizedNumRangesV1(value)
78                    }
79                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
80                        if type_ == b {
81                            let value = map.next_value()?;
82                            UnresolvedCheckCondition::Unknown(Unknown { type_, value })
83                        } else {
84                            return Err(
85                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
86                            )
87                        }
88                    }
89                    (variant, Some(key)) => {
90                        return Err(
91                            de::Error::invalid_value(
92                                de::Unexpected::Str(key.as_str()),
93                                &variant.as_str(),
94                            ),
95                        );
96                    }
97                    (variant, None) => {
98                        return Err(de::Error::missing_field(variant.as_str()));
99                    }
100                }
101            }
102            Some(UnionField_::Value(variant)) => {
103                let value = match &variant {
104                    Variant_::NumRangesV2 => {
105                        let value = map.next_value()?;
106                        UnresolvedCheckCondition::NumRangesV2(value)
107                    }
108                    Variant_::NumRangesV3 => {
109                        let value = map.next_value()?;
110                        UnresolvedCheckCondition::NumRangesV3(value)
111                    }
112                    Variant_::ParameterizedNumRangesV1 => {
113                        let value = map.next_value()?;
114                        UnresolvedCheckCondition::ParameterizedNumRangesV1(value)
115                    }
116                    Variant_::Unknown(type_) => {
117                        let value = map.next_value()?;
118                        UnresolvedCheckCondition::Unknown(Unknown {
119                            type_: type_.clone(),
120                            value,
121                        })
122                    }
123                };
124                if map.next_key::<UnionTypeField_>()?.is_none() {
125                    return Err(de::Error::missing_field("type"));
126                }
127                let type_variant = map.next_value::<Variant_>()?;
128                if variant != type_variant {
129                    return Err(
130                        de::Error::invalid_value(
131                            de::Unexpected::Str(type_variant.as_str()),
132                            &variant.as_str(),
133                        ),
134                    );
135                }
136                value
137            }
138            None => return Err(de::Error::missing_field("type")),
139        };
140        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
141            return Err(de::Error::invalid_length(3, &"type and value fields"));
142        }
143        Ok(v)
144    }
145}
146#[derive(PartialEq)]
147enum Variant_ {
148    NumRangesV2,
149    NumRangesV3,
150    ParameterizedNumRangesV1,
151    Unknown(Box<str>),
152}
153impl Variant_ {
154    fn as_str(&self) -> &'static str {
155        match *self {
156            Variant_::NumRangesV2 => "numRangesV2",
157            Variant_::NumRangesV3 => "numRangesV3",
158            Variant_::ParameterizedNumRangesV1 => "parameterizedNumRangesV1",
159            Variant_::Unknown(_) => "unknown variant",
160        }
161    }
162}
163impl<'de> de::Deserialize<'de> for Variant_ {
164    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
165    where
166        D: de::Deserializer<'de>,
167    {
168        d.deserialize_str(VariantVisitor_)
169    }
170}
171struct VariantVisitor_;
172impl<'de> de::Visitor<'de> for VariantVisitor_ {
173    type Value = Variant_;
174    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
175        fmt.write_str("string")
176    }
177    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
178    where
179        E: de::Error,
180    {
181        let v = match value {
182            "numRangesV2" => Variant_::NumRangesV2,
183            "numRangesV3" => Variant_::NumRangesV3,
184            "parameterizedNumRangesV1" => Variant_::ParameterizedNumRangesV1,
185            value => Variant_::Unknown(value.to_string().into_boxed_str()),
186        };
187        Ok(v)
188    }
189}
190///An unknown variant of the UnresolvedCheckCondition union.
191#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
192pub struct Unknown {
193    type_: Box<str>,
194    value: conjure_object::Any,
195}
196impl Unknown {
197    /// Returns the unknown variant's type name.
198    #[inline]
199    pub fn type_(&self) -> &str {
200        &self.type_
201    }
202}
nominal_api_conjure/conjure/objects/scout/checks/api/unresolved_check_condition.rs

nominal_api_conjure/conjure/objects/scout/checks/api/
unresolved_check_condition.rs
