nominal_api/conjure/objects/scout/datareview/api/
close_strategy.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, PartialEq, Eq, PartialOrd, Ord, Hash)]
6pub enum CloseStrategy {
7    CloseAllLinkedAlerts(super::CloseAllLinkedAlerts),
8    CloseAndDetachFromNotebook(super::CloseAndDetachFromNotebook),
9    CloseAndDuplicatePreviouslyLinkedNotebook(
10        super::CloseAndDuplicatePreviouslyLinkedNotebook,
11    ),
12    /// An unknown variant.
13    Unknown(Unknown),
14}
15impl ser::Serialize for CloseStrategy {
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            CloseStrategy::CloseAllLinkedAlerts(value) => {
23                map.serialize_entry(&"type", &"closeAllLinkedAlerts")?;
24                map.serialize_entry(&"closeAllLinkedAlerts", value)?;
25            }
26            CloseStrategy::CloseAndDetachFromNotebook(value) => {
27                map.serialize_entry(&"type", &"closeAndDetachFromNotebook")?;
28                map.serialize_entry(&"closeAndDetachFromNotebook", value)?;
29            }
30            CloseStrategy::CloseAndDuplicatePreviouslyLinkedNotebook(value) => {
31                map.serialize_entry(
32                    &"type",
33                    &"closeAndDuplicatePreviouslyLinkedNotebook",
34                )?;
35                map.serialize_entry(
36                    &"closeAndDuplicatePreviouslyLinkedNotebook",
37                    value,
38                )?;
39            }
40            CloseStrategy::Unknown(value) => {
41                map.serialize_entry(&"type", &value.type_)?;
42                map.serialize_entry(&value.type_, &value.value)?;
43            }
44        }
45        map.end()
46    }
47}
48impl<'de> de::Deserialize<'de> for CloseStrategy {
49    fn deserialize<D>(d: D) -> Result<CloseStrategy, D::Error>
50    where
51        D: de::Deserializer<'de>,
52    {
53        d.deserialize_map(Visitor_)
54    }
55}
56struct Visitor_;
57impl<'de> de::Visitor<'de> for Visitor_ {
58    type Value = CloseStrategy;
59    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
60        fmt.write_str("union CloseStrategy")
61    }
62    fn visit_map<A>(self, mut map: A) -> Result<CloseStrategy, A::Error>
63    where
64        A: de::MapAccess<'de>,
65    {
66        let v = match map.next_key::<UnionField_<Variant_>>()? {
67            Some(UnionField_::Type) => {
68                let variant = map.next_value()?;
69                let key = map.next_key()?;
70                match (variant, key) {
71                    (
72                        Variant_::CloseAllLinkedAlerts,
73                        Some(Variant_::CloseAllLinkedAlerts),
74                    ) => {
75                        let value = map.next_value()?;
76                        CloseStrategy::CloseAllLinkedAlerts(value)
77                    }
78                    (
79                        Variant_::CloseAndDetachFromNotebook,
80                        Some(Variant_::CloseAndDetachFromNotebook),
81                    ) => {
82                        let value = map.next_value()?;
83                        CloseStrategy::CloseAndDetachFromNotebook(value)
84                    }
85                    (
86                        Variant_::CloseAndDuplicatePreviouslyLinkedNotebook,
87                        Some(Variant_::CloseAndDuplicatePreviouslyLinkedNotebook),
88                    ) => {
89                        let value = map.next_value()?;
90                        CloseStrategy::CloseAndDuplicatePreviouslyLinkedNotebook(value)
91                    }
92                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
93                        if type_ == b {
94                            let value = map.next_value()?;
95                            CloseStrategy::Unknown(Unknown { type_, value })
96                        } else {
97                            return Err(
98                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
99                            )
100                        }
101                    }
102                    (variant, Some(key)) => {
103                        return Err(
104                            de::Error::invalid_value(
105                                de::Unexpected::Str(key.as_str()),
106                                &variant.as_str(),
107                            ),
108                        );
109                    }
110                    (variant, None) => {
111                        return Err(de::Error::missing_field(variant.as_str()));
112                    }
113                }
114            }
115            Some(UnionField_::Value(variant)) => {
116                let value = match &variant {
117                    Variant_::CloseAllLinkedAlerts => {
118                        let value = map.next_value()?;
119                        CloseStrategy::CloseAllLinkedAlerts(value)
120                    }
121                    Variant_::CloseAndDetachFromNotebook => {
122                        let value = map.next_value()?;
123                        CloseStrategy::CloseAndDetachFromNotebook(value)
124                    }
125                    Variant_::CloseAndDuplicatePreviouslyLinkedNotebook => {
126                        let value = map.next_value()?;
127                        CloseStrategy::CloseAndDuplicatePreviouslyLinkedNotebook(value)
128                    }
129                    Variant_::Unknown(type_) => {
130                        let value = map.next_value()?;
131                        CloseStrategy::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    CloseAllLinkedAlerts,
162    CloseAndDetachFromNotebook,
163    CloseAndDuplicatePreviouslyLinkedNotebook,
164    Unknown(Box<str>),
165}
166impl Variant_ {
167    fn as_str(&self) -> &'static str {
168        match *self {
169            Variant_::CloseAllLinkedAlerts => "closeAllLinkedAlerts",
170            Variant_::CloseAndDetachFromNotebook => "closeAndDetachFromNotebook",
171            Variant_::CloseAndDuplicatePreviouslyLinkedNotebook => {
172                "closeAndDuplicatePreviouslyLinkedNotebook"
173            }
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            "closeAllLinkedAlerts" => Variant_::CloseAllLinkedAlerts,
198            "closeAndDetachFromNotebook" => Variant_::CloseAndDetachFromNotebook,
199            "closeAndDuplicatePreviouslyLinkedNotebook" => {
200                Variant_::CloseAndDuplicatePreviouslyLinkedNotebook
201            }
202            value => Variant_::Unknown(value.to_string().into_boxed_str()),
203        };
204        Ok(v)
205    }
206}
207///An unknown variant of the CloseStrategy union.
208#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
209pub struct Unknown {
210    type_: Box<str>,
211    value: conjure_object::Any,
212}
213impl Unknown {
214    /// Returns the unknown variant's type name.
215    #[inline]
216    pub fn type_(&self) -> &str {
217        &self.type_
218    }
219}
nominal_api/conjure/objects/scout/datareview/api/close_strategy.rs

nominal_api/conjure/objects/scout/datareview/api/
close_strategy.rs
