#
k8s_openapi/v1_35/api/core/v1/
config_map_key_selector.rs

    1// Generated from definition io.k8s.api.core.v1.ConfigMapKeySelector
    2
    3/// Selects a key from a ConfigMap.
    4#[derive(Clone, Debug, Default, PartialEq)]
    5pub struct ConfigMapKeySelector {
    6    /// The key to select.
    7    pub key: std::string::String,
    8
    9    /// Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
    10    pub name: std::string::String,
    11
    12    /// Specify whether the ConfigMap or its key must be defined
    13    pub optional: Option<bool>,
    14}
    15
    16impl crate::DeepMerge for ConfigMapKeySelector {
    17    fn merge_from(&mut self, other: Self) {
    18        crate::DeepMerge::merge_from(&mut self.key, other.key);
    19        crate::DeepMerge::merge_from(&mut self.name, other.name);
    20        crate::DeepMerge::merge_from(&mut self.optional, other.optional);
    21    }
    22}
    23
    24impl<'de> crate::serde::Deserialize<'de> for ConfigMapKeySelector {
    25    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    26        #[allow(non_camel_case_types)]
    27        enum Field {
    28            Key_key,
    29            Key_name,
    30            Key_optional,
    31            Other,
    32        }
    33
    34        impl<'de> crate::serde::Deserialize<'de> for Field {
    35            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    36                struct Visitor;
    37
    38                impl crate::serde::de::Visitor<'_> for Visitor {
    39                    type Value = Field;
    40
    41                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    42                        f.write_str("field identifier")
    43                    }
    44
    45                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
    46                        Ok(match v {
    47                            "key" => Field::Key_key,
    48                            "name" => Field::Key_name,
    49                            "optional" => Field::Key_optional,
    50                            _ => Field::Other,
    51                        })
    52                    }
    53                }
    54
    55                deserializer.deserialize_identifier(Visitor)
    56            }
    57        }
    58
    59        struct Visitor;
    60
    61        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
    62            type Value = ConfigMapKeySelector;
    63
    64            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    65                f.write_str("ConfigMapKeySelector")
    66            }
    67
    68            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
    69                let mut value_key: Option<std::string::String> = None;
    70                let mut value_name: Option<std::string::String> = None;
    71                let mut value_optional: Option<bool> = None;
    72
    73                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
    74                    match key {
    75                        Field::Key_key => value_key = crate::serde::de::MapAccess::next_value(&mut map)?,
    76                        Field::Key_name => value_name = crate::serde::de::MapAccess::next_value(&mut map)?,
    77                        Field::Key_optional => value_optional = crate::serde::de::MapAccess::next_value(&mut map)?,
    78                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
    79                    }
    80                }
    81
    82                Ok(ConfigMapKeySelector {
    83                    key: value_key.unwrap_or_default(),
    84                    name: value_name.unwrap_or_default(),
    85                    optional: value_optional,
    86                })
    87            }
    88        }
    89
    90        deserializer.deserialize_struct(
    91            "ConfigMapKeySelector",
    92            &[
    93                "key",
    94                "name",
    95                "optional",
    96            ],
    97            Visitor,
    98        )
    99    }
    100}
    101
    102impl crate::serde::Serialize for ConfigMapKeySelector {
    103    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
    104        let mut state = serializer.serialize_struct(
    105            "ConfigMapKeySelector",
    106            2 +
    107            self.optional.as_ref().map_or(0, |_| 1),
    108        )?;
    109        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "key", &self.key)?;
    110        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "name", &self.name)?;
    111        if let Some(value) = &self.optional {
    112            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "optional", value)?;
    113        }
    114        crate::serde::ser::SerializeStruct::end(state)
    115    }
    116}
    117
    118#[cfg(feature = "schemars")]
    119impl crate::schemars::JsonSchema for ConfigMapKeySelector {
    120    fn schema_name() -> std::borrow::Cow<'static, str> {
    121        "io.k8s.api.core.v1.ConfigMapKeySelector".into()
    122    }
    123
    124    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
    125        crate::schemars::json_schema!({
    126            "description": "Selects a key from a ConfigMap.",
    127            "type": "object",
    128            "properties": {
    129                "key": {
    130                    "description": "The key to select.",
    131                    "type": "string",
    132                },
    133                "name": {
    134                    "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
    135                    "type": "string",
    136                },
    137                "optional": {
    138                    "description": "Specify whether the ConfigMap or its key must be defined",
    139                    "type": "boolean",
    140                },
    141            },
    142            "required": [
    143                "key",
    144                "name",
    145            ],
    146        })
    147    }
    148}