1#![allow(clippy::useless_conversion)]
2use crate::telemetry::*;
3impl serde::Serialize for BatchEventMessage {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.events.is_empty() {
12 len += 1;
13 }
14 let mut struct_ser = serializer.serialize_struct("telemetry.BatchEventMessage", len)?;
15 if !self.events.is_empty() {
16 struct_ser.serialize_field("events", &self.events)?;
17 }
18 struct_ser.end()
19 }
20}
21impl<'de> serde::Deserialize<'de> for BatchEventMessage {
22 #[allow(deprecated)]
23 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
24 where
25 D: serde::Deserializer<'de>,
26 {
27 const FIELDS: &[&str] = &[
28 "events",
29 ];
30
31 #[allow(clippy::enum_variant_names)]
32 enum GeneratedField {
33 Events,
34 }
35 impl<'de> serde::Deserialize<'de> for GeneratedField {
36 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
37 where
38 D: serde::Deserializer<'de>,
39 {
40 struct GeneratedVisitor;
41
42 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
43 type Value = GeneratedField;
44
45 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
46 write!(formatter, "expected one of: {:?}", &FIELDS)
47 }
48
49 #[allow(unused_variables)]
50 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
51 where
52 E: serde::de::Error,
53 {
54 match value {
55 "events" => Ok(GeneratedField::Events),
56 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
57 }
58 }
59 }
60 deserializer.deserialize_identifier(GeneratedVisitor)
61 }
62 }
63 struct GeneratedVisitor;
64 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
65 type Value = BatchEventMessage;
66
67 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68 formatter.write_str("struct telemetry.BatchEventMessage")
69 }
70
71 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchEventMessage, V::Error>
72 where
73 V: serde::de::MapAccess<'de>,
74 {
75 let mut events__ = None;
76 while let Some(k) = map_.next_key()? {
77 match k {
78 GeneratedField::Events => {
79 if events__.is_some() {
80 return Err(serde::de::Error::duplicate_field("events"));
81 }
82 events__ = Some(map_.next_value()?);
83 }
84 }
85 }
86 Ok(BatchEventMessage {
87 events: events__.unwrap_or_default(),
88 })
89 }
90 }
91 deserializer.deserialize_struct("telemetry.BatchEventMessage", FIELDS, GeneratedVisitor)
92 }
93}
94impl serde::Serialize for CompactorReport {
95 #[allow(deprecated)]
96 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
97 where
98 S: serde::Serializer,
99 {
100 use serde::ser::SerializeStruct;
101 let mut len = 0;
102 if self.base.is_some() {
103 len += 1;
104 }
105 let mut struct_ser = serializer.serialize_struct("telemetry.CompactorReport", len)?;
106 if let Some(v) = self.base.as_ref() {
107 struct_ser.serialize_field("base", v)?;
108 }
109 struct_ser.end()
110 }
111}
112impl<'de> serde::Deserialize<'de> for CompactorReport {
113 #[allow(deprecated)]
114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
115 where
116 D: serde::Deserializer<'de>,
117 {
118 const FIELDS: &[&str] = &[
119 "base",
120 ];
121
122 #[allow(clippy::enum_variant_names)]
123 enum GeneratedField {
124 Base,
125 }
126 impl<'de> serde::Deserialize<'de> for GeneratedField {
127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
128 where
129 D: serde::Deserializer<'de>,
130 {
131 struct GeneratedVisitor;
132
133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
134 type Value = GeneratedField;
135
136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
137 write!(formatter, "expected one of: {:?}", &FIELDS)
138 }
139
140 #[allow(unused_variables)]
141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
142 where
143 E: serde::de::Error,
144 {
145 match value {
146 "base" => Ok(GeneratedField::Base),
147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
148 }
149 }
150 }
151 deserializer.deserialize_identifier(GeneratedVisitor)
152 }
153 }
154 struct GeneratedVisitor;
155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
156 type Value = CompactorReport;
157
158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
159 formatter.write_str("struct telemetry.CompactorReport")
160 }
161
162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactorReport, V::Error>
163 where
164 V: serde::de::MapAccess<'de>,
165 {
166 let mut base__ = None;
167 while let Some(k) = map_.next_key()? {
168 match k {
169 GeneratedField::Base => {
170 if base__.is_some() {
171 return Err(serde::de::Error::duplicate_field("base"));
172 }
173 base__ = map_.next_value()?;
174 }
175 }
176 }
177 Ok(CompactorReport {
178 base: base__,
179 })
180 }
181 }
182 deserializer.deserialize_struct("telemetry.CompactorReport", FIELDS, GeneratedVisitor)
183 }
184}
185impl serde::Serialize for ComputeReport {
186 #[allow(deprecated)]
187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
188 where
189 S: serde::Serializer,
190 {
191 use serde::ser::SerializeStruct;
192 let mut len = 0;
193 if self.base.is_some() {
194 len += 1;
195 }
196 let mut struct_ser = serializer.serialize_struct("telemetry.ComputeReport", len)?;
197 if let Some(v) = self.base.as_ref() {
198 struct_ser.serialize_field("base", v)?;
199 }
200 struct_ser.end()
201 }
202}
203impl<'de> serde::Deserialize<'de> for ComputeReport {
204 #[allow(deprecated)]
205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
206 where
207 D: serde::Deserializer<'de>,
208 {
209 const FIELDS: &[&str] = &[
210 "base",
211 ];
212
213 #[allow(clippy::enum_variant_names)]
214 enum GeneratedField {
215 Base,
216 }
217 impl<'de> serde::Deserialize<'de> for GeneratedField {
218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
219 where
220 D: serde::Deserializer<'de>,
221 {
222 struct GeneratedVisitor;
223
224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
225 type Value = GeneratedField;
226
227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
228 write!(formatter, "expected one of: {:?}", &FIELDS)
229 }
230
231 #[allow(unused_variables)]
232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
233 where
234 E: serde::de::Error,
235 {
236 match value {
237 "base" => Ok(GeneratedField::Base),
238 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
239 }
240 }
241 }
242 deserializer.deserialize_identifier(GeneratedVisitor)
243 }
244 }
245 struct GeneratedVisitor;
246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
247 type Value = ComputeReport;
248
249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
250 formatter.write_str("struct telemetry.ComputeReport")
251 }
252
253 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ComputeReport, V::Error>
254 where
255 V: serde::de::MapAccess<'de>,
256 {
257 let mut base__ = None;
258 while let Some(k) = map_.next_key()? {
259 match k {
260 GeneratedField::Base => {
261 if base__.is_some() {
262 return Err(serde::de::Error::duplicate_field("base"));
263 }
264 base__ = map_.next_value()?;
265 }
266 }
267 }
268 Ok(ComputeReport {
269 base: base__,
270 })
271 }
272 }
273 deserializer.deserialize_struct("telemetry.ComputeReport", FIELDS, GeneratedVisitor)
274 }
275}
276impl serde::Serialize for EventMessage {
277 #[allow(deprecated)]
278 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
279 where
280 S: serde::Serializer,
281 {
282 use serde::ser::SerializeStruct;
283 let mut len = 0;
284 if !self.tracking_id.is_empty() {
285 len += 1;
286 }
287 if self.event_time_sec != 0 {
288 len += 1;
289 }
290 if self.event_stage != 0 {
291 len += 1;
292 }
293 if !self.event_name.is_empty() {
294 len += 1;
295 }
296 if self.connector_name.is_some() {
297 len += 1;
298 }
299 if self.object.is_some() {
300 len += 1;
301 }
302 if self.catalog_id != 0 {
303 len += 1;
304 }
305 if self.attributes.is_some() {
306 len += 1;
307 }
308 if !self.node.is_empty() {
309 len += 1;
310 }
311 if self.is_test {
312 len += 1;
313 }
314 let mut struct_ser = serializer.serialize_struct("telemetry.EventMessage", len)?;
315 if !self.tracking_id.is_empty() {
316 struct_ser.serialize_field("trackingId", &self.tracking_id)?;
317 }
318 if self.event_time_sec != 0 {
319 #[allow(clippy::needless_borrow)]
320 #[allow(clippy::needless_borrows_for_generic_args)]
321 struct_ser.serialize_field("eventTimeSec", ToString::to_string(&self.event_time_sec).as_str())?;
322 }
323 if self.event_stage != 0 {
324 let v = TelemetryEventStage::try_from(self.event_stage)
325 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.event_stage)))?;
326 struct_ser.serialize_field("eventStage", &v)?;
327 }
328 if !self.event_name.is_empty() {
329 struct_ser.serialize_field("eventName", &self.event_name)?;
330 }
331 if let Some(v) = self.connector_name.as_ref() {
332 struct_ser.serialize_field("connectorName", v)?;
333 }
334 if let Some(v) = self.object.as_ref() {
335 let v = TelemetryDatabaseObject::try_from(*v)
336 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
337 struct_ser.serialize_field("object", &v)?;
338 }
339 if self.catalog_id != 0 {
340 #[allow(clippy::needless_borrow)]
341 #[allow(clippy::needless_borrows_for_generic_args)]
342 struct_ser.serialize_field("catalogId", ToString::to_string(&self.catalog_id).as_str())?;
343 }
344 if let Some(v) = self.attributes.as_ref() {
345 struct_ser.serialize_field("attributes", v)?;
346 }
347 if !self.node.is_empty() {
348 struct_ser.serialize_field("node", &self.node)?;
349 }
350 if self.is_test {
351 struct_ser.serialize_field("isTest", &self.is_test)?;
352 }
353 struct_ser.end()
354 }
355}
356impl<'de> serde::Deserialize<'de> for EventMessage {
357 #[allow(deprecated)]
358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
359 where
360 D: serde::Deserializer<'de>,
361 {
362 const FIELDS: &[&str] = &[
363 "tracking_id",
364 "trackingId",
365 "event_time_sec",
366 "eventTimeSec",
367 "event_stage",
368 "eventStage",
369 "event_name",
370 "eventName",
371 "connector_name",
372 "connectorName",
373 "object",
374 "catalog_id",
375 "catalogId",
376 "attributes",
377 "node",
378 "is_test",
379 "isTest",
380 ];
381
382 #[allow(clippy::enum_variant_names)]
383 enum GeneratedField {
384 TrackingId,
385 EventTimeSec,
386 EventStage,
387 EventName,
388 ConnectorName,
389 Object,
390 CatalogId,
391 Attributes,
392 Node,
393 IsTest,
394 }
395 impl<'de> serde::Deserialize<'de> for GeneratedField {
396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
397 where
398 D: serde::Deserializer<'de>,
399 {
400 struct GeneratedVisitor;
401
402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
403 type Value = GeneratedField;
404
405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
406 write!(formatter, "expected one of: {:?}", &FIELDS)
407 }
408
409 #[allow(unused_variables)]
410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
411 where
412 E: serde::de::Error,
413 {
414 match value {
415 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
416 "eventTimeSec" | "event_time_sec" => Ok(GeneratedField::EventTimeSec),
417 "eventStage" | "event_stage" => Ok(GeneratedField::EventStage),
418 "eventName" | "event_name" => Ok(GeneratedField::EventName),
419 "connectorName" | "connector_name" => Ok(GeneratedField::ConnectorName),
420 "object" => Ok(GeneratedField::Object),
421 "catalogId" | "catalog_id" => Ok(GeneratedField::CatalogId),
422 "attributes" => Ok(GeneratedField::Attributes),
423 "node" => Ok(GeneratedField::Node),
424 "isTest" | "is_test" => Ok(GeneratedField::IsTest),
425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
426 }
427 }
428 }
429 deserializer.deserialize_identifier(GeneratedVisitor)
430 }
431 }
432 struct GeneratedVisitor;
433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
434 type Value = EventMessage;
435
436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
437 formatter.write_str("struct telemetry.EventMessage")
438 }
439
440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventMessage, V::Error>
441 where
442 V: serde::de::MapAccess<'de>,
443 {
444 let mut tracking_id__ = None;
445 let mut event_time_sec__ = None;
446 let mut event_stage__ = None;
447 let mut event_name__ = None;
448 let mut connector_name__ = None;
449 let mut object__ = None;
450 let mut catalog_id__ = None;
451 let mut attributes__ = None;
452 let mut node__ = None;
453 let mut is_test__ = None;
454 while let Some(k) = map_.next_key()? {
455 match k {
456 GeneratedField::TrackingId => {
457 if tracking_id__.is_some() {
458 return Err(serde::de::Error::duplicate_field("trackingId"));
459 }
460 tracking_id__ = Some(map_.next_value()?);
461 }
462 GeneratedField::EventTimeSec => {
463 if event_time_sec__.is_some() {
464 return Err(serde::de::Error::duplicate_field("eventTimeSec"));
465 }
466 event_time_sec__ =
467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
468 ;
469 }
470 GeneratedField::EventStage => {
471 if event_stage__.is_some() {
472 return Err(serde::de::Error::duplicate_field("eventStage"));
473 }
474 event_stage__ = Some(map_.next_value::<TelemetryEventStage>()? as i32);
475 }
476 GeneratedField::EventName => {
477 if event_name__.is_some() {
478 return Err(serde::de::Error::duplicate_field("eventName"));
479 }
480 event_name__ = Some(map_.next_value()?);
481 }
482 GeneratedField::ConnectorName => {
483 if connector_name__.is_some() {
484 return Err(serde::de::Error::duplicate_field("connectorName"));
485 }
486 connector_name__ = map_.next_value()?;
487 }
488 GeneratedField::Object => {
489 if object__.is_some() {
490 return Err(serde::de::Error::duplicate_field("object"));
491 }
492 object__ = map_.next_value::<::std::option::Option<TelemetryDatabaseObject>>()?.map(|x| x as i32);
493 }
494 GeneratedField::CatalogId => {
495 if catalog_id__.is_some() {
496 return Err(serde::de::Error::duplicate_field("catalogId"));
497 }
498 catalog_id__ =
499 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
500 ;
501 }
502 GeneratedField::Attributes => {
503 if attributes__.is_some() {
504 return Err(serde::de::Error::duplicate_field("attributes"));
505 }
506 attributes__ = map_.next_value()?;
507 }
508 GeneratedField::Node => {
509 if node__.is_some() {
510 return Err(serde::de::Error::duplicate_field("node"));
511 }
512 node__ = Some(map_.next_value()?);
513 }
514 GeneratedField::IsTest => {
515 if is_test__.is_some() {
516 return Err(serde::de::Error::duplicate_field("isTest"));
517 }
518 is_test__ = Some(map_.next_value()?);
519 }
520 }
521 }
522 Ok(EventMessage {
523 tracking_id: tracking_id__.unwrap_or_default(),
524 event_time_sec: event_time_sec__.unwrap_or_default(),
525 event_stage: event_stage__.unwrap_or_default(),
526 event_name: event_name__.unwrap_or_default(),
527 connector_name: connector_name__,
528 object: object__,
529 catalog_id: catalog_id__.unwrap_or_default(),
530 attributes: attributes__,
531 node: node__.unwrap_or_default(),
532 is_test: is_test__.unwrap_or_default(),
533 })
534 }
535 }
536 deserializer.deserialize_struct("telemetry.EventMessage", FIELDS, GeneratedVisitor)
537 }
538}
539impl serde::Serialize for FrontendReport {
540 #[allow(deprecated)]
541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
542 where
543 S: serde::Serializer,
544 {
545 use serde::ser::SerializeStruct;
546 let mut len = 0;
547 if self.base.is_some() {
548 len += 1;
549 }
550 let mut struct_ser = serializer.serialize_struct("telemetry.FrontendReport", len)?;
551 if let Some(v) = self.base.as_ref() {
552 struct_ser.serialize_field("base", v)?;
553 }
554 struct_ser.end()
555 }
556}
557impl<'de> serde::Deserialize<'de> for FrontendReport {
558 #[allow(deprecated)]
559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
560 where
561 D: serde::Deserializer<'de>,
562 {
563 const FIELDS: &[&str] = &[
564 "base",
565 ];
566
567 #[allow(clippy::enum_variant_names)]
568 enum GeneratedField {
569 Base,
570 }
571 impl<'de> serde::Deserialize<'de> for GeneratedField {
572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
573 where
574 D: serde::Deserializer<'de>,
575 {
576 struct GeneratedVisitor;
577
578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
579 type Value = GeneratedField;
580
581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
582 write!(formatter, "expected one of: {:?}", &FIELDS)
583 }
584
585 #[allow(unused_variables)]
586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
587 where
588 E: serde::de::Error,
589 {
590 match value {
591 "base" => Ok(GeneratedField::Base),
592 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
593 }
594 }
595 }
596 deserializer.deserialize_identifier(GeneratedVisitor)
597 }
598 }
599 struct GeneratedVisitor;
600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
601 type Value = FrontendReport;
602
603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
604 formatter.write_str("struct telemetry.FrontendReport")
605 }
606
607 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FrontendReport, V::Error>
608 where
609 V: serde::de::MapAccess<'de>,
610 {
611 let mut base__ = None;
612 while let Some(k) = map_.next_key()? {
613 match k {
614 GeneratedField::Base => {
615 if base__.is_some() {
616 return Err(serde::de::Error::duplicate_field("base"));
617 }
618 base__ = map_.next_value()?;
619 }
620 }
621 }
622 Ok(FrontendReport {
623 base: base__,
624 })
625 }
626 }
627 deserializer.deserialize_struct("telemetry.FrontendReport", FIELDS, GeneratedVisitor)
628 }
629}
630impl serde::Serialize for MetaBackend {
631 #[allow(deprecated)]
632 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
633 where
634 S: serde::Serializer,
635 {
636 let variant = match self {
637 Self::Unspecified => "META_BACKEND_UNSPECIFIED",
638 Self::Memory => "META_BACKEND_MEMORY",
639 Self::Etcd => "META_BACKEND_ETCD",
640 Self::Rdb => "META_BACKEND_RDB",
641 };
642 serializer.serialize_str(variant)
643 }
644}
645impl<'de> serde::Deserialize<'de> for MetaBackend {
646 #[allow(deprecated)]
647 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
648 where
649 D: serde::Deserializer<'de>,
650 {
651 const FIELDS: &[&str] = &[
652 "META_BACKEND_UNSPECIFIED",
653 "META_BACKEND_MEMORY",
654 "META_BACKEND_ETCD",
655 "META_BACKEND_RDB",
656 ];
657
658 struct GeneratedVisitor;
659
660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
661 type Value = MetaBackend;
662
663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
664 write!(formatter, "expected one of: {:?}", &FIELDS)
665 }
666
667 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
668 where
669 E: serde::de::Error,
670 {
671 i32::try_from(v)
672 .ok()
673 .and_then(|x| x.try_into().ok())
674 .ok_or_else(|| {
675 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
676 })
677 }
678
679 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
680 where
681 E: serde::de::Error,
682 {
683 i32::try_from(v)
684 .ok()
685 .and_then(|x| x.try_into().ok())
686 .ok_or_else(|| {
687 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
688 })
689 }
690
691 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
692 where
693 E: serde::de::Error,
694 {
695 match value {
696 "META_BACKEND_UNSPECIFIED" => Ok(MetaBackend::Unspecified),
697 "META_BACKEND_MEMORY" => Ok(MetaBackend::Memory),
698 "META_BACKEND_ETCD" => Ok(MetaBackend::Etcd),
699 "META_BACKEND_RDB" => Ok(MetaBackend::Rdb),
700 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
701 }
702 }
703 }
704 deserializer.deserialize_any(GeneratedVisitor)
705 }
706}
707impl serde::Serialize for MetaReport {
708 #[allow(deprecated)]
709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
710 where
711 S: serde::Serializer,
712 {
713 use serde::ser::SerializeStruct;
714 let mut len = 0;
715 if self.base.is_some() {
716 len += 1;
717 }
718 if self.meta_backend != 0 {
719 len += 1;
720 }
721 if self.node_count.is_some() {
722 len += 1;
723 }
724 if self.rw_version.is_some() {
725 len += 1;
726 }
727 if self.stream_job_count != 0 {
728 len += 1;
729 }
730 if !self.stream_jobs.is_empty() {
731 len += 1;
732 }
733 if self.cluster_type != 0 {
734 len += 1;
735 }
736 if !self.object_store_media_type.is_empty() {
737 len += 1;
738 }
739 if !self.connector_usage_json_str.is_empty() {
740 len += 1;
741 }
742 if !self.license_info_json_str.is_empty() {
743 len += 1;
744 }
745 let mut struct_ser = serializer.serialize_struct("telemetry.MetaReport", len)?;
746 if let Some(v) = self.base.as_ref() {
747 struct_ser.serialize_field("base", v)?;
748 }
749 if self.meta_backend != 0 {
750 let v = MetaBackend::try_from(self.meta_backend)
751 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.meta_backend)))?;
752 struct_ser.serialize_field("metaBackend", &v)?;
753 }
754 if let Some(v) = self.node_count.as_ref() {
755 struct_ser.serialize_field("nodeCount", v)?;
756 }
757 if let Some(v) = self.rw_version.as_ref() {
758 struct_ser.serialize_field("rwVersion", v)?;
759 }
760 if self.stream_job_count != 0 {
761 struct_ser.serialize_field("streamJobCount", &self.stream_job_count)?;
762 }
763 if !self.stream_jobs.is_empty() {
764 struct_ser.serialize_field("streamJobs", &self.stream_jobs)?;
765 }
766 if self.cluster_type != 0 {
767 let v = TelemetryClusterType::try_from(self.cluster_type)
768 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cluster_type)))?;
769 struct_ser.serialize_field("clusterType", &v)?;
770 }
771 if !self.object_store_media_type.is_empty() {
772 struct_ser.serialize_field("objectStoreMediaType", &self.object_store_media_type)?;
773 }
774 if !self.connector_usage_json_str.is_empty() {
775 struct_ser.serialize_field("connectorUsageJsonStr", &self.connector_usage_json_str)?;
776 }
777 if !self.license_info_json_str.is_empty() {
778 struct_ser.serialize_field("licenseInfoJsonStr", &self.license_info_json_str)?;
779 }
780 struct_ser.end()
781 }
782}
783impl<'de> serde::Deserialize<'de> for MetaReport {
784 #[allow(deprecated)]
785 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
786 where
787 D: serde::Deserializer<'de>,
788 {
789 const FIELDS: &[&str] = &[
790 "base",
791 "meta_backend",
792 "metaBackend",
793 "node_count",
794 "nodeCount",
795 "rw_version",
796 "rwVersion",
797 "stream_job_count",
798 "streamJobCount",
799 "stream_jobs",
800 "streamJobs",
801 "cluster_type",
802 "clusterType",
803 "object_store_media_type",
804 "objectStoreMediaType",
805 "connector_usage_json_str",
806 "connectorUsageJsonStr",
807 "license_info_json_str",
808 "licenseInfoJsonStr",
809 ];
810
811 #[allow(clippy::enum_variant_names)]
812 enum GeneratedField {
813 Base,
814 MetaBackend,
815 NodeCount,
816 RwVersion,
817 StreamJobCount,
818 StreamJobs,
819 ClusterType,
820 ObjectStoreMediaType,
821 ConnectorUsageJsonStr,
822 LicenseInfoJsonStr,
823 }
824 impl<'de> serde::Deserialize<'de> for GeneratedField {
825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
826 where
827 D: serde::Deserializer<'de>,
828 {
829 struct GeneratedVisitor;
830
831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
832 type Value = GeneratedField;
833
834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
835 write!(formatter, "expected one of: {:?}", &FIELDS)
836 }
837
838 #[allow(unused_variables)]
839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
840 where
841 E: serde::de::Error,
842 {
843 match value {
844 "base" => Ok(GeneratedField::Base),
845 "metaBackend" | "meta_backend" => Ok(GeneratedField::MetaBackend),
846 "nodeCount" | "node_count" => Ok(GeneratedField::NodeCount),
847 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
848 "streamJobCount" | "stream_job_count" => Ok(GeneratedField::StreamJobCount),
849 "streamJobs" | "stream_jobs" => Ok(GeneratedField::StreamJobs),
850 "clusterType" | "cluster_type" => Ok(GeneratedField::ClusterType),
851 "objectStoreMediaType" | "object_store_media_type" => Ok(GeneratedField::ObjectStoreMediaType),
852 "connectorUsageJsonStr" | "connector_usage_json_str" => Ok(GeneratedField::ConnectorUsageJsonStr),
853 "licenseInfoJsonStr" | "license_info_json_str" => Ok(GeneratedField::LicenseInfoJsonStr),
854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
855 }
856 }
857 }
858 deserializer.deserialize_identifier(GeneratedVisitor)
859 }
860 }
861 struct GeneratedVisitor;
862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
863 type Value = MetaReport;
864
865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
866 formatter.write_str("struct telemetry.MetaReport")
867 }
868
869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaReport, V::Error>
870 where
871 V: serde::de::MapAccess<'de>,
872 {
873 let mut base__ = None;
874 let mut meta_backend__ = None;
875 let mut node_count__ = None;
876 let mut rw_version__ = None;
877 let mut stream_job_count__ = None;
878 let mut stream_jobs__ = None;
879 let mut cluster_type__ = None;
880 let mut object_store_media_type__ = None;
881 let mut connector_usage_json_str__ = None;
882 let mut license_info_json_str__ = None;
883 while let Some(k) = map_.next_key()? {
884 match k {
885 GeneratedField::Base => {
886 if base__.is_some() {
887 return Err(serde::de::Error::duplicate_field("base"));
888 }
889 base__ = map_.next_value()?;
890 }
891 GeneratedField::MetaBackend => {
892 if meta_backend__.is_some() {
893 return Err(serde::de::Error::duplicate_field("metaBackend"));
894 }
895 meta_backend__ = Some(map_.next_value::<MetaBackend>()? as i32);
896 }
897 GeneratedField::NodeCount => {
898 if node_count__.is_some() {
899 return Err(serde::de::Error::duplicate_field("nodeCount"));
900 }
901 node_count__ = map_.next_value()?;
902 }
903 GeneratedField::RwVersion => {
904 if rw_version__.is_some() {
905 return Err(serde::de::Error::duplicate_field("rwVersion"));
906 }
907 rw_version__ = map_.next_value()?;
908 }
909 GeneratedField::StreamJobCount => {
910 if stream_job_count__.is_some() {
911 return Err(serde::de::Error::duplicate_field("streamJobCount"));
912 }
913 stream_job_count__ =
914 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
915 ;
916 }
917 GeneratedField::StreamJobs => {
918 if stream_jobs__.is_some() {
919 return Err(serde::de::Error::duplicate_field("streamJobs"));
920 }
921 stream_jobs__ = Some(map_.next_value()?);
922 }
923 GeneratedField::ClusterType => {
924 if cluster_type__.is_some() {
925 return Err(serde::de::Error::duplicate_field("clusterType"));
926 }
927 cluster_type__ = Some(map_.next_value::<TelemetryClusterType>()? as i32);
928 }
929 GeneratedField::ObjectStoreMediaType => {
930 if object_store_media_type__.is_some() {
931 return Err(serde::de::Error::duplicate_field("objectStoreMediaType"));
932 }
933 object_store_media_type__ = Some(map_.next_value()?);
934 }
935 GeneratedField::ConnectorUsageJsonStr => {
936 if connector_usage_json_str__.is_some() {
937 return Err(serde::de::Error::duplicate_field("connectorUsageJsonStr"));
938 }
939 connector_usage_json_str__ = Some(map_.next_value()?);
940 }
941 GeneratedField::LicenseInfoJsonStr => {
942 if license_info_json_str__.is_some() {
943 return Err(serde::de::Error::duplicate_field("licenseInfoJsonStr"));
944 }
945 license_info_json_str__ = Some(map_.next_value()?);
946 }
947 }
948 }
949 Ok(MetaReport {
950 base: base__,
951 meta_backend: meta_backend__.unwrap_or_default(),
952 node_count: node_count__,
953 rw_version: rw_version__,
954 stream_job_count: stream_job_count__.unwrap_or_default(),
955 stream_jobs: stream_jobs__.unwrap_or_default(),
956 cluster_type: cluster_type__.unwrap_or_default(),
957 object_store_media_type: object_store_media_type__.unwrap_or_default(),
958 connector_usage_json_str: connector_usage_json_str__.unwrap_or_default(),
959 license_info_json_str: license_info_json_str__.unwrap_or_default(),
960 })
961 }
962 }
963 deserializer.deserialize_struct("telemetry.MetaReport", FIELDS, GeneratedVisitor)
964 }
965}
966impl serde::Serialize for NodeCount {
967 #[allow(deprecated)]
968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
969 where
970 S: serde::Serializer,
971 {
972 use serde::ser::SerializeStruct;
973 let mut len = 0;
974 if self.meta != 0 {
975 len += 1;
976 }
977 if self.compute != 0 {
978 len += 1;
979 }
980 if self.frontend != 0 {
981 len += 1;
982 }
983 if self.compactor != 0 {
984 len += 1;
985 }
986 let mut struct_ser = serializer.serialize_struct("telemetry.NodeCount", len)?;
987 if self.meta != 0 {
988 struct_ser.serialize_field("meta", &self.meta)?;
989 }
990 if self.compute != 0 {
991 struct_ser.serialize_field("compute", &self.compute)?;
992 }
993 if self.frontend != 0 {
994 struct_ser.serialize_field("frontend", &self.frontend)?;
995 }
996 if self.compactor != 0 {
997 struct_ser.serialize_field("compactor", &self.compactor)?;
998 }
999 struct_ser.end()
1000 }
1001}
1002impl<'de> serde::Deserialize<'de> for NodeCount {
1003 #[allow(deprecated)]
1004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1005 where
1006 D: serde::Deserializer<'de>,
1007 {
1008 const FIELDS: &[&str] = &[
1009 "meta",
1010 "compute",
1011 "frontend",
1012 "compactor",
1013 ];
1014
1015 #[allow(clippy::enum_variant_names)]
1016 enum GeneratedField {
1017 Meta,
1018 Compute,
1019 Frontend,
1020 Compactor,
1021 }
1022 impl<'de> serde::Deserialize<'de> for GeneratedField {
1023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1024 where
1025 D: serde::Deserializer<'de>,
1026 {
1027 struct GeneratedVisitor;
1028
1029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1030 type Value = GeneratedField;
1031
1032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1033 write!(formatter, "expected one of: {:?}", &FIELDS)
1034 }
1035
1036 #[allow(unused_variables)]
1037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1038 where
1039 E: serde::de::Error,
1040 {
1041 match value {
1042 "meta" => Ok(GeneratedField::Meta),
1043 "compute" => Ok(GeneratedField::Compute),
1044 "frontend" => Ok(GeneratedField::Frontend),
1045 "compactor" => Ok(GeneratedField::Compactor),
1046 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1047 }
1048 }
1049 }
1050 deserializer.deserialize_identifier(GeneratedVisitor)
1051 }
1052 }
1053 struct GeneratedVisitor;
1054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1055 type Value = NodeCount;
1056
1057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1058 formatter.write_str("struct telemetry.NodeCount")
1059 }
1060
1061 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NodeCount, V::Error>
1062 where
1063 V: serde::de::MapAccess<'de>,
1064 {
1065 let mut meta__ = None;
1066 let mut compute__ = None;
1067 let mut frontend__ = None;
1068 let mut compactor__ = None;
1069 while let Some(k) = map_.next_key()? {
1070 match k {
1071 GeneratedField::Meta => {
1072 if meta__.is_some() {
1073 return Err(serde::de::Error::duplicate_field("meta"));
1074 }
1075 meta__ =
1076 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1077 ;
1078 }
1079 GeneratedField::Compute => {
1080 if compute__.is_some() {
1081 return Err(serde::de::Error::duplicate_field("compute"));
1082 }
1083 compute__ =
1084 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1085 ;
1086 }
1087 GeneratedField::Frontend => {
1088 if frontend__.is_some() {
1089 return Err(serde::de::Error::duplicate_field("frontend"));
1090 }
1091 frontend__ =
1092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1093 ;
1094 }
1095 GeneratedField::Compactor => {
1096 if compactor__.is_some() {
1097 return Err(serde::de::Error::duplicate_field("compactor"));
1098 }
1099 compactor__ =
1100 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1101 ;
1102 }
1103 }
1104 }
1105 Ok(NodeCount {
1106 meta: meta__.unwrap_or_default(),
1107 compute: compute__.unwrap_or_default(),
1108 frontend: frontend__.unwrap_or_default(),
1109 compactor: compactor__.unwrap_or_default(),
1110 })
1111 }
1112 }
1113 deserializer.deserialize_struct("telemetry.NodeCount", FIELDS, GeneratedVisitor)
1114 }
1115}
1116impl serde::Serialize for PlanOptimization {
1117 #[allow(deprecated)]
1118 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1119 where
1120 S: serde::Serializer,
1121 {
1122 let variant = match self {
1123 Self::TableOptimizationUnspecified => "TABLE_OPTIMIZATION_UNSPECIFIED",
1124 };
1125 serializer.serialize_str(variant)
1126 }
1127}
1128impl<'de> serde::Deserialize<'de> for PlanOptimization {
1129 #[allow(deprecated)]
1130 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1131 where
1132 D: serde::Deserializer<'de>,
1133 {
1134 const FIELDS: &[&str] = &[
1135 "TABLE_OPTIMIZATION_UNSPECIFIED",
1136 ];
1137
1138 struct GeneratedVisitor;
1139
1140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1141 type Value = PlanOptimization;
1142
1143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1144 write!(formatter, "expected one of: {:?}", &FIELDS)
1145 }
1146
1147 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1148 where
1149 E: serde::de::Error,
1150 {
1151 i32::try_from(v)
1152 .ok()
1153 .and_then(|x| x.try_into().ok())
1154 .ok_or_else(|| {
1155 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1156 })
1157 }
1158
1159 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1160 where
1161 E: serde::de::Error,
1162 {
1163 i32::try_from(v)
1164 .ok()
1165 .and_then(|x| x.try_into().ok())
1166 .ok_or_else(|| {
1167 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1168 })
1169 }
1170
1171 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1172 where
1173 E: serde::de::Error,
1174 {
1175 match value {
1176 "TABLE_OPTIMIZATION_UNSPECIFIED" => Ok(PlanOptimization::TableOptimizationUnspecified),
1177 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1178 }
1179 }
1180 }
1181 deserializer.deserialize_any(GeneratedVisitor)
1182 }
1183}
1184impl serde::Serialize for ReportBase {
1185 #[allow(deprecated)]
1186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1187 where
1188 S: serde::Serializer,
1189 {
1190 use serde::ser::SerializeStruct;
1191 let mut len = 0;
1192 if !self.tracking_id.is_empty() {
1193 len += 1;
1194 }
1195 if !self.session_id.is_empty() {
1196 len += 1;
1197 }
1198 if self.system_data.is_some() {
1199 len += 1;
1200 }
1201 if self.up_time != 0 {
1202 len += 1;
1203 }
1204 if self.report_time != 0 {
1205 len += 1;
1206 }
1207 if self.node_type != 0 {
1208 len += 1;
1209 }
1210 if self.is_test {
1211 len += 1;
1212 }
1213 let mut struct_ser = serializer.serialize_struct("telemetry.ReportBase", len)?;
1214 if !self.tracking_id.is_empty() {
1215 struct_ser.serialize_field("trackingId", &self.tracking_id)?;
1216 }
1217 if !self.session_id.is_empty() {
1218 struct_ser.serialize_field("sessionId", &self.session_id)?;
1219 }
1220 if let Some(v) = self.system_data.as_ref() {
1221 struct_ser.serialize_field("systemData", v)?;
1222 }
1223 if self.up_time != 0 {
1224 #[allow(clippy::needless_borrow)]
1225 #[allow(clippy::needless_borrows_for_generic_args)]
1226 struct_ser.serialize_field("upTime", ToString::to_string(&self.up_time).as_str())?;
1227 }
1228 if self.report_time != 0 {
1229 #[allow(clippy::needless_borrow)]
1230 #[allow(clippy::needless_borrows_for_generic_args)]
1231 struct_ser.serialize_field("reportTime", ToString::to_string(&self.report_time).as_str())?;
1232 }
1233 if self.node_type != 0 {
1234 let v = TelemetryNodeType::try_from(self.node_type)
1235 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.node_type)))?;
1236 struct_ser.serialize_field("nodeType", &v)?;
1237 }
1238 if self.is_test {
1239 struct_ser.serialize_field("isTest", &self.is_test)?;
1240 }
1241 struct_ser.end()
1242 }
1243}
1244impl<'de> serde::Deserialize<'de> for ReportBase {
1245 #[allow(deprecated)]
1246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1247 where
1248 D: serde::Deserializer<'de>,
1249 {
1250 const FIELDS: &[&str] = &[
1251 "tracking_id",
1252 "trackingId",
1253 "session_id",
1254 "sessionId",
1255 "system_data",
1256 "systemData",
1257 "up_time",
1258 "upTime",
1259 "report_time",
1260 "reportTime",
1261 "node_type",
1262 "nodeType",
1263 "is_test",
1264 "isTest",
1265 ];
1266
1267 #[allow(clippy::enum_variant_names)]
1268 enum GeneratedField {
1269 TrackingId,
1270 SessionId,
1271 SystemData,
1272 UpTime,
1273 ReportTime,
1274 NodeType,
1275 IsTest,
1276 }
1277 impl<'de> serde::Deserialize<'de> for GeneratedField {
1278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1279 where
1280 D: serde::Deserializer<'de>,
1281 {
1282 struct GeneratedVisitor;
1283
1284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1285 type Value = GeneratedField;
1286
1287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1288 write!(formatter, "expected one of: {:?}", &FIELDS)
1289 }
1290
1291 #[allow(unused_variables)]
1292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1293 where
1294 E: serde::de::Error,
1295 {
1296 match value {
1297 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
1298 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
1299 "systemData" | "system_data" => Ok(GeneratedField::SystemData),
1300 "upTime" | "up_time" => Ok(GeneratedField::UpTime),
1301 "reportTime" | "report_time" => Ok(GeneratedField::ReportTime),
1302 "nodeType" | "node_type" => Ok(GeneratedField::NodeType),
1303 "isTest" | "is_test" => Ok(GeneratedField::IsTest),
1304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1305 }
1306 }
1307 }
1308 deserializer.deserialize_identifier(GeneratedVisitor)
1309 }
1310 }
1311 struct GeneratedVisitor;
1312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1313 type Value = ReportBase;
1314
1315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1316 formatter.write_str("struct telemetry.ReportBase")
1317 }
1318
1319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportBase, V::Error>
1320 where
1321 V: serde::de::MapAccess<'de>,
1322 {
1323 let mut tracking_id__ = None;
1324 let mut session_id__ = None;
1325 let mut system_data__ = None;
1326 let mut up_time__ = None;
1327 let mut report_time__ = None;
1328 let mut node_type__ = None;
1329 let mut is_test__ = None;
1330 while let Some(k) = map_.next_key()? {
1331 match k {
1332 GeneratedField::TrackingId => {
1333 if tracking_id__.is_some() {
1334 return Err(serde::de::Error::duplicate_field("trackingId"));
1335 }
1336 tracking_id__ = Some(map_.next_value()?);
1337 }
1338 GeneratedField::SessionId => {
1339 if session_id__.is_some() {
1340 return Err(serde::de::Error::duplicate_field("sessionId"));
1341 }
1342 session_id__ = Some(map_.next_value()?);
1343 }
1344 GeneratedField::SystemData => {
1345 if system_data__.is_some() {
1346 return Err(serde::de::Error::duplicate_field("systemData"));
1347 }
1348 system_data__ = map_.next_value()?;
1349 }
1350 GeneratedField::UpTime => {
1351 if up_time__.is_some() {
1352 return Err(serde::de::Error::duplicate_field("upTime"));
1353 }
1354 up_time__ =
1355 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1356 ;
1357 }
1358 GeneratedField::ReportTime => {
1359 if report_time__.is_some() {
1360 return Err(serde::de::Error::duplicate_field("reportTime"));
1361 }
1362 report_time__ =
1363 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1364 ;
1365 }
1366 GeneratedField::NodeType => {
1367 if node_type__.is_some() {
1368 return Err(serde::de::Error::duplicate_field("nodeType"));
1369 }
1370 node_type__ = Some(map_.next_value::<TelemetryNodeType>()? as i32);
1371 }
1372 GeneratedField::IsTest => {
1373 if is_test__.is_some() {
1374 return Err(serde::de::Error::duplicate_field("isTest"));
1375 }
1376 is_test__ = Some(map_.next_value()?);
1377 }
1378 }
1379 }
1380 Ok(ReportBase {
1381 tracking_id: tracking_id__.unwrap_or_default(),
1382 session_id: session_id__.unwrap_or_default(),
1383 system_data: system_data__,
1384 up_time: up_time__.unwrap_or_default(),
1385 report_time: report_time__.unwrap_or_default(),
1386 node_type: node_type__.unwrap_or_default(),
1387 is_test: is_test__.unwrap_or_default(),
1388 })
1389 }
1390 }
1391 deserializer.deserialize_struct("telemetry.ReportBase", FIELDS, GeneratedVisitor)
1392 }
1393}
1394impl serde::Serialize for RwVersion {
1395 #[allow(deprecated)]
1396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1397 where
1398 S: serde::Serializer,
1399 {
1400 use serde::ser::SerializeStruct;
1401 let mut len = 0;
1402 if !self.rw_version.is_empty() {
1403 len += 1;
1404 }
1405 if !self.git_sha.is_empty() {
1406 len += 1;
1407 }
1408 let mut struct_ser = serializer.serialize_struct("telemetry.RwVersion", len)?;
1409 if !self.rw_version.is_empty() {
1410 struct_ser.serialize_field("rwVersion", &self.rw_version)?;
1411 }
1412 if !self.git_sha.is_empty() {
1413 struct_ser.serialize_field("gitSha", &self.git_sha)?;
1414 }
1415 struct_ser.end()
1416 }
1417}
1418impl<'de> serde::Deserialize<'de> for RwVersion {
1419 #[allow(deprecated)]
1420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1421 where
1422 D: serde::Deserializer<'de>,
1423 {
1424 const FIELDS: &[&str] = &[
1425 "rw_version",
1426 "rwVersion",
1427 "git_sha",
1428 "gitSha",
1429 ];
1430
1431 #[allow(clippy::enum_variant_names)]
1432 enum GeneratedField {
1433 RwVersion,
1434 GitSha,
1435 }
1436 impl<'de> serde::Deserialize<'de> for GeneratedField {
1437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1438 where
1439 D: serde::Deserializer<'de>,
1440 {
1441 struct GeneratedVisitor;
1442
1443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1444 type Value = GeneratedField;
1445
1446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1447 write!(formatter, "expected one of: {:?}", &FIELDS)
1448 }
1449
1450 #[allow(unused_variables)]
1451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1452 where
1453 E: serde::de::Error,
1454 {
1455 match value {
1456 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
1457 "gitSha" | "git_sha" => Ok(GeneratedField::GitSha),
1458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1459 }
1460 }
1461 }
1462 deserializer.deserialize_identifier(GeneratedVisitor)
1463 }
1464 }
1465 struct GeneratedVisitor;
1466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1467 type Value = RwVersion;
1468
1469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1470 formatter.write_str("struct telemetry.RwVersion")
1471 }
1472
1473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RwVersion, V::Error>
1474 where
1475 V: serde::de::MapAccess<'de>,
1476 {
1477 let mut rw_version__ = None;
1478 let mut git_sha__ = None;
1479 while let Some(k) = map_.next_key()? {
1480 match k {
1481 GeneratedField::RwVersion => {
1482 if rw_version__.is_some() {
1483 return Err(serde::de::Error::duplicate_field("rwVersion"));
1484 }
1485 rw_version__ = Some(map_.next_value()?);
1486 }
1487 GeneratedField::GitSha => {
1488 if git_sha__.is_some() {
1489 return Err(serde::de::Error::duplicate_field("gitSha"));
1490 }
1491 git_sha__ = Some(map_.next_value()?);
1492 }
1493 }
1494 }
1495 Ok(RwVersion {
1496 rw_version: rw_version__.unwrap_or_default(),
1497 git_sha: git_sha__.unwrap_or_default(),
1498 })
1499 }
1500 }
1501 deserializer.deserialize_struct("telemetry.RwVersion", FIELDS, GeneratedVisitor)
1502 }
1503}
1504impl serde::Serialize for StreamJobDesc {
1505 #[allow(deprecated)]
1506 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1507 where
1508 S: serde::Serializer,
1509 {
1510 use serde::ser::SerializeStruct;
1511 let mut len = 0;
1512 if self.table_id != 0 {
1513 len += 1;
1514 }
1515 if self.connector_name.is_some() {
1516 len += 1;
1517 }
1518 if !self.plan_optimizations.is_empty() {
1519 len += 1;
1520 }
1521 let mut struct_ser = serializer.serialize_struct("telemetry.StreamJobDesc", len)?;
1522 if self.table_id != 0 {
1523 struct_ser.serialize_field("tableId", &self.table_id)?;
1524 }
1525 if let Some(v) = self.connector_name.as_ref() {
1526 struct_ser.serialize_field("connectorName", v)?;
1527 }
1528 if !self.plan_optimizations.is_empty() {
1529 let v = self.plan_optimizations.iter().cloned().map(|v| {
1530 PlanOptimization::try_from(v)
1531 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
1532 }).collect::<std::result::Result<Vec<_>, _>>()?;
1533 struct_ser.serialize_field("planOptimizations", &v)?;
1534 }
1535 struct_ser.end()
1536 }
1537}
1538impl<'de> serde::Deserialize<'de> for StreamJobDesc {
1539 #[allow(deprecated)]
1540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1541 where
1542 D: serde::Deserializer<'de>,
1543 {
1544 const FIELDS: &[&str] = &[
1545 "table_id",
1546 "tableId",
1547 "connector_name",
1548 "connectorName",
1549 "plan_optimizations",
1550 "planOptimizations",
1551 ];
1552
1553 #[allow(clippy::enum_variant_names)]
1554 enum GeneratedField {
1555 TableId,
1556 ConnectorName,
1557 PlanOptimizations,
1558 }
1559 impl<'de> serde::Deserialize<'de> for GeneratedField {
1560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1561 where
1562 D: serde::Deserializer<'de>,
1563 {
1564 struct GeneratedVisitor;
1565
1566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1567 type Value = GeneratedField;
1568
1569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1570 write!(formatter, "expected one of: {:?}", &FIELDS)
1571 }
1572
1573 #[allow(unused_variables)]
1574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1575 where
1576 E: serde::de::Error,
1577 {
1578 match value {
1579 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1580 "connectorName" | "connector_name" => Ok(GeneratedField::ConnectorName),
1581 "planOptimizations" | "plan_optimizations" => Ok(GeneratedField::PlanOptimizations),
1582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1583 }
1584 }
1585 }
1586 deserializer.deserialize_identifier(GeneratedVisitor)
1587 }
1588 }
1589 struct GeneratedVisitor;
1590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1591 type Value = StreamJobDesc;
1592
1593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1594 formatter.write_str("struct telemetry.StreamJobDesc")
1595 }
1596
1597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamJobDesc, V::Error>
1598 where
1599 V: serde::de::MapAccess<'de>,
1600 {
1601 let mut table_id__ = None;
1602 let mut connector_name__ = None;
1603 let mut plan_optimizations__ = None;
1604 while let Some(k) = map_.next_key()? {
1605 match k {
1606 GeneratedField::TableId => {
1607 if table_id__.is_some() {
1608 return Err(serde::de::Error::duplicate_field("tableId"));
1609 }
1610 table_id__ =
1611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1612 ;
1613 }
1614 GeneratedField::ConnectorName => {
1615 if connector_name__.is_some() {
1616 return Err(serde::de::Error::duplicate_field("connectorName"));
1617 }
1618 connector_name__ = map_.next_value()?;
1619 }
1620 GeneratedField::PlanOptimizations => {
1621 if plan_optimizations__.is_some() {
1622 return Err(serde::de::Error::duplicate_field("planOptimizations"));
1623 }
1624 plan_optimizations__ = Some(map_.next_value::<Vec<PlanOptimization>>()?.into_iter().map(|x| x as i32).collect());
1625 }
1626 }
1627 }
1628 Ok(StreamJobDesc {
1629 table_id: table_id__.unwrap_or_default(),
1630 connector_name: connector_name__,
1631 plan_optimizations: plan_optimizations__.unwrap_or_default(),
1632 })
1633 }
1634 }
1635 deserializer.deserialize_struct("telemetry.StreamJobDesc", FIELDS, GeneratedVisitor)
1636 }
1637}
1638impl serde::Serialize for SystemCpu {
1639 #[allow(deprecated)]
1640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1641 where
1642 S: serde::Serializer,
1643 {
1644 use serde::ser::SerializeStruct;
1645 let mut len = 0;
1646 if self.available != 0. {
1647 len += 1;
1648 }
1649 let mut struct_ser = serializer.serialize_struct("telemetry.SystemCpu", len)?;
1650 if self.available != 0. {
1651 struct_ser.serialize_field("available", &self.available)?;
1652 }
1653 struct_ser.end()
1654 }
1655}
1656impl<'de> serde::Deserialize<'de> for SystemCpu {
1657 #[allow(deprecated)]
1658 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1659 where
1660 D: serde::Deserializer<'de>,
1661 {
1662 const FIELDS: &[&str] = &[
1663 "available",
1664 ];
1665
1666 #[allow(clippy::enum_variant_names)]
1667 enum GeneratedField {
1668 Available,
1669 }
1670 impl<'de> serde::Deserialize<'de> for GeneratedField {
1671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1672 where
1673 D: serde::Deserializer<'de>,
1674 {
1675 struct GeneratedVisitor;
1676
1677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1678 type Value = GeneratedField;
1679
1680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1681 write!(formatter, "expected one of: {:?}", &FIELDS)
1682 }
1683
1684 #[allow(unused_variables)]
1685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1686 where
1687 E: serde::de::Error,
1688 {
1689 match value {
1690 "available" => Ok(GeneratedField::Available),
1691 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1692 }
1693 }
1694 }
1695 deserializer.deserialize_identifier(GeneratedVisitor)
1696 }
1697 }
1698 struct GeneratedVisitor;
1699 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1700 type Value = SystemCpu;
1701
1702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1703 formatter.write_str("struct telemetry.SystemCpu")
1704 }
1705
1706 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemCpu, V::Error>
1707 where
1708 V: serde::de::MapAccess<'de>,
1709 {
1710 let mut available__ = None;
1711 while let Some(k) = map_.next_key()? {
1712 match k {
1713 GeneratedField::Available => {
1714 if available__.is_some() {
1715 return Err(serde::de::Error::duplicate_field("available"));
1716 }
1717 available__ =
1718 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1719 ;
1720 }
1721 }
1722 }
1723 Ok(SystemCpu {
1724 available: available__.unwrap_or_default(),
1725 })
1726 }
1727 }
1728 deserializer.deserialize_struct("telemetry.SystemCpu", FIELDS, GeneratedVisitor)
1729 }
1730}
1731impl serde::Serialize for SystemData {
1732 #[allow(deprecated)]
1733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1734 where
1735 S: serde::Serializer,
1736 {
1737 use serde::ser::SerializeStruct;
1738 let mut len = 0;
1739 if self.memory.is_some() {
1740 len += 1;
1741 }
1742 if self.os.is_some() {
1743 len += 1;
1744 }
1745 if self.cpu.is_some() {
1746 len += 1;
1747 }
1748 let mut struct_ser = serializer.serialize_struct("telemetry.SystemData", len)?;
1749 if let Some(v) = self.memory.as_ref() {
1750 struct_ser.serialize_field("memory", v)?;
1751 }
1752 if let Some(v) = self.os.as_ref() {
1753 struct_ser.serialize_field("os", v)?;
1754 }
1755 if let Some(v) = self.cpu.as_ref() {
1756 struct_ser.serialize_field("cpu", v)?;
1757 }
1758 struct_ser.end()
1759 }
1760}
1761impl<'de> serde::Deserialize<'de> for SystemData {
1762 #[allow(deprecated)]
1763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1764 where
1765 D: serde::Deserializer<'de>,
1766 {
1767 const FIELDS: &[&str] = &[
1768 "memory",
1769 "os",
1770 "cpu",
1771 ];
1772
1773 #[allow(clippy::enum_variant_names)]
1774 enum GeneratedField {
1775 Memory,
1776 Os,
1777 Cpu,
1778 }
1779 impl<'de> serde::Deserialize<'de> for GeneratedField {
1780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1781 where
1782 D: serde::Deserializer<'de>,
1783 {
1784 struct GeneratedVisitor;
1785
1786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1787 type Value = GeneratedField;
1788
1789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1790 write!(formatter, "expected one of: {:?}", &FIELDS)
1791 }
1792
1793 #[allow(unused_variables)]
1794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1795 where
1796 E: serde::de::Error,
1797 {
1798 match value {
1799 "memory" => Ok(GeneratedField::Memory),
1800 "os" => Ok(GeneratedField::Os),
1801 "cpu" => Ok(GeneratedField::Cpu),
1802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1803 }
1804 }
1805 }
1806 deserializer.deserialize_identifier(GeneratedVisitor)
1807 }
1808 }
1809 struct GeneratedVisitor;
1810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1811 type Value = SystemData;
1812
1813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1814 formatter.write_str("struct telemetry.SystemData")
1815 }
1816
1817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemData, V::Error>
1818 where
1819 V: serde::de::MapAccess<'de>,
1820 {
1821 let mut memory__ = None;
1822 let mut os__ = None;
1823 let mut cpu__ = None;
1824 while let Some(k) = map_.next_key()? {
1825 match k {
1826 GeneratedField::Memory => {
1827 if memory__.is_some() {
1828 return Err(serde::de::Error::duplicate_field("memory"));
1829 }
1830 memory__ = map_.next_value()?;
1831 }
1832 GeneratedField::Os => {
1833 if os__.is_some() {
1834 return Err(serde::de::Error::duplicate_field("os"));
1835 }
1836 os__ = map_.next_value()?;
1837 }
1838 GeneratedField::Cpu => {
1839 if cpu__.is_some() {
1840 return Err(serde::de::Error::duplicate_field("cpu"));
1841 }
1842 cpu__ = map_.next_value()?;
1843 }
1844 }
1845 }
1846 Ok(SystemData {
1847 memory: memory__,
1848 os: os__,
1849 cpu: cpu__,
1850 })
1851 }
1852 }
1853 deserializer.deserialize_struct("telemetry.SystemData", FIELDS, GeneratedVisitor)
1854 }
1855}
1856impl serde::Serialize for SystemMemory {
1857 #[allow(deprecated)]
1858 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1859 where
1860 S: serde::Serializer,
1861 {
1862 use serde::ser::SerializeStruct;
1863 let mut len = 0;
1864 if self.used != 0 {
1865 len += 1;
1866 }
1867 if self.total != 0 {
1868 len += 1;
1869 }
1870 let mut struct_ser = serializer.serialize_struct("telemetry.SystemMemory", len)?;
1871 if self.used != 0 {
1872 #[allow(clippy::needless_borrow)]
1873 #[allow(clippy::needless_borrows_for_generic_args)]
1874 struct_ser.serialize_field("used", ToString::to_string(&self.used).as_str())?;
1875 }
1876 if self.total != 0 {
1877 #[allow(clippy::needless_borrow)]
1878 #[allow(clippy::needless_borrows_for_generic_args)]
1879 struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?;
1880 }
1881 struct_ser.end()
1882 }
1883}
1884impl<'de> serde::Deserialize<'de> for SystemMemory {
1885 #[allow(deprecated)]
1886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1887 where
1888 D: serde::Deserializer<'de>,
1889 {
1890 const FIELDS: &[&str] = &[
1891 "used",
1892 "total",
1893 ];
1894
1895 #[allow(clippy::enum_variant_names)]
1896 enum GeneratedField {
1897 Used,
1898 Total,
1899 }
1900 impl<'de> serde::Deserialize<'de> for GeneratedField {
1901 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1902 where
1903 D: serde::Deserializer<'de>,
1904 {
1905 struct GeneratedVisitor;
1906
1907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1908 type Value = GeneratedField;
1909
1910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1911 write!(formatter, "expected one of: {:?}", &FIELDS)
1912 }
1913
1914 #[allow(unused_variables)]
1915 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1916 where
1917 E: serde::de::Error,
1918 {
1919 match value {
1920 "used" => Ok(GeneratedField::Used),
1921 "total" => Ok(GeneratedField::Total),
1922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1923 }
1924 }
1925 }
1926 deserializer.deserialize_identifier(GeneratedVisitor)
1927 }
1928 }
1929 struct GeneratedVisitor;
1930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1931 type Value = SystemMemory;
1932
1933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1934 formatter.write_str("struct telemetry.SystemMemory")
1935 }
1936
1937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemMemory, V::Error>
1938 where
1939 V: serde::de::MapAccess<'de>,
1940 {
1941 let mut used__ = None;
1942 let mut total__ = None;
1943 while let Some(k) = map_.next_key()? {
1944 match k {
1945 GeneratedField::Used => {
1946 if used__.is_some() {
1947 return Err(serde::de::Error::duplicate_field("used"));
1948 }
1949 used__ =
1950 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1951 ;
1952 }
1953 GeneratedField::Total => {
1954 if total__.is_some() {
1955 return Err(serde::de::Error::duplicate_field("total"));
1956 }
1957 total__ =
1958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1959 ;
1960 }
1961 }
1962 }
1963 Ok(SystemMemory {
1964 used: used__.unwrap_or_default(),
1965 total: total__.unwrap_or_default(),
1966 })
1967 }
1968 }
1969 deserializer.deserialize_struct("telemetry.SystemMemory", FIELDS, GeneratedVisitor)
1970 }
1971}
1972impl serde::Serialize for SystemOs {
1973 #[allow(deprecated)]
1974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1975 where
1976 S: serde::Serializer,
1977 {
1978 use serde::ser::SerializeStruct;
1979 let mut len = 0;
1980 if !self.name.is_empty() {
1981 len += 1;
1982 }
1983 if !self.version.is_empty() {
1984 len += 1;
1985 }
1986 if !self.kernel_version.is_empty() {
1987 len += 1;
1988 }
1989 let mut struct_ser = serializer.serialize_struct("telemetry.SystemOs", len)?;
1990 if !self.name.is_empty() {
1991 struct_ser.serialize_field("name", &self.name)?;
1992 }
1993 if !self.version.is_empty() {
1994 struct_ser.serialize_field("version", &self.version)?;
1995 }
1996 if !self.kernel_version.is_empty() {
1997 struct_ser.serialize_field("kernelVersion", &self.kernel_version)?;
1998 }
1999 struct_ser.end()
2000 }
2001}
2002impl<'de> serde::Deserialize<'de> for SystemOs {
2003 #[allow(deprecated)]
2004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2005 where
2006 D: serde::Deserializer<'de>,
2007 {
2008 const FIELDS: &[&str] = &[
2009 "name",
2010 "version",
2011 "kernel_version",
2012 "kernelVersion",
2013 ];
2014
2015 #[allow(clippy::enum_variant_names)]
2016 enum GeneratedField {
2017 Name,
2018 Version,
2019 KernelVersion,
2020 }
2021 impl<'de> serde::Deserialize<'de> for GeneratedField {
2022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2023 where
2024 D: serde::Deserializer<'de>,
2025 {
2026 struct GeneratedVisitor;
2027
2028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2029 type Value = GeneratedField;
2030
2031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2032 write!(formatter, "expected one of: {:?}", &FIELDS)
2033 }
2034
2035 #[allow(unused_variables)]
2036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2037 where
2038 E: serde::de::Error,
2039 {
2040 match value {
2041 "name" => Ok(GeneratedField::Name),
2042 "version" => Ok(GeneratedField::Version),
2043 "kernelVersion" | "kernel_version" => Ok(GeneratedField::KernelVersion),
2044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2045 }
2046 }
2047 }
2048 deserializer.deserialize_identifier(GeneratedVisitor)
2049 }
2050 }
2051 struct GeneratedVisitor;
2052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2053 type Value = SystemOs;
2054
2055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2056 formatter.write_str("struct telemetry.SystemOs")
2057 }
2058
2059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemOs, V::Error>
2060 where
2061 V: serde::de::MapAccess<'de>,
2062 {
2063 let mut name__ = None;
2064 let mut version__ = None;
2065 let mut kernel_version__ = None;
2066 while let Some(k) = map_.next_key()? {
2067 match k {
2068 GeneratedField::Name => {
2069 if name__.is_some() {
2070 return Err(serde::de::Error::duplicate_field("name"));
2071 }
2072 name__ = Some(map_.next_value()?);
2073 }
2074 GeneratedField::Version => {
2075 if version__.is_some() {
2076 return Err(serde::de::Error::duplicate_field("version"));
2077 }
2078 version__ = Some(map_.next_value()?);
2079 }
2080 GeneratedField::KernelVersion => {
2081 if kernel_version__.is_some() {
2082 return Err(serde::de::Error::duplicate_field("kernelVersion"));
2083 }
2084 kernel_version__ = Some(map_.next_value()?);
2085 }
2086 }
2087 }
2088 Ok(SystemOs {
2089 name: name__.unwrap_or_default(),
2090 version: version__.unwrap_or_default(),
2091 kernel_version: kernel_version__.unwrap_or_default(),
2092 })
2093 }
2094 }
2095 deserializer.deserialize_struct("telemetry.SystemOs", FIELDS, GeneratedVisitor)
2096 }
2097}
2098impl serde::Serialize for TelemetryClusterType {
2099 #[allow(deprecated)]
2100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2101 where
2102 S: serde::Serializer,
2103 {
2104 let variant = match self {
2105 Self::Unspecified => "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED",
2106 Self::SingleNode => "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE",
2107 Self::DockerCompose => "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE",
2108 Self::Kubernetes => "TELEMETRY_CLUSTER_TYPE_KUBERNETES",
2109 Self::CloudHosted => "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED",
2110 };
2111 serializer.serialize_str(variant)
2112 }
2113}
2114impl<'de> serde::Deserialize<'de> for TelemetryClusterType {
2115 #[allow(deprecated)]
2116 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2117 where
2118 D: serde::Deserializer<'de>,
2119 {
2120 const FIELDS: &[&str] = &[
2121 "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED",
2122 "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE",
2123 "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE",
2124 "TELEMETRY_CLUSTER_TYPE_KUBERNETES",
2125 "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED",
2126 ];
2127
2128 struct GeneratedVisitor;
2129
2130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2131 type Value = TelemetryClusterType;
2132
2133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2134 write!(formatter, "expected one of: {:?}", &FIELDS)
2135 }
2136
2137 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2138 where
2139 E: serde::de::Error,
2140 {
2141 i32::try_from(v)
2142 .ok()
2143 .and_then(|x| x.try_into().ok())
2144 .ok_or_else(|| {
2145 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2146 })
2147 }
2148
2149 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2150 where
2151 E: serde::de::Error,
2152 {
2153 i32::try_from(v)
2154 .ok()
2155 .and_then(|x| x.try_into().ok())
2156 .ok_or_else(|| {
2157 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2158 })
2159 }
2160
2161 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2162 where
2163 E: serde::de::Error,
2164 {
2165 match value {
2166 "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED" => Ok(TelemetryClusterType::Unspecified),
2167 "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE" => Ok(TelemetryClusterType::SingleNode),
2168 "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE" => Ok(TelemetryClusterType::DockerCompose),
2169 "TELEMETRY_CLUSTER_TYPE_KUBERNETES" => Ok(TelemetryClusterType::Kubernetes),
2170 "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED" => Ok(TelemetryClusterType::CloudHosted),
2171 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2172 }
2173 }
2174 }
2175 deserializer.deserialize_any(GeneratedVisitor)
2176 }
2177}
2178impl serde::Serialize for TelemetryDatabaseObject {
2179 #[allow(deprecated)]
2180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2181 where
2182 S: serde::Serializer,
2183 {
2184 let variant = match self {
2185 Self::Unspecified => "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED",
2186 Self::Source => "TELEMETRY_DATABASE_OBJECT_SOURCE",
2187 Self::Mv => "TELEMETRY_DATABASE_OBJECT_MV",
2188 Self::Table => "TELEMETRY_DATABASE_OBJECT_TABLE",
2189 Self::Sink => "TELEMETRY_DATABASE_OBJECT_SINK",
2190 Self::Index => "TELEMETRY_DATABASE_OBJECT_INDEX",
2191 };
2192 serializer.serialize_str(variant)
2193 }
2194}
2195impl<'de> serde::Deserialize<'de> for TelemetryDatabaseObject {
2196 #[allow(deprecated)]
2197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2198 where
2199 D: serde::Deserializer<'de>,
2200 {
2201 const FIELDS: &[&str] = &[
2202 "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED",
2203 "TELEMETRY_DATABASE_OBJECT_SOURCE",
2204 "TELEMETRY_DATABASE_OBJECT_MV",
2205 "TELEMETRY_DATABASE_OBJECT_TABLE",
2206 "TELEMETRY_DATABASE_OBJECT_SINK",
2207 "TELEMETRY_DATABASE_OBJECT_INDEX",
2208 ];
2209
2210 struct GeneratedVisitor;
2211
2212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2213 type Value = TelemetryDatabaseObject;
2214
2215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2216 write!(formatter, "expected one of: {:?}", &FIELDS)
2217 }
2218
2219 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2220 where
2221 E: serde::de::Error,
2222 {
2223 i32::try_from(v)
2224 .ok()
2225 .and_then(|x| x.try_into().ok())
2226 .ok_or_else(|| {
2227 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2228 })
2229 }
2230
2231 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2232 where
2233 E: serde::de::Error,
2234 {
2235 i32::try_from(v)
2236 .ok()
2237 .and_then(|x| x.try_into().ok())
2238 .ok_or_else(|| {
2239 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2240 })
2241 }
2242
2243 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2244 where
2245 E: serde::de::Error,
2246 {
2247 match value {
2248 "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED" => Ok(TelemetryDatabaseObject::Unspecified),
2249 "TELEMETRY_DATABASE_OBJECT_SOURCE" => Ok(TelemetryDatabaseObject::Source),
2250 "TELEMETRY_DATABASE_OBJECT_MV" => Ok(TelemetryDatabaseObject::Mv),
2251 "TELEMETRY_DATABASE_OBJECT_TABLE" => Ok(TelemetryDatabaseObject::Table),
2252 "TELEMETRY_DATABASE_OBJECT_SINK" => Ok(TelemetryDatabaseObject::Sink),
2253 "TELEMETRY_DATABASE_OBJECT_INDEX" => Ok(TelemetryDatabaseObject::Index),
2254 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2255 }
2256 }
2257 }
2258 deserializer.deserialize_any(GeneratedVisitor)
2259 }
2260}
2261impl serde::Serialize for TelemetryEventStage {
2262 #[allow(deprecated)]
2263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2264 where
2265 S: serde::Serializer,
2266 {
2267 let variant = match self {
2268 Self::Unspecified => "TELEMETRY_EVENT_STAGE_UNSPECIFIED",
2269 Self::CreateStreamJob => "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB",
2270 Self::UpdateStreamJob => "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB",
2271 Self::DropStreamJob => "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB",
2272 Self::Query => "TELEMETRY_EVENT_STAGE_QUERY",
2273 Self::Recovery => "TELEMETRY_EVENT_STAGE_RECOVERY",
2274 };
2275 serializer.serialize_str(variant)
2276 }
2277}
2278impl<'de> serde::Deserialize<'de> for TelemetryEventStage {
2279 #[allow(deprecated)]
2280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2281 where
2282 D: serde::Deserializer<'de>,
2283 {
2284 const FIELDS: &[&str] = &[
2285 "TELEMETRY_EVENT_STAGE_UNSPECIFIED",
2286 "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB",
2287 "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB",
2288 "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB",
2289 "TELEMETRY_EVENT_STAGE_QUERY",
2290 "TELEMETRY_EVENT_STAGE_RECOVERY",
2291 ];
2292
2293 struct GeneratedVisitor;
2294
2295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2296 type Value = TelemetryEventStage;
2297
2298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2299 write!(formatter, "expected one of: {:?}", &FIELDS)
2300 }
2301
2302 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2303 where
2304 E: serde::de::Error,
2305 {
2306 i32::try_from(v)
2307 .ok()
2308 .and_then(|x| x.try_into().ok())
2309 .ok_or_else(|| {
2310 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2311 })
2312 }
2313
2314 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2315 where
2316 E: serde::de::Error,
2317 {
2318 i32::try_from(v)
2319 .ok()
2320 .and_then(|x| x.try_into().ok())
2321 .ok_or_else(|| {
2322 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2323 })
2324 }
2325
2326 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2327 where
2328 E: serde::de::Error,
2329 {
2330 match value {
2331 "TELEMETRY_EVENT_STAGE_UNSPECIFIED" => Ok(TelemetryEventStage::Unspecified),
2332 "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB" => Ok(TelemetryEventStage::CreateStreamJob),
2333 "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB" => Ok(TelemetryEventStage::UpdateStreamJob),
2334 "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB" => Ok(TelemetryEventStage::DropStreamJob),
2335 "TELEMETRY_EVENT_STAGE_QUERY" => Ok(TelemetryEventStage::Query),
2336 "TELEMETRY_EVENT_STAGE_RECOVERY" => Ok(TelemetryEventStage::Recovery),
2337 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2338 }
2339 }
2340 }
2341 deserializer.deserialize_any(GeneratedVisitor)
2342 }
2343}
2344impl serde::Serialize for TelemetryNodeType {
2345 #[allow(deprecated)]
2346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2347 where
2348 S: serde::Serializer,
2349 {
2350 let variant = match self {
2351 Self::Unspecified => "TELEMETRY_NODE_TYPE_UNSPECIFIED",
2352 Self::Meta => "TELEMETRY_NODE_TYPE_META",
2353 Self::Compute => "TELEMETRY_NODE_TYPE_COMPUTE",
2354 Self::Frontend => "TELEMETRY_NODE_TYPE_FRONTEND",
2355 Self::Compactor => "TELEMETRY_NODE_TYPE_COMPACTOR",
2356 };
2357 serializer.serialize_str(variant)
2358 }
2359}
2360impl<'de> serde::Deserialize<'de> for TelemetryNodeType {
2361 #[allow(deprecated)]
2362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2363 where
2364 D: serde::Deserializer<'de>,
2365 {
2366 const FIELDS: &[&str] = &[
2367 "TELEMETRY_NODE_TYPE_UNSPECIFIED",
2368 "TELEMETRY_NODE_TYPE_META",
2369 "TELEMETRY_NODE_TYPE_COMPUTE",
2370 "TELEMETRY_NODE_TYPE_FRONTEND",
2371 "TELEMETRY_NODE_TYPE_COMPACTOR",
2372 ];
2373
2374 struct GeneratedVisitor;
2375
2376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2377 type Value = TelemetryNodeType;
2378
2379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2380 write!(formatter, "expected one of: {:?}", &FIELDS)
2381 }
2382
2383 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2384 where
2385 E: serde::de::Error,
2386 {
2387 i32::try_from(v)
2388 .ok()
2389 .and_then(|x| x.try_into().ok())
2390 .ok_or_else(|| {
2391 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2392 })
2393 }
2394
2395 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2396 where
2397 E: serde::de::Error,
2398 {
2399 i32::try_from(v)
2400 .ok()
2401 .and_then(|x| x.try_into().ok())
2402 .ok_or_else(|| {
2403 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2404 })
2405 }
2406
2407 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2408 where
2409 E: serde::de::Error,
2410 {
2411 match value {
2412 "TELEMETRY_NODE_TYPE_UNSPECIFIED" => Ok(TelemetryNodeType::Unspecified),
2413 "TELEMETRY_NODE_TYPE_META" => Ok(TelemetryNodeType::Meta),
2414 "TELEMETRY_NODE_TYPE_COMPUTE" => Ok(TelemetryNodeType::Compute),
2415 "TELEMETRY_NODE_TYPE_FRONTEND" => Ok(TelemetryNodeType::Frontend),
2416 "TELEMETRY_NODE_TYPE_COMPACTOR" => Ok(TelemetryNodeType::Compactor),
2417 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2418 }
2419 }
2420 }
2421 deserializer.deserialize_any(GeneratedVisitor)
2422 }
2423}