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

    1// Generated from definition io.k8s.api.core.v1.LocalObjectReference
    2
    3/// LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.
    4#[derive(Clone, Debug, Default, PartialEq)]
    5pub struct LocalObjectReference {
    6    /// 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
    7    pub name: std::string::String,
    8}
    9
    10impl crate::DeepMerge for LocalObjectReference {
    11    fn merge_from(&mut self, other: Self) {
    12        crate::DeepMerge::merge_from(&mut self.name, other.name);
    13    }
    14}
    15
    16impl<'de> crate::serde::Deserialize<'de> for LocalObjectReference {
    17    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    18        #[allow(non_camel_case_types)]
    19        enum Field {
    20            Key_name,
    21            Other,
    22        }
    23
    24        impl<'de> crate::serde::Deserialize<'de> for Field {
    25            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    26                struct Visitor;
    27
    28                impl crate::serde::de::Visitor<'_> for Visitor {
    29                    type Value = Field;
    30
    31                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    32                        f.write_str("field identifier")
    33                    }
    34
    35                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
    36                        Ok(match v {
    37                            "name" => Field::Key_name,
    38                            _ => Field::Other,
    39                        })
    40                    }
    41                }
    42
    43                deserializer.deserialize_identifier(Visitor)
    44            }
    45        }
    46
    47        struct Visitor;
    48
    49        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
    50            type Value = LocalObjectReference;
    51
    52            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    53                f.write_str("LocalObjectReference")
    54            }
    55
    56            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
    57                let mut value_name: Option<std::string::String> = None;
    58
    59                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
    60                    match key {
    61                        Field::Key_name => value_name = crate::serde::de::MapAccess::next_value(&mut map)?,
    62                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
    63                    }
    64                }
    65
    66                Ok(LocalObjectReference {
    67                    name: value_name.unwrap_or_default(),
    68                })
    69            }
    70        }
    71
    72        deserializer.deserialize_struct(
    73            "LocalObjectReference",
    74            &[
    75                "name",
    76            ],
    77            Visitor,
    78        )
    79    }
    80}
    81
    82impl crate::serde::Serialize for LocalObjectReference {
    83    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
    84        let mut state = serializer.serialize_struct(
    85            "LocalObjectReference",
    86            1,
    87        )?;
    88        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "name", &self.name)?;
    89        crate::serde::ser::SerializeStruct::end(state)
    90    }
    91}
    92
    93#[cfg(feature = "schemars")]
    94impl crate::schemars::JsonSchema for LocalObjectReference {
    95    fn schema_name() -> std::borrow::Cow<'static, str> {
    96        "io.k8s.api.core.v1.LocalObjectReference".into()
    97    }
    98
    99    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
    100        crate::schemars::json_schema!({
    101            "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.",
    102            "type": "object",
    103            "properties": {
    104                "name": {
    105                    "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",
    106                    "type": "string",
    107                },
    108            },
    109            "required": [
    110                "name",
    111            ],
    112        })
    113    }
    114}