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

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