1#[derive(Clone, Debug, PartialEq)]
11pub enum WatchEvent<T> {
12 Added(T),
13 Deleted(T),
14 Modified(T),
15 Bookmark {
16 annotations: std::collections::BTreeMap<String, String>,
17 resource_version: String,
18 },
19 ErrorStatus(crate::apimachinery::pkg::apis::meta::v1::Status),
20 ErrorOther(crate::apimachinery::pkg::runtime::RawExtension),
21}
22
23impl<'de, T> crate::serde::Deserialize<'de> for WatchEvent<T> where T: crate::serde::Deserialize<'de> {
24 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
25 #[allow(non_camel_case_types)]
26 enum Field {
27 Key_type,
28 Key_object,
29 Other,
30 }
31
32 impl<'de> crate::serde::Deserialize<'de> for Field {
33 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
34 struct Visitor;
35
36 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
37 type Value = Field;
38
39 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
40 f.write_str("field identifier")
41 }
42
43 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
44 Ok(match v {
45 "type" => Field::Key_type,
46 "object" => Field::Key_object,
47 _ => Field::Other,
48 })
49 }
50 }
51
52 deserializer.deserialize_identifier(Visitor)
53 }
54 }
55
56 enum WatchEventType {
57 Added,
58 Deleted,
59 Modified,
60 Bookmark,
61 Error,
62 }
63
64 impl<'de> crate::serde::Deserialize<'de> for WatchEventType {
65 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
66 struct Visitor;
67
68 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
69 type Value = WatchEventType;
70
71 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
72 f.write_str("watch event type")
73 }
74
75 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
76 Ok(match v {
77 "ADDED" => WatchEventType::Added,
78 "DELETED" => WatchEventType::Deleted,
79 "MODIFIED" => WatchEventType::Modified,
80 "BOOKMARK" => WatchEventType::Bookmark,
81 "ERROR" => WatchEventType::Error,
82 _ => return Err(crate::serde::de::Error::unknown_variant(
83 v,
84 &["ADDED", "DELETED", "MODIFIED", "BOOKMARK", "ERROR"],
85 )),
86 })
87 }
88 }
89
90 deserializer.deserialize_identifier(Visitor)
91 }
92 }
93
94 struct Visitor<T>(std::marker::PhantomData<T>);
95
96 impl<'de, T> crate::serde::de::Visitor<'de> for Visitor<T> where T: crate::serde::Deserialize<'de> {
97 type Value = WatchEvent<T>;
98
99 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
100 f.write_str("WatchEvent")
101 }
102
103 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
104 let mut value_type: Option<WatchEventType> = None;
105 let mut value_object: Option<crate::serde_value::Value> = None;
106
107 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
108 match key {
109 Field::Key_type => value_type = crate::serde::de::MapAccess::next_value(&mut map)?,
110 Field::Key_object => value_object = crate::serde::de::MapAccess::next_value(&mut map)?,
111 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
112 }
113 }
114
115 let value_type = value_type.ok_or_else(|| crate::serde::de::Error::missing_field("type"))?;
116 let value_object = value_object.ok_or_else(|| crate::serde::de::Error::missing_field("object"))?;
117
118 Ok(match value_type {
119 WatchEventType::Added => {
120 let value_object = crate::serde_value::ValueDeserializer::new(value_object);
121 WatchEvent::Added(crate::serde::Deserialize::deserialize(value_object)?)
122 },
123 WatchEventType::Deleted => {
124 let value_object = crate::serde_value::ValueDeserializer::new(value_object);
125 WatchEvent::Deleted(crate::serde::Deserialize::deserialize(value_object)?)
126 },
127 WatchEventType::Modified => {
128 let value_object = crate::serde_value::ValueDeserializer::new(value_object);
129 WatchEvent::Modified(crate::serde::Deserialize::deserialize(value_object)?)
130 },
131 WatchEventType::Bookmark => {
132 let value_object = crate::serde_value::ValueDeserializer::new(value_object);
133 let value: BookmarkObject<'static> = crate::serde::Deserialize::deserialize(value_object)?;
134 WatchEvent::Bookmark {
135 annotations: value.metadata.annotations.into_owned(),
136 resource_version: value.metadata.resource_version.into_owned(),
137 }
138 },
139 WatchEventType::Error => {
140 let is_status =
141 if let crate::serde_value::Value::Map(map) = &value_object {
142 matches!(map.get(&crate::serde_value::Value::String("kind".to_owned())), Some(crate::serde_value::Value::String(s)) if s == "Status")
143 }
144 else {
145 false
146 };
147 let value_object = crate::serde_value::ValueDeserializer::new(value_object);
148 if is_status {
149 WatchEvent::ErrorStatus(crate::serde::Deserialize::deserialize(value_object)?)
150 }
151 else {
152 WatchEvent::ErrorOther(crate::serde::Deserialize::deserialize(value_object)?)
153 }
154 },
155 })
156 }
157 }
158
159 deserializer.deserialize_struct(
160 "WatchEvent",
161 &[
162 "type",
163 "object",
164 ],
165 Visitor(Default::default()),
166 )
167 }
168}
169
170impl<T> crate::serde::Serialize for WatchEvent<T> where T: crate::serde::Serialize {
171 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
172 let mut state = serializer.serialize_struct(
173 "WatchEvent",
174 2,
175 )?;
176 match self {
177 WatchEvent::Added(object) => {
178 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", "ADDED")?;
179 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
180 },
181 WatchEvent::Deleted(object) => {
182 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", "DELETED")?;
183 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
184 },
185 WatchEvent::Modified(object) => {
186 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", "MODIFIED")?;
187 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
188 },
189 WatchEvent::Bookmark { annotations, resource_version } => {
190 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", "BOOKMARK")?;
191 let object = BookmarkObject {
192 metadata: BookmarkObjectMeta {
193 annotations: std::borrow::Cow::Borrowed(annotations),
194 resource_version: std::borrow::Cow::Borrowed(&**resource_version),
195 },
196 };
197 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
198 },
199 WatchEvent::ErrorStatus(object) => {
200 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", "ERROR")?;
201 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
202 },
203 WatchEvent::ErrorOther(object) => {
204 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", "ERROR")?;
205 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
206 },
207 }
208 crate::serde::ser::SerializeStruct::end(state)
209 }
210}
211
212#[derive(Debug, PartialEq)]
213struct BookmarkObject<'a> {
214 metadata: BookmarkObjectMeta<'a>,
215}
216
217#[derive(Debug, PartialEq)]
218struct BookmarkObjectMeta<'a> {
219 annotations: std::borrow::Cow<'a, std::collections::BTreeMap<String, String>>,
220 resource_version: std::borrow::Cow<'a, str>,
221}
222
223impl<'de> crate::serde::Deserialize<'de> for BookmarkObject<'static> {
224 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
225 #[allow(non_camel_case_types)]
226 enum Field {
227 Key_metadata,
228 Other,
229 }
230
231 impl<'de> crate::serde::Deserialize<'de> for Field {
232 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
233 struct Visitor;
234
235 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
236 type Value = Field;
237
238 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
239 f.write_str("field identifier")
240 }
241
242 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
243 Ok(match v {
244 "metadata" => Field::Key_metadata,
245 _ => Field::Other,
246 })
247 }
248 }
249
250 deserializer.deserialize_identifier(Visitor)
251 }
252 }
253
254 struct Visitor;
255
256 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
257 type Value = BookmarkObject<'static>;
258
259 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
260 f.write_str("BookmarkObject")
261 }
262
263 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
264 let mut value_metadata: Option<BookmarkObjectMeta<'static>> = None;
265
266 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
267 match key {
268 Field::Key_metadata => value_metadata = crate::serde::de::MapAccess::next_value(&mut map)?,
269 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
270 }
271 }
272
273 Ok(BookmarkObject {
274 metadata: value_metadata.ok_or_else(|| crate::serde::de::Error::missing_field("metadata"))?,
275 })
276 }
277 }
278
279 deserializer.deserialize_struct(
280 "BookmarkObject",
281 &[
282 "annotations",
283 "metadata",
284 ],
285 Visitor,
286 )
287 }
288}
289
290impl<'de> crate::serde::Deserialize<'de> for BookmarkObjectMeta<'static> {
291 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
292 #[allow(non_camel_case_types)]
293 enum Field {
294 Key_annotations,
295 Key_resource_version,
296 Other,
297 }
298
299 impl<'de> crate::serde::Deserialize<'de> for Field {
300 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
301 struct Visitor;
302
303 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
304 type Value = Field;
305
306 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
307 f.write_str("field identifier")
308 }
309
310 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
311 Ok(match v {
312 "annotations" => Field::Key_annotations,
313 "resourceVersion" => Field::Key_resource_version,
314 _ => Field::Other,
315 })
316 }
317 }
318
319 deserializer.deserialize_identifier(Visitor)
320 }
321 }
322
323 struct Visitor;
324
325 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
326 type Value = BookmarkObjectMeta<'static>;
327
328 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
329 f.write_str("ObjectMeta")
330 }
331
332 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
333 let mut value_annotations: Option<std::collections::BTreeMap<String, String>> = None;
334 let mut value_resource_version: Option<String> = None;
335
336 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
337 match key {
338 Field::Key_annotations => value_annotations = crate::serde::de::MapAccess::next_value(&mut map)?,
339 Field::Key_resource_version => value_resource_version = crate::serde::de::MapAccess::next_value(&mut map)?,
340 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
341 }
342 }
343
344 Ok(BookmarkObjectMeta {
345 annotations: std::borrow::Cow::Owned(value_annotations.unwrap_or_default()),
346 resource_version: std::borrow::Cow::Owned(value_resource_version.ok_or_else(|| crate::serde::de::Error::missing_field("resourceVersion"))?),
347 })
348 }
349 }
350
351 deserializer.deserialize_struct(
352 "ObjectMeta",
353 &[
354 "annotations",
355 "resourceVersion",
356 ],
357 Visitor,
358 )
359 }
360}
361
362impl<'a> crate::serde::Serialize for BookmarkObject<'a> {
363 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
364 let mut state = serializer.serialize_struct(
365 "BookmarkObject",
366 1,
367 )?;
368 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
369 crate::serde::ser::SerializeStruct::end(state)
370 }
371}
372
373impl<'a> crate::serde::Serialize for BookmarkObjectMeta<'a> {
374 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
375 let mut state = serializer.serialize_struct(
376 "ObjectMeta",
377 2,
378 )?;
379 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "annotations", &self.annotations)?;
380 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "resourceVersion", &self.resource_version)?;
381 crate::serde::ser::SerializeStruct::end(state)
382 }
383}
384
385
386#[cfg(feature = "schemars")]
387impl<T> crate::schemars::JsonSchema for WatchEvent<T> {
388 fn schema_name() -> String {
389 "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent".to_owned()
390 }
391
392 fn json_schema(__gen: &mut crate::schemars::gen::SchemaGenerator) -> crate::schemars::schema::Schema {
393 crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
394 metadata: Some(Box::new(crate::schemars::schema::Metadata {
395 description: Some("Event represents a single event to a watched resource.\n\nObject is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context.\n".to_owned()),
396 ..Default::default()
397 })),
398 instance_type: Some(crate::schemars::schema::SingleOrVec::Single(Box::new(crate::schemars::schema::InstanceType::Object))),
399 object: Some(Box::new(crate::schemars::schema::ObjectValidation {
400 properties: [
401 (
402 "object".to_owned(),
403 __gen.subschema_for::<crate::apimachinery::pkg::runtime::RawExtension>(),
404 ),
405 (
406 "type".to_owned(),
407 crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
408 instance_type: Some(crate::schemars::schema::SingleOrVec::Single(Box::new(crate::schemars::schema::InstanceType::String))),
409 ..Default::default()
410 }),
411 ),
412 ].into(),
413 required: [
414 "object".to_owned(),
415 "type".to_owned(),
416 ].into(),
417 ..Default::default()
418 })),
419 ..Default::default()
420 })
421 }
422}