openshift_openapi/v4_5/api/authorization/v1/
service_account_reference.rs

1// Generated from definition com.github.openshift.api.authorization.v1.ServiceAccountReference
2
3/// ServiceAccountReference specifies a service account and namespace by their names.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ServiceAccountReference {
6    /// Name is the name of the service account.
7    pub name: String,
8
9    /// Namespace is the namespace of the service account.  Service accounts from inside the whitelisted namespaces are allowed to be bound to roles.  If Namespace is empty, then the namespace of the RoleBindingRestriction in which the ServiceAccountReference is embedded is used.
10    pub namespace: String,
11}
12
13impl<'de> serde::Deserialize<'de> for ServiceAccountReference {
14    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
15        #[allow(non_camel_case_types)]
16        enum Field {
17            Key_name,
18            Key_namespace,
19            Other,
20        }
21
22        impl<'de> serde::Deserialize<'de> for Field {
23            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
24                struct Visitor;
25
26                impl<'de> serde::de::Visitor<'de> for Visitor {
27                    type Value = Field;
28
29                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
30                        f.write_str("field identifier")
31                    }
32
33                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
34                        Ok(match v {
35                            "name" => Field::Key_name,
36                            "namespace" => Field::Key_namespace,
37                            _ => Field::Other,
38                        })
39                    }
40                }
41
42                deserializer.deserialize_identifier(Visitor)
43            }
44        }
45
46        struct Visitor;
47
48        impl<'de> serde::de::Visitor<'de> for Visitor {
49            type Value = ServiceAccountReference;
50
51            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
52                f.write_str("ServiceAccountReference")
53            }
54
55            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
56                let mut value_name: Option<String> = None;
57                let mut value_namespace: Option<String> = None;
58
59                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
60                    match key {
61                        Field::Key_name => value_name = Some(serde::de::MapAccess::next_value(&mut map)?),
62                        Field::Key_namespace => value_namespace = Some(serde::de::MapAccess::next_value(&mut map)?),
63                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
64                    }
65                }
66
67                Ok(ServiceAccountReference {
68                    name: value_name.ok_or_else(|| serde::de::Error::missing_field("name"))?,
69                    namespace: value_namespace.ok_or_else(|| serde::de::Error::missing_field("namespace"))?,
70                })
71            }
72        }
73
74        deserializer.deserialize_struct(
75            "ServiceAccountReference",
76            &[
77                "name",
78                "namespace",
79            ],
80            Visitor,
81        )
82    }
83}
84
85impl serde::Serialize for ServiceAccountReference {
86    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
87        let mut state = serializer.serialize_struct(
88            "ServiceAccountReference",
89            2,
90        )?;
91        serde::ser::SerializeStruct::serialize_field(&mut state, "name", &self.name)?;
92        serde::ser::SerializeStruct::serialize_field(&mut state, "namespace", &self.namespace)?;
93        serde::ser::SerializeStruct::end(state)
94    }
95}