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