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

    1// Generated from definition io.k8s.api.core.v1.SecretKeySelector
    2
    3/// SecretKeySelector selects a key of a Secret.
    4#[derive(Clone, Debug, Default, PartialEq)]
    5pub struct SecretKeySelector {
    6    /// The key of the secret to select from.  Must be a valid secret key.
    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 Secret or its key must be defined
    13    pub optional: Option<bool>,
    14}
    15
    16impl crate::DeepMerge for SecretKeySelector {
    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 SecretKeySelector {
    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 = SecretKeySelector;
    63
    64            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    65                f.write_str("SecretKeySelector")
    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(SecretKeySelector {
    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            "SecretKeySelector",
    92            &[
    93                "key",
    94                "name",
    95                "optional",
    96            ],
    97            Visitor,
    98        )
    99    }
    100}
    101
    102impl crate::serde::Serialize for SecretKeySelector {
    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            "SecretKeySelector",
    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 SecretKeySelector {
    120    fn schema_name() -> std::borrow::Cow<'static, str> {
    121        "io.k8s.api.core.v1.SecretKeySelector".into()
    122    }
    123
    124    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
    125        crate::schemars::json_schema!({
    126            "description": "SecretKeySelector selects a key of a Secret.",
    127            "type": "object",
    128            "properties": {
    129                "key": {
    130                    "description": "The key of the secret to select from.  Must be a valid secret key.",
    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 Secret or its key must be defined",
    139                    "type": "boolean",
    140                },
    141            },
    142            "required": [
    143                "key",
    144                "name",
    145            ],
    146        })
    147    }
    148}