k8s_openapi/v1_35/api/core/v1/
container_restart_rule_on_exit_codes.rs

1// Generated from definition io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes
2
3/// ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ContainerRestartRuleOnExitCodes {
6    /// Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the
7    ///   set of specified values.
8    /// - NotIn: the requirement is satisfied if the container exit code is
9    ///   not in the set of specified values.
10    pub operator: std::string::String,
11
12    /// Specifies the set of values to check for container exit codes. At most 255 elements are allowed.
13    pub values: Option<std::vec::Vec<i32>>,
14}
15
16impl crate::DeepMerge for ContainerRestartRuleOnExitCodes {
17    fn merge_from(&mut self, other: Self) {
18        crate::DeepMerge::merge_from(&mut self.operator, other.operator);
19        crate::merge_strategies::list::set(&mut self.values, other.values);
20    }
21}
22
23impl<'de> crate::serde::Deserialize<'de> for ContainerRestartRuleOnExitCodes {
24    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
25        #[allow(non_camel_case_types)]
26        enum Field {
27            Key_operator,
28            Key_values,
29            Other,
30        }
31
32        impl<'de> crate::serde::Deserialize<'de> for Field {
33            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
34                struct Visitor;
35
36                impl crate::serde::de::Visitor<'_> for Visitor {
37                    type Value = Field;
38
39                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
40                        f.write_str("field identifier")
41                    }
42
43                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
44                        Ok(match v {
45                            "operator" => Field::Key_operator,
46                            "values" => Field::Key_values,
47                            _ => Field::Other,
48                        })
49                    }
50                }
51
52                deserializer.deserialize_identifier(Visitor)
53            }
54        }
55
56        struct Visitor;
57
58        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
59            type Value = ContainerRestartRuleOnExitCodes;
60
61            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
62                f.write_str("ContainerRestartRuleOnExitCodes")
63            }
64
65            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
66                let mut value_operator: Option<std::string::String> = None;
67                let mut value_values: Option<std::vec::Vec<i32>> = None;
68
69                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
70                    match key {
71                        Field::Key_operator => value_operator = crate::serde::de::MapAccess::next_value(&mut map)?,
72                        Field::Key_values => value_values = crate::serde::de::MapAccess::next_value(&mut map)?,
73                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
74                    }
75                }
76
77                Ok(ContainerRestartRuleOnExitCodes {
78                    operator: value_operator.unwrap_or_default(),
79                    values: value_values,
80                })
81            }
82        }
83
84        deserializer.deserialize_struct(
85            "ContainerRestartRuleOnExitCodes",
86            &[
87                "operator",
88                "values",
89            ],
90            Visitor,
91        )
92    }
93}
94
95impl crate::serde::Serialize for ContainerRestartRuleOnExitCodes {
96    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
97        let mut state = serializer.serialize_struct(
98            "ContainerRestartRuleOnExitCodes",
99            1 +
100            self.values.as_ref().map_or(0, |_| 1),
101        )?;
102        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "operator", &self.operator)?;
103        if let Some(value) = &self.values {
104            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "values", value)?;
105        }
106        crate::serde::ser::SerializeStruct::end(state)
107    }
108}
109
110#[cfg(feature = "schemars")]
111impl crate::schemars::JsonSchema for ContainerRestartRuleOnExitCodes {
112    fn schema_name() -> std::borrow::Cow<'static, str> {
113        "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes".into()
114    }
115
116    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
117        crate::schemars::json_schema!({
118            "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.",
119            "type": "object",
120            "properties": {
121                "operator": {
122                    "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n  set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n  not in the set of specified values.",
123                    "type": "string",
124                },
125                "values": {
126                    "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.",
127                    "type": "array",
128                    "items": {
129                        "type": "integer",
130                        "format": "int32",
131                    },
132                },
133            },
134            "required": [
135                "operator",
136            ],
137        })
138    }
139}