k8s_openapi/v1_31/api/resource/v1alpha3/
device_allocation_configuration.rs1#[derive(Clone, Debug, Default, PartialEq)]
5pub struct DeviceAllocationConfiguration {
6 pub opaque: Option<crate::api::resource::v1alpha3::OpaqueDeviceConfiguration>,
8
9 pub requests: Option<std::vec::Vec<std::string::String>>,
11
12 pub source: std::string::String,
14}
15
16impl crate::DeepMerge for DeviceAllocationConfiguration {
17 fn merge_from(&mut self, other: Self) {
18 crate::DeepMerge::merge_from(&mut self.opaque, other.opaque);
19 crate::merge_strategies::list::atomic(&mut self.requests, other.requests);
20 crate::DeepMerge::merge_from(&mut self.source, other.source);
21 }
22}
23
24impl<'de> crate::serde::Deserialize<'de> for DeviceAllocationConfiguration {
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_opaque,
29 Key_requests,
30 Key_source,
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 "opaque" => Field::Key_opaque,
48 "requests" => Field::Key_requests,
49 "source" => Field::Key_source,
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 = DeviceAllocationConfiguration;
63
64 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
65 f.write_str("DeviceAllocationConfiguration")
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_opaque: Option<crate::api::resource::v1alpha3::OpaqueDeviceConfiguration> = None;
70 let mut value_requests: Option<std::vec::Vec<std::string::String>> = None;
71 let mut value_source: Option<std::string::String> = None;
72
73 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
74 match key {
75 Field::Key_opaque => value_opaque = crate::serde::de::MapAccess::next_value(&mut map)?,
76 Field::Key_requests => value_requests = crate::serde::de::MapAccess::next_value(&mut map)?,
77 Field::Key_source => value_source = 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(DeviceAllocationConfiguration {
83 opaque: value_opaque,
84 requests: value_requests,
85 source: value_source.unwrap_or_default(),
86 })
87 }
88 }
89
90 deserializer.deserialize_struct(
91 "DeviceAllocationConfiguration",
92 &[
93 "opaque",
94 "requests",
95 "source",
96 ],
97 Visitor,
98 )
99 }
100}
101
102impl crate::serde::Serialize for DeviceAllocationConfiguration {
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 "DeviceAllocationConfiguration",
106 1 +
107 self.opaque.as_ref().map_or(0, |_| 1) +
108 self.requests.as_ref().map_or(0, |_| 1),
109 )?;
110 if let Some(value) = &self.opaque {
111 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "opaque", value)?;
112 }
113 if let Some(value) = &self.requests {
114 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "requests", value)?;
115 }
116 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "source", &self.source)?;
117 crate::serde::ser::SerializeStruct::end(state)
118 }
119}
120
121#[cfg(feature = "schemars")]
122impl crate::schemars::JsonSchema for DeviceAllocationConfiguration {
123 fn schema_name() -> std::borrow::Cow<'static, str> {
124 "io.k8s.api.resource.v1alpha3.DeviceAllocationConfiguration".into()
125 }
126
127 fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
128 crate::schemars::json_schema!({
129 "description": "DeviceAllocationConfiguration gets embedded in an AllocationResult.",
130 "type": "object",
131 "properties": {
132 "opaque": ({
133 let mut schema_obj = __gen.subschema_for::<crate::api::resource::v1alpha3::OpaqueDeviceConfiguration>();
134 schema_obj.ensure_object().insert("description".into(), "Opaque provides driver-specific configuration parameters.".into());
135 schema_obj
136 }),
137 "requests": {
138 "description": "Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.",
139 "type": "array",
140 "items": {
141 "type": "string",
142 },
143 },
144 "source": {
145 "description": "Source records whether the configuration comes from a class and thus is not something that a normal user would have been able to set or from a claim.",
146 "type": "string",
147 },
148 },
149 "required": [
150 "source",
151 ],
152 })
153 }
154}