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