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