1use crate::meta::*;
2impl serde::Serialize for ActivateWorkerNodeRequest {
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.host.is_some() {
11 len += 1;
12 }
13 if self.node_id != 0 {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
17 if let Some(v) = self.host.as_ref() {
18 struct_ser.serialize_field("host", v)?;
19 }
20 if self.node_id != 0 {
21 struct_ser.serialize_field("nodeId", &self.node_id)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "host",
34 "node_id",
35 "nodeId",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 Host,
41 NodeId,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "host" => Ok(GeneratedField::Host),
64 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActivateWorkerNodeRequest;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut host__ = None;
85 let mut node_id__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::Host => {
89 if host__.is_some() {
90 return Err(serde::de::Error::duplicate_field("host"));
91 }
92 host__ = map_.next_value()?;
93 }
94 GeneratedField::NodeId => {
95 if node_id__.is_some() {
96 return Err(serde::de::Error::duplicate_field("nodeId"));
97 }
98 node_id__ =
99 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
100 ;
101 }
102 }
103 }
104 Ok(ActivateWorkerNodeRequest {
105 host: host__,
106 node_id: node_id__.unwrap_or_default(),
107 })
108 }
109 }
110 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
111 }
112}
113impl serde::Serialize for ActivateWorkerNodeResponse {
114 #[allow(deprecated)]
115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116 where
117 S: serde::Serializer,
118 {
119 use serde::ser::SerializeStruct;
120 let mut len = 0;
121 if self.status.is_some() {
122 len += 1;
123 }
124 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
125 if let Some(v) = self.status.as_ref() {
126 struct_ser.serialize_field("status", v)?;
127 }
128 struct_ser.end()
129 }
130}
131impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
132 #[allow(deprecated)]
133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
134 where
135 D: serde::Deserializer<'de>,
136 {
137 const FIELDS: &[&str] = &[
138 "status",
139 ];
140
141 #[allow(clippy::enum_variant_names)]
142 enum GeneratedField {
143 Status,
144 }
145 impl<'de> serde::Deserialize<'de> for GeneratedField {
146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
147 where
148 D: serde::Deserializer<'de>,
149 {
150 struct GeneratedVisitor;
151
152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
153 type Value = GeneratedField;
154
155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156 write!(formatter, "expected one of: {:?}", &FIELDS)
157 }
158
159 #[allow(unused_variables)]
160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
161 where
162 E: serde::de::Error,
163 {
164 match value {
165 "status" => Ok(GeneratedField::Status),
166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
167 }
168 }
169 }
170 deserializer.deserialize_identifier(GeneratedVisitor)
171 }
172 }
173 struct GeneratedVisitor;
174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
175 type Value = ActivateWorkerNodeResponse;
176
177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
178 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
179 }
180
181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
182 where
183 V: serde::de::MapAccess<'de>,
184 {
185 let mut status__ = None;
186 while let Some(k) = map_.next_key()? {
187 match k {
188 GeneratedField::Status => {
189 if status__.is_some() {
190 return Err(serde::de::Error::duplicate_field("status"));
191 }
192 status__ = map_.next_value()?;
193 }
194 }
195 }
196 Ok(ActivateWorkerNodeResponse {
197 status: status__,
198 })
199 }
200 }
201 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
202 }
203}
204impl serde::Serialize for ActorCountPerParallelism {
205 #[allow(deprecated)]
206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
207 where
208 S: serde::Serializer,
209 {
210 use serde::ser::SerializeStruct;
211 let mut len = 0;
212 if !self.worker_id_to_actor_count.is_empty() {
213 len += 1;
214 }
215 if self.hard_limit != 0 {
216 len += 1;
217 }
218 if self.soft_limit != 0 {
219 len += 1;
220 }
221 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
222 if !self.worker_id_to_actor_count.is_empty() {
223 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
224 }
225 if self.hard_limit != 0 {
226 #[allow(clippy::needless_borrow)]
227 #[allow(clippy::needless_borrows_for_generic_args)]
228 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
229 }
230 if self.soft_limit != 0 {
231 #[allow(clippy::needless_borrow)]
232 #[allow(clippy::needless_borrows_for_generic_args)]
233 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
234 }
235 struct_ser.end()
236 }
237}
238impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
239 #[allow(deprecated)]
240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
241 where
242 D: serde::Deserializer<'de>,
243 {
244 const FIELDS: &[&str] = &[
245 "worker_id_to_actor_count",
246 "workerIdToActorCount",
247 "hard_limit",
248 "hardLimit",
249 "soft_limit",
250 "softLimit",
251 ];
252
253 #[allow(clippy::enum_variant_names)]
254 enum GeneratedField {
255 WorkerIdToActorCount,
256 HardLimit,
257 SoftLimit,
258 }
259 impl<'de> serde::Deserialize<'de> for GeneratedField {
260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261 where
262 D: serde::Deserializer<'de>,
263 {
264 struct GeneratedVisitor;
265
266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267 type Value = GeneratedField;
268
269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 write!(formatter, "expected one of: {:?}", &FIELDS)
271 }
272
273 #[allow(unused_variables)]
274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275 where
276 E: serde::de::Error,
277 {
278 match value {
279 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
280 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
281 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
283 }
284 }
285 }
286 deserializer.deserialize_identifier(GeneratedVisitor)
287 }
288 }
289 struct GeneratedVisitor;
290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
291 type Value = ActorCountPerParallelism;
292
293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
294 formatter.write_str("struct meta.ActorCountPerParallelism")
295 }
296
297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
298 where
299 V: serde::de::MapAccess<'de>,
300 {
301 let mut worker_id_to_actor_count__ = None;
302 let mut hard_limit__ = None;
303 let mut soft_limit__ = None;
304 while let Some(k) = map_.next_key()? {
305 match k {
306 GeneratedField::WorkerIdToActorCount => {
307 if worker_id_to_actor_count__.is_some() {
308 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
309 }
310 worker_id_to_actor_count__ = Some(
311 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
312 .into_iter().map(|(k,v)| (k.0, v)).collect()
313 );
314 }
315 GeneratedField::HardLimit => {
316 if hard_limit__.is_some() {
317 return Err(serde::de::Error::duplicate_field("hardLimit"));
318 }
319 hard_limit__ =
320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
321 ;
322 }
323 GeneratedField::SoftLimit => {
324 if soft_limit__.is_some() {
325 return Err(serde::de::Error::duplicate_field("softLimit"));
326 }
327 soft_limit__ =
328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
329 ;
330 }
331 }
332 }
333 Ok(ActorCountPerParallelism {
334 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
335 hard_limit: hard_limit__.unwrap_or_default(),
336 soft_limit: soft_limit__.unwrap_or_default(),
337 })
338 }
339 }
340 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
341 }
342}
343impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
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.parallelism != 0 {
355 len += 1;
356 }
357 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
358 if self.actor_count != 0 {
359 #[allow(clippy::needless_borrow)]
360 #[allow(clippy::needless_borrows_for_generic_args)]
361 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
362 }
363 if self.parallelism != 0 {
364 #[allow(clippy::needless_borrow)]
365 #[allow(clippy::needless_borrows_for_generic_args)]
366 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
367 }
368 struct_ser.end()
369 }
370}
371impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
372 #[allow(deprecated)]
373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
374 where
375 D: serde::Deserializer<'de>,
376 {
377 const FIELDS: &[&str] = &[
378 "actor_count",
379 "actorCount",
380 "parallelism",
381 ];
382
383 #[allow(clippy::enum_variant_names)]
384 enum GeneratedField {
385 ActorCount,
386 Parallelism,
387 }
388 impl<'de> serde::Deserialize<'de> for GeneratedField {
389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
390 where
391 D: serde::Deserializer<'de>,
392 {
393 struct GeneratedVisitor;
394
395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
396 type Value = GeneratedField;
397
398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
399 write!(formatter, "expected one of: {:?}", &FIELDS)
400 }
401
402 #[allow(unused_variables)]
403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
404 where
405 E: serde::de::Error,
406 {
407 match value {
408 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
409 "parallelism" => Ok(GeneratedField::Parallelism),
410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
411 }
412 }
413 }
414 deserializer.deserialize_identifier(GeneratedVisitor)
415 }
416 }
417 struct GeneratedVisitor;
418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
419 type Value = actor_count_per_parallelism::WorkerActorCount;
420
421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
422 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
423 }
424
425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
426 where
427 V: serde::de::MapAccess<'de>,
428 {
429 let mut actor_count__ = None;
430 let mut parallelism__ = None;
431 while let Some(k) = map_.next_key()? {
432 match k {
433 GeneratedField::ActorCount => {
434 if actor_count__.is_some() {
435 return Err(serde::de::Error::duplicate_field("actorCount"));
436 }
437 actor_count__ =
438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
439 ;
440 }
441 GeneratedField::Parallelism => {
442 if parallelism__.is_some() {
443 return Err(serde::de::Error::duplicate_field("parallelism"));
444 }
445 parallelism__ =
446 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
447 ;
448 }
449 }
450 }
451 Ok(actor_count_per_parallelism::WorkerActorCount {
452 actor_count: actor_count__.unwrap_or_default(),
453 parallelism: parallelism__.unwrap_or_default(),
454 })
455 }
456 }
457 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
458 }
459}
460impl serde::Serialize for ActorIds {
461 #[allow(deprecated)]
462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
463 where
464 S: serde::Serializer,
465 {
466 use serde::ser::SerializeStruct;
467 let mut len = 0;
468 if !self.ids.is_empty() {
469 len += 1;
470 }
471 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
472 if !self.ids.is_empty() {
473 struct_ser.serialize_field("ids", &self.ids)?;
474 }
475 struct_ser.end()
476 }
477}
478impl<'de> serde::Deserialize<'de> for ActorIds {
479 #[allow(deprecated)]
480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 const FIELDS: &[&str] = &[
485 "ids",
486 ];
487
488 #[allow(clippy::enum_variant_names)]
489 enum GeneratedField {
490 Ids,
491 }
492 impl<'de> serde::Deserialize<'de> for GeneratedField {
493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
494 where
495 D: serde::Deserializer<'de>,
496 {
497 struct GeneratedVisitor;
498
499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
500 type Value = GeneratedField;
501
502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
503 write!(formatter, "expected one of: {:?}", &FIELDS)
504 }
505
506 #[allow(unused_variables)]
507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
508 where
509 E: serde::de::Error,
510 {
511 match value {
512 "ids" => Ok(GeneratedField::Ids),
513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
514 }
515 }
516 }
517 deserializer.deserialize_identifier(GeneratedVisitor)
518 }
519 }
520 struct GeneratedVisitor;
521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
522 type Value = ActorIds;
523
524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
525 formatter.write_str("struct meta.ActorIds")
526 }
527
528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
529 where
530 V: serde::de::MapAccess<'de>,
531 {
532 let mut ids__ = None;
533 while let Some(k) = map_.next_key()? {
534 match k {
535 GeneratedField::Ids => {
536 if ids__.is_some() {
537 return Err(serde::de::Error::duplicate_field("ids"));
538 }
539 ids__ =
540 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
541 .into_iter().map(|x| x.0).collect())
542 ;
543 }
544 }
545 }
546 Ok(ActorIds {
547 ids: ids__.unwrap_or_default(),
548 })
549 }
550 }
551 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
552 }
553}
554impl serde::Serialize for ActorLocation {
555 #[allow(deprecated)]
556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
557 where
558 S: serde::Serializer,
559 {
560 use serde::ser::SerializeStruct;
561 let mut len = 0;
562 if self.node.is_some() {
563 len += 1;
564 }
565 if !self.actors.is_empty() {
566 len += 1;
567 }
568 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
569 if let Some(v) = self.node.as_ref() {
570 struct_ser.serialize_field("node", v)?;
571 }
572 if !self.actors.is_empty() {
573 struct_ser.serialize_field("actors", &self.actors)?;
574 }
575 struct_ser.end()
576 }
577}
578impl<'de> serde::Deserialize<'de> for ActorLocation {
579 #[allow(deprecated)]
580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
581 where
582 D: serde::Deserializer<'de>,
583 {
584 const FIELDS: &[&str] = &[
585 "node",
586 "actors",
587 ];
588
589 #[allow(clippy::enum_variant_names)]
590 enum GeneratedField {
591 Node,
592 Actors,
593 }
594 impl<'de> serde::Deserialize<'de> for GeneratedField {
595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
596 where
597 D: serde::Deserializer<'de>,
598 {
599 struct GeneratedVisitor;
600
601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
602 type Value = GeneratedField;
603
604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
605 write!(formatter, "expected one of: {:?}", &FIELDS)
606 }
607
608 #[allow(unused_variables)]
609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
610 where
611 E: serde::de::Error,
612 {
613 match value {
614 "node" => Ok(GeneratedField::Node),
615 "actors" => Ok(GeneratedField::Actors),
616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
617 }
618 }
619 }
620 deserializer.deserialize_identifier(GeneratedVisitor)
621 }
622 }
623 struct GeneratedVisitor;
624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625 type Value = ActorLocation;
626
627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628 formatter.write_str("struct meta.ActorLocation")
629 }
630
631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
632 where
633 V: serde::de::MapAccess<'de>,
634 {
635 let mut node__ = None;
636 let mut actors__ = None;
637 while let Some(k) = map_.next_key()? {
638 match k {
639 GeneratedField::Node => {
640 if node__.is_some() {
641 return Err(serde::de::Error::duplicate_field("node"));
642 }
643 node__ = map_.next_value()?;
644 }
645 GeneratedField::Actors => {
646 if actors__.is_some() {
647 return Err(serde::de::Error::duplicate_field("actors"));
648 }
649 actors__ = Some(map_.next_value()?);
650 }
651 }
652 }
653 Ok(ActorLocation {
654 node: node__,
655 actors: actors__.unwrap_or_default(),
656 })
657 }
658 }
659 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
660 }
661}
662impl serde::Serialize for AddEventLogRequest {
663 #[allow(deprecated)]
664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
665 where
666 S: serde::Serializer,
667 {
668 use serde::ser::SerializeStruct;
669 let mut len = 0;
670 if self.event.is_some() {
671 len += 1;
672 }
673 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
674 if let Some(v) = self.event.as_ref() {
675 match v {
676 add_event_log_request::Event::WorkerNodePanic(v) => {
677 struct_ser.serialize_field("workerNodePanic", v)?;
678 }
679 add_event_log_request::Event::SinkFail(v) => {
680 struct_ser.serialize_field("sinkFail", v)?;
681 }
682 }
683 }
684 struct_ser.end()
685 }
686}
687impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
688 #[allow(deprecated)]
689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
690 where
691 D: serde::Deserializer<'de>,
692 {
693 const FIELDS: &[&str] = &[
694 "worker_node_panic",
695 "workerNodePanic",
696 "sink_fail",
697 "sinkFail",
698 ];
699
700 #[allow(clippy::enum_variant_names)]
701 enum GeneratedField {
702 WorkerNodePanic,
703 SinkFail,
704 }
705 impl<'de> serde::Deserialize<'de> for GeneratedField {
706 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
707 where
708 D: serde::Deserializer<'de>,
709 {
710 struct GeneratedVisitor;
711
712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
713 type Value = GeneratedField;
714
715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
716 write!(formatter, "expected one of: {:?}", &FIELDS)
717 }
718
719 #[allow(unused_variables)]
720 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
721 where
722 E: serde::de::Error,
723 {
724 match value {
725 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
726 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
728 }
729 }
730 }
731 deserializer.deserialize_identifier(GeneratedVisitor)
732 }
733 }
734 struct GeneratedVisitor;
735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
736 type Value = AddEventLogRequest;
737
738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
739 formatter.write_str("struct meta.AddEventLogRequest")
740 }
741
742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
743 where
744 V: serde::de::MapAccess<'de>,
745 {
746 let mut event__ = None;
747 while let Some(k) = map_.next_key()? {
748 match k {
749 GeneratedField::WorkerNodePanic => {
750 if event__.is_some() {
751 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
752 }
753 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
754;
755 }
756 GeneratedField::SinkFail => {
757 if event__.is_some() {
758 return Err(serde::de::Error::duplicate_field("sinkFail"));
759 }
760 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
761;
762 }
763 }
764 }
765 Ok(AddEventLogRequest {
766 event: event__,
767 })
768 }
769 }
770 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
771 }
772}
773impl serde::Serialize for AddEventLogResponse {
774 #[allow(deprecated)]
775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
776 where
777 S: serde::Serializer,
778 {
779 use serde::ser::SerializeStruct;
780 let len = 0;
781 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
782 struct_ser.end()
783 }
784}
785impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
786 #[allow(deprecated)]
787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
788 where
789 D: serde::Deserializer<'de>,
790 {
791 const FIELDS: &[&str] = &[
792 ];
793
794 #[allow(clippy::enum_variant_names)]
795 enum GeneratedField {
796 }
797 impl<'de> serde::Deserialize<'de> for GeneratedField {
798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
799 where
800 D: serde::Deserializer<'de>,
801 {
802 struct GeneratedVisitor;
803
804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
805 type Value = GeneratedField;
806
807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
808 write!(formatter, "expected one of: {:?}", &FIELDS)
809 }
810
811 #[allow(unused_variables)]
812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
813 where
814 E: serde::de::Error,
815 {
816 Err(serde::de::Error::unknown_field(value, FIELDS))
817 }
818 }
819 deserializer.deserialize_identifier(GeneratedVisitor)
820 }
821 }
822 struct GeneratedVisitor;
823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
824 type Value = AddEventLogResponse;
825
826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
827 formatter.write_str("struct meta.AddEventLogResponse")
828 }
829
830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
831 where
832 V: serde::de::MapAccess<'de>,
833 {
834 while map_.next_key::<GeneratedField>()?.is_some() {
835 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
836 }
837 Ok(AddEventLogResponse {
838 })
839 }
840 }
841 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
842 }
843}
844impl serde::Serialize for AddWorkerNodeRequest {
845 #[allow(deprecated)]
846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
847 where
848 S: serde::Serializer,
849 {
850 use serde::ser::SerializeStruct;
851 let mut len = 0;
852 if self.worker_type != 0 {
853 len += 1;
854 }
855 if self.host.is_some() {
856 len += 1;
857 }
858 if self.resource.is_some() {
859 len += 1;
860 }
861 if self.property.is_some() {
862 len += 1;
863 }
864 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
865 if self.worker_type != 0 {
866 let v = super::common::WorkerType::try_from(self.worker_type)
867 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
868 struct_ser.serialize_field("workerType", &v)?;
869 }
870 if let Some(v) = self.host.as_ref() {
871 struct_ser.serialize_field("host", v)?;
872 }
873 if let Some(v) = self.resource.as_ref() {
874 struct_ser.serialize_field("resource", v)?;
875 }
876 if let Some(v) = self.property.as_ref() {
877 struct_ser.serialize_field("property", v)?;
878 }
879 struct_ser.end()
880 }
881}
882impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
883 #[allow(deprecated)]
884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
885 where
886 D: serde::Deserializer<'de>,
887 {
888 const FIELDS: &[&str] = &[
889 "worker_type",
890 "workerType",
891 "host",
892 "resource",
893 "property",
894 ];
895
896 #[allow(clippy::enum_variant_names)]
897 enum GeneratedField {
898 WorkerType,
899 Host,
900 Resource,
901 Property,
902 }
903 impl<'de> serde::Deserialize<'de> for GeneratedField {
904 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
905 where
906 D: serde::Deserializer<'de>,
907 {
908 struct GeneratedVisitor;
909
910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
911 type Value = GeneratedField;
912
913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
914 write!(formatter, "expected one of: {:?}", &FIELDS)
915 }
916
917 #[allow(unused_variables)]
918 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
919 where
920 E: serde::de::Error,
921 {
922 match value {
923 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
924 "host" => Ok(GeneratedField::Host),
925 "resource" => Ok(GeneratedField::Resource),
926 "property" => Ok(GeneratedField::Property),
927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
928 }
929 }
930 }
931 deserializer.deserialize_identifier(GeneratedVisitor)
932 }
933 }
934 struct GeneratedVisitor;
935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
936 type Value = AddWorkerNodeRequest;
937
938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
939 formatter.write_str("struct meta.AddWorkerNodeRequest")
940 }
941
942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
943 where
944 V: serde::de::MapAccess<'de>,
945 {
946 let mut worker_type__ = None;
947 let mut host__ = None;
948 let mut resource__ = None;
949 let mut property__ = None;
950 while let Some(k) = map_.next_key()? {
951 match k {
952 GeneratedField::WorkerType => {
953 if worker_type__.is_some() {
954 return Err(serde::de::Error::duplicate_field("workerType"));
955 }
956 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
957 }
958 GeneratedField::Host => {
959 if host__.is_some() {
960 return Err(serde::de::Error::duplicate_field("host"));
961 }
962 host__ = map_.next_value()?;
963 }
964 GeneratedField::Resource => {
965 if resource__.is_some() {
966 return Err(serde::de::Error::duplicate_field("resource"));
967 }
968 resource__ = map_.next_value()?;
969 }
970 GeneratedField::Property => {
971 if property__.is_some() {
972 return Err(serde::de::Error::duplicate_field("property"));
973 }
974 property__ = map_.next_value()?;
975 }
976 }
977 }
978 Ok(AddWorkerNodeRequest {
979 worker_type: worker_type__.unwrap_or_default(),
980 host: host__,
981 resource: resource__,
982 property: property__,
983 })
984 }
985 }
986 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
987 }
988}
989impl serde::Serialize for AddWorkerNodeResponse {
990 #[allow(deprecated)]
991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
992 where
993 S: serde::Serializer,
994 {
995 use serde::ser::SerializeStruct;
996 let mut len = 0;
997 if self.node_id.is_some() {
998 len += 1;
999 }
1000 if !self.cluster_id.is_empty() {
1001 len += 1;
1002 }
1003 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1004 if let Some(v) = self.node_id.as_ref() {
1005 struct_ser.serialize_field("nodeId", v)?;
1006 }
1007 if !self.cluster_id.is_empty() {
1008 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1009 }
1010 struct_ser.end()
1011 }
1012}
1013impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1014 #[allow(deprecated)]
1015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1016 where
1017 D: serde::Deserializer<'de>,
1018 {
1019 const FIELDS: &[&str] = &[
1020 "node_id",
1021 "nodeId",
1022 "cluster_id",
1023 "clusterId",
1024 ];
1025
1026 #[allow(clippy::enum_variant_names)]
1027 enum GeneratedField {
1028 NodeId,
1029 ClusterId,
1030 }
1031 impl<'de> serde::Deserialize<'de> for GeneratedField {
1032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1033 where
1034 D: serde::Deserializer<'de>,
1035 {
1036 struct GeneratedVisitor;
1037
1038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1039 type Value = GeneratedField;
1040
1041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1042 write!(formatter, "expected one of: {:?}", &FIELDS)
1043 }
1044
1045 #[allow(unused_variables)]
1046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1047 where
1048 E: serde::de::Error,
1049 {
1050 match value {
1051 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1052 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1054 }
1055 }
1056 }
1057 deserializer.deserialize_identifier(GeneratedVisitor)
1058 }
1059 }
1060 struct GeneratedVisitor;
1061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1062 type Value = AddWorkerNodeResponse;
1063
1064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1065 formatter.write_str("struct meta.AddWorkerNodeResponse")
1066 }
1067
1068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1069 where
1070 V: serde::de::MapAccess<'de>,
1071 {
1072 let mut node_id__ = None;
1073 let mut cluster_id__ = None;
1074 while let Some(k) = map_.next_key()? {
1075 match k {
1076 GeneratedField::NodeId => {
1077 if node_id__.is_some() {
1078 return Err(serde::de::Error::duplicate_field("nodeId"));
1079 }
1080 node_id__ =
1081 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1082 ;
1083 }
1084 GeneratedField::ClusterId => {
1085 if cluster_id__.is_some() {
1086 return Err(serde::de::Error::duplicate_field("clusterId"));
1087 }
1088 cluster_id__ = Some(map_.next_value()?);
1089 }
1090 }
1091 }
1092 Ok(AddWorkerNodeResponse {
1093 node_id: node_id__,
1094 cluster_id: cluster_id__.unwrap_or_default(),
1095 })
1096 }
1097 }
1098 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1099 }
1100}
1101impl serde::Serialize for ApplyThrottleRequest {
1102 #[allow(deprecated)]
1103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1104 where
1105 S: serde::Serializer,
1106 {
1107 use serde::ser::SerializeStruct;
1108 let mut len = 0;
1109 if self.kind != 0 {
1110 len += 1;
1111 }
1112 if self.id != 0 {
1113 len += 1;
1114 }
1115 if self.rate.is_some() {
1116 len += 1;
1117 }
1118 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1119 if self.kind != 0 {
1120 let v = ThrottleTarget::try_from(self.kind)
1121 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1122 struct_ser.serialize_field("kind", &v)?;
1123 }
1124 if self.id != 0 {
1125 struct_ser.serialize_field("id", &self.id)?;
1126 }
1127 if let Some(v) = self.rate.as_ref() {
1128 struct_ser.serialize_field("rate", v)?;
1129 }
1130 struct_ser.end()
1131 }
1132}
1133impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1134 #[allow(deprecated)]
1135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1136 where
1137 D: serde::Deserializer<'de>,
1138 {
1139 const FIELDS: &[&str] = &[
1140 "kind",
1141 "id",
1142 "rate",
1143 ];
1144
1145 #[allow(clippy::enum_variant_names)]
1146 enum GeneratedField {
1147 Kind,
1148 Id,
1149 Rate,
1150 }
1151 impl<'de> serde::Deserialize<'de> for GeneratedField {
1152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1153 where
1154 D: serde::Deserializer<'de>,
1155 {
1156 struct GeneratedVisitor;
1157
1158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1159 type Value = GeneratedField;
1160
1161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1162 write!(formatter, "expected one of: {:?}", &FIELDS)
1163 }
1164
1165 #[allow(unused_variables)]
1166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1167 where
1168 E: serde::de::Error,
1169 {
1170 match value {
1171 "kind" => Ok(GeneratedField::Kind),
1172 "id" => Ok(GeneratedField::Id),
1173 "rate" => Ok(GeneratedField::Rate),
1174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1175 }
1176 }
1177 }
1178 deserializer.deserialize_identifier(GeneratedVisitor)
1179 }
1180 }
1181 struct GeneratedVisitor;
1182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1183 type Value = ApplyThrottleRequest;
1184
1185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1186 formatter.write_str("struct meta.ApplyThrottleRequest")
1187 }
1188
1189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1190 where
1191 V: serde::de::MapAccess<'de>,
1192 {
1193 let mut kind__ = None;
1194 let mut id__ = None;
1195 let mut rate__ = None;
1196 while let Some(k) = map_.next_key()? {
1197 match k {
1198 GeneratedField::Kind => {
1199 if kind__.is_some() {
1200 return Err(serde::de::Error::duplicate_field("kind"));
1201 }
1202 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1203 }
1204 GeneratedField::Id => {
1205 if id__.is_some() {
1206 return Err(serde::de::Error::duplicate_field("id"));
1207 }
1208 id__ =
1209 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1210 ;
1211 }
1212 GeneratedField::Rate => {
1213 if rate__.is_some() {
1214 return Err(serde::de::Error::duplicate_field("rate"));
1215 }
1216 rate__ =
1217 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1218 ;
1219 }
1220 }
1221 }
1222 Ok(ApplyThrottleRequest {
1223 kind: kind__.unwrap_or_default(),
1224 id: id__.unwrap_or_default(),
1225 rate: rate__,
1226 })
1227 }
1228 }
1229 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1230 }
1231}
1232impl serde::Serialize for ApplyThrottleResponse {
1233 #[allow(deprecated)]
1234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1235 where
1236 S: serde::Serializer,
1237 {
1238 use serde::ser::SerializeStruct;
1239 let mut len = 0;
1240 if self.status.is_some() {
1241 len += 1;
1242 }
1243 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1244 if let Some(v) = self.status.as_ref() {
1245 struct_ser.serialize_field("status", v)?;
1246 }
1247 struct_ser.end()
1248 }
1249}
1250impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1251 #[allow(deprecated)]
1252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1253 where
1254 D: serde::Deserializer<'de>,
1255 {
1256 const FIELDS: &[&str] = &[
1257 "status",
1258 ];
1259
1260 #[allow(clippy::enum_variant_names)]
1261 enum GeneratedField {
1262 Status,
1263 }
1264 impl<'de> serde::Deserialize<'de> for GeneratedField {
1265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1266 where
1267 D: serde::Deserializer<'de>,
1268 {
1269 struct GeneratedVisitor;
1270
1271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1272 type Value = GeneratedField;
1273
1274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1275 write!(formatter, "expected one of: {:?}", &FIELDS)
1276 }
1277
1278 #[allow(unused_variables)]
1279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1280 where
1281 E: serde::de::Error,
1282 {
1283 match value {
1284 "status" => Ok(GeneratedField::Status),
1285 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1286 }
1287 }
1288 }
1289 deserializer.deserialize_identifier(GeneratedVisitor)
1290 }
1291 }
1292 struct GeneratedVisitor;
1293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1294 type Value = ApplyThrottleResponse;
1295
1296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1297 formatter.write_str("struct meta.ApplyThrottleResponse")
1298 }
1299
1300 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1301 where
1302 V: serde::de::MapAccess<'de>,
1303 {
1304 let mut status__ = None;
1305 while let Some(k) = map_.next_key()? {
1306 match k {
1307 GeneratedField::Status => {
1308 if status__.is_some() {
1309 return Err(serde::de::Error::duplicate_field("status"));
1310 }
1311 status__ = map_.next_value()?;
1312 }
1313 }
1314 }
1315 Ok(ApplyThrottleResponse {
1316 status: status__,
1317 })
1318 }
1319 }
1320 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1321 }
1322}
1323impl serde::Serialize for CancelCreatingJobsRequest {
1324 #[allow(deprecated)]
1325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1326 where
1327 S: serde::Serializer,
1328 {
1329 use serde::ser::SerializeStruct;
1330 let mut len = 0;
1331 if self.jobs.is_some() {
1332 len += 1;
1333 }
1334 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1335 if let Some(v) = self.jobs.as_ref() {
1336 match v {
1337 cancel_creating_jobs_request::Jobs::Infos(v) => {
1338 struct_ser.serialize_field("infos", v)?;
1339 }
1340 cancel_creating_jobs_request::Jobs::Ids(v) => {
1341 struct_ser.serialize_field("ids", v)?;
1342 }
1343 }
1344 }
1345 struct_ser.end()
1346 }
1347}
1348impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1349 #[allow(deprecated)]
1350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1351 where
1352 D: serde::Deserializer<'de>,
1353 {
1354 const FIELDS: &[&str] = &[
1355 "infos",
1356 "ids",
1357 ];
1358
1359 #[allow(clippy::enum_variant_names)]
1360 enum GeneratedField {
1361 Infos,
1362 Ids,
1363 }
1364 impl<'de> serde::Deserialize<'de> for GeneratedField {
1365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1366 where
1367 D: serde::Deserializer<'de>,
1368 {
1369 struct GeneratedVisitor;
1370
1371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1372 type Value = GeneratedField;
1373
1374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1375 write!(formatter, "expected one of: {:?}", &FIELDS)
1376 }
1377
1378 #[allow(unused_variables)]
1379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1380 where
1381 E: serde::de::Error,
1382 {
1383 match value {
1384 "infos" => Ok(GeneratedField::Infos),
1385 "ids" => Ok(GeneratedField::Ids),
1386 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1387 }
1388 }
1389 }
1390 deserializer.deserialize_identifier(GeneratedVisitor)
1391 }
1392 }
1393 struct GeneratedVisitor;
1394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1395 type Value = CancelCreatingJobsRequest;
1396
1397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1398 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1399 }
1400
1401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1402 where
1403 V: serde::de::MapAccess<'de>,
1404 {
1405 let mut jobs__ = None;
1406 while let Some(k) = map_.next_key()? {
1407 match k {
1408 GeneratedField::Infos => {
1409 if jobs__.is_some() {
1410 return Err(serde::de::Error::duplicate_field("infos"));
1411 }
1412 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1413;
1414 }
1415 GeneratedField::Ids => {
1416 if jobs__.is_some() {
1417 return Err(serde::de::Error::duplicate_field("ids"));
1418 }
1419 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1420;
1421 }
1422 }
1423 }
1424 Ok(CancelCreatingJobsRequest {
1425 jobs: jobs__,
1426 })
1427 }
1428 }
1429 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1430 }
1431}
1432impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1433 #[allow(deprecated)]
1434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1435 where
1436 S: serde::Serializer,
1437 {
1438 use serde::ser::SerializeStruct;
1439 let mut len = 0;
1440 if !self.job_ids.is_empty() {
1441 len += 1;
1442 }
1443 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1444 if !self.job_ids.is_empty() {
1445 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1446 }
1447 struct_ser.end()
1448 }
1449}
1450impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1451 #[allow(deprecated)]
1452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1453 where
1454 D: serde::Deserializer<'de>,
1455 {
1456 const FIELDS: &[&str] = &[
1457 "job_ids",
1458 "jobIds",
1459 ];
1460
1461 #[allow(clippy::enum_variant_names)]
1462 enum GeneratedField {
1463 JobIds,
1464 }
1465 impl<'de> serde::Deserialize<'de> for GeneratedField {
1466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1467 where
1468 D: serde::Deserializer<'de>,
1469 {
1470 struct GeneratedVisitor;
1471
1472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1473 type Value = GeneratedField;
1474
1475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1476 write!(formatter, "expected one of: {:?}", &FIELDS)
1477 }
1478
1479 #[allow(unused_variables)]
1480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1481 where
1482 E: serde::de::Error,
1483 {
1484 match value {
1485 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1486 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1487 }
1488 }
1489 }
1490 deserializer.deserialize_identifier(GeneratedVisitor)
1491 }
1492 }
1493 struct GeneratedVisitor;
1494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1495 type Value = cancel_creating_jobs_request::CreatingJobIds;
1496
1497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1498 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1499 }
1500
1501 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1502 where
1503 V: serde::de::MapAccess<'de>,
1504 {
1505 let mut job_ids__ = None;
1506 while let Some(k) = map_.next_key()? {
1507 match k {
1508 GeneratedField::JobIds => {
1509 if job_ids__.is_some() {
1510 return Err(serde::de::Error::duplicate_field("jobIds"));
1511 }
1512 job_ids__ =
1513 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1514 .into_iter().map(|x| x.0).collect())
1515 ;
1516 }
1517 }
1518 }
1519 Ok(cancel_creating_jobs_request::CreatingJobIds {
1520 job_ids: job_ids__.unwrap_or_default(),
1521 })
1522 }
1523 }
1524 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
1525 }
1526}
1527impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
1528 #[allow(deprecated)]
1529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1530 where
1531 S: serde::Serializer,
1532 {
1533 use serde::ser::SerializeStruct;
1534 let mut len = 0;
1535 if self.database_id != 0 {
1536 len += 1;
1537 }
1538 if self.schema_id != 0 {
1539 len += 1;
1540 }
1541 if !self.name.is_empty() {
1542 len += 1;
1543 }
1544 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
1545 if self.database_id != 0 {
1546 struct_ser.serialize_field("databaseId", &self.database_id)?;
1547 }
1548 if self.schema_id != 0 {
1549 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1550 }
1551 if !self.name.is_empty() {
1552 struct_ser.serialize_field("name", &self.name)?;
1553 }
1554 struct_ser.end()
1555 }
1556}
1557impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
1558 #[allow(deprecated)]
1559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1560 where
1561 D: serde::Deserializer<'de>,
1562 {
1563 const FIELDS: &[&str] = &[
1564 "database_id",
1565 "databaseId",
1566 "schema_id",
1567 "schemaId",
1568 "name",
1569 ];
1570
1571 #[allow(clippy::enum_variant_names)]
1572 enum GeneratedField {
1573 DatabaseId,
1574 SchemaId,
1575 Name,
1576 }
1577 impl<'de> serde::Deserialize<'de> for GeneratedField {
1578 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1579 where
1580 D: serde::Deserializer<'de>,
1581 {
1582 struct GeneratedVisitor;
1583
1584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1585 type Value = GeneratedField;
1586
1587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1588 write!(formatter, "expected one of: {:?}", &FIELDS)
1589 }
1590
1591 #[allow(unused_variables)]
1592 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1593 where
1594 E: serde::de::Error,
1595 {
1596 match value {
1597 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1598 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1599 "name" => Ok(GeneratedField::Name),
1600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1601 }
1602 }
1603 }
1604 deserializer.deserialize_identifier(GeneratedVisitor)
1605 }
1606 }
1607 struct GeneratedVisitor;
1608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1609 type Value = cancel_creating_jobs_request::CreatingJobInfo;
1610
1611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1612 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
1613 }
1614
1615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
1616 where
1617 V: serde::de::MapAccess<'de>,
1618 {
1619 let mut database_id__ = None;
1620 let mut schema_id__ = None;
1621 let mut name__ = None;
1622 while let Some(k) = map_.next_key()? {
1623 match k {
1624 GeneratedField::DatabaseId => {
1625 if database_id__.is_some() {
1626 return Err(serde::de::Error::duplicate_field("databaseId"));
1627 }
1628 database_id__ =
1629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1630 ;
1631 }
1632 GeneratedField::SchemaId => {
1633 if schema_id__.is_some() {
1634 return Err(serde::de::Error::duplicate_field("schemaId"));
1635 }
1636 schema_id__ =
1637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1638 ;
1639 }
1640 GeneratedField::Name => {
1641 if name__.is_some() {
1642 return Err(serde::de::Error::duplicate_field("name"));
1643 }
1644 name__ = Some(map_.next_value()?);
1645 }
1646 }
1647 }
1648 Ok(cancel_creating_jobs_request::CreatingJobInfo {
1649 database_id: database_id__.unwrap_or_default(),
1650 schema_id: schema_id__.unwrap_or_default(),
1651 name: name__.unwrap_or_default(),
1652 })
1653 }
1654 }
1655 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
1656 }
1657}
1658impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
1659 #[allow(deprecated)]
1660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1661 where
1662 S: serde::Serializer,
1663 {
1664 use serde::ser::SerializeStruct;
1665 let mut len = 0;
1666 if !self.infos.is_empty() {
1667 len += 1;
1668 }
1669 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
1670 if !self.infos.is_empty() {
1671 struct_ser.serialize_field("infos", &self.infos)?;
1672 }
1673 struct_ser.end()
1674 }
1675}
1676impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
1677 #[allow(deprecated)]
1678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1679 where
1680 D: serde::Deserializer<'de>,
1681 {
1682 const FIELDS: &[&str] = &[
1683 "infos",
1684 ];
1685
1686 #[allow(clippy::enum_variant_names)]
1687 enum GeneratedField {
1688 Infos,
1689 }
1690 impl<'de> serde::Deserialize<'de> for GeneratedField {
1691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1692 where
1693 D: serde::Deserializer<'de>,
1694 {
1695 struct GeneratedVisitor;
1696
1697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1698 type Value = GeneratedField;
1699
1700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1701 write!(formatter, "expected one of: {:?}", &FIELDS)
1702 }
1703
1704 #[allow(unused_variables)]
1705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1706 where
1707 E: serde::de::Error,
1708 {
1709 match value {
1710 "infos" => Ok(GeneratedField::Infos),
1711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1712 }
1713 }
1714 }
1715 deserializer.deserialize_identifier(GeneratedVisitor)
1716 }
1717 }
1718 struct GeneratedVisitor;
1719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1720 type Value = cancel_creating_jobs_request::CreatingJobInfos;
1721
1722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1723 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
1724 }
1725
1726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
1727 where
1728 V: serde::de::MapAccess<'de>,
1729 {
1730 let mut infos__ = None;
1731 while let Some(k) = map_.next_key()? {
1732 match k {
1733 GeneratedField::Infos => {
1734 if infos__.is_some() {
1735 return Err(serde::de::Error::duplicate_field("infos"));
1736 }
1737 infos__ = Some(map_.next_value()?);
1738 }
1739 }
1740 }
1741 Ok(cancel_creating_jobs_request::CreatingJobInfos {
1742 infos: infos__.unwrap_or_default(),
1743 })
1744 }
1745 }
1746 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
1747 }
1748}
1749impl serde::Serialize for CancelCreatingJobsResponse {
1750 #[allow(deprecated)]
1751 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1752 where
1753 S: serde::Serializer,
1754 {
1755 use serde::ser::SerializeStruct;
1756 let mut len = 0;
1757 if self.status.is_some() {
1758 len += 1;
1759 }
1760 if !self.canceled_jobs.is_empty() {
1761 len += 1;
1762 }
1763 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
1764 if let Some(v) = self.status.as_ref() {
1765 struct_ser.serialize_field("status", v)?;
1766 }
1767 if !self.canceled_jobs.is_empty() {
1768 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
1769 }
1770 struct_ser.end()
1771 }
1772}
1773impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
1774 #[allow(deprecated)]
1775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1776 where
1777 D: serde::Deserializer<'de>,
1778 {
1779 const FIELDS: &[&str] = &[
1780 "status",
1781 "canceled_jobs",
1782 "canceledJobs",
1783 ];
1784
1785 #[allow(clippy::enum_variant_names)]
1786 enum GeneratedField {
1787 Status,
1788 CanceledJobs,
1789 }
1790 impl<'de> serde::Deserialize<'de> for GeneratedField {
1791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1792 where
1793 D: serde::Deserializer<'de>,
1794 {
1795 struct GeneratedVisitor;
1796
1797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1798 type Value = GeneratedField;
1799
1800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1801 write!(formatter, "expected one of: {:?}", &FIELDS)
1802 }
1803
1804 #[allow(unused_variables)]
1805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1806 where
1807 E: serde::de::Error,
1808 {
1809 match value {
1810 "status" => Ok(GeneratedField::Status),
1811 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
1812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1813 }
1814 }
1815 }
1816 deserializer.deserialize_identifier(GeneratedVisitor)
1817 }
1818 }
1819 struct GeneratedVisitor;
1820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1821 type Value = CancelCreatingJobsResponse;
1822
1823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1824 formatter.write_str("struct meta.CancelCreatingJobsResponse")
1825 }
1826
1827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
1828 where
1829 V: serde::de::MapAccess<'de>,
1830 {
1831 let mut status__ = None;
1832 let mut canceled_jobs__ = None;
1833 while let Some(k) = map_.next_key()? {
1834 match k {
1835 GeneratedField::Status => {
1836 if status__.is_some() {
1837 return Err(serde::de::Error::duplicate_field("status"));
1838 }
1839 status__ = map_.next_value()?;
1840 }
1841 GeneratedField::CanceledJobs => {
1842 if canceled_jobs__.is_some() {
1843 return Err(serde::de::Error::duplicate_field("canceledJobs"));
1844 }
1845 canceled_jobs__ =
1846 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1847 .into_iter().map(|x| x.0).collect())
1848 ;
1849 }
1850 }
1851 }
1852 Ok(CancelCreatingJobsResponse {
1853 status: status__,
1854 canceled_jobs: canceled_jobs__.unwrap_or_default(),
1855 })
1856 }
1857 }
1858 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
1859 }
1860}
1861impl serde::Serialize for ClusterLimit {
1862 #[allow(deprecated)]
1863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1864 where
1865 S: serde::Serializer,
1866 {
1867 use serde::ser::SerializeStruct;
1868 let mut len = 0;
1869 if self.limit.is_some() {
1870 len += 1;
1871 }
1872 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
1873 if let Some(v) = self.limit.as_ref() {
1874 match v {
1875 cluster_limit::Limit::ActorCount(v) => {
1876 struct_ser.serialize_field("actorCount", v)?;
1877 }
1878 }
1879 }
1880 struct_ser.end()
1881 }
1882}
1883impl<'de> serde::Deserialize<'de> for ClusterLimit {
1884 #[allow(deprecated)]
1885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1886 where
1887 D: serde::Deserializer<'de>,
1888 {
1889 const FIELDS: &[&str] = &[
1890 "actor_count",
1891 "actorCount",
1892 ];
1893
1894 #[allow(clippy::enum_variant_names)]
1895 enum GeneratedField {
1896 ActorCount,
1897 }
1898 impl<'de> serde::Deserialize<'de> for GeneratedField {
1899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1900 where
1901 D: serde::Deserializer<'de>,
1902 {
1903 struct GeneratedVisitor;
1904
1905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1906 type Value = GeneratedField;
1907
1908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1909 write!(formatter, "expected one of: {:?}", &FIELDS)
1910 }
1911
1912 #[allow(unused_variables)]
1913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1914 where
1915 E: serde::de::Error,
1916 {
1917 match value {
1918 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
1919 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1920 }
1921 }
1922 }
1923 deserializer.deserialize_identifier(GeneratedVisitor)
1924 }
1925 }
1926 struct GeneratedVisitor;
1927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1928 type Value = ClusterLimit;
1929
1930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1931 formatter.write_str("struct meta.ClusterLimit")
1932 }
1933
1934 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
1935 where
1936 V: serde::de::MapAccess<'de>,
1937 {
1938 let mut limit__ = None;
1939 while let Some(k) = map_.next_key()? {
1940 match k {
1941 GeneratedField::ActorCount => {
1942 if limit__.is_some() {
1943 return Err(serde::de::Error::duplicate_field("actorCount"));
1944 }
1945 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
1946;
1947 }
1948 }
1949 }
1950 Ok(ClusterLimit {
1951 limit: limit__,
1952 })
1953 }
1954 }
1955 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
1956 }
1957}
1958impl serde::Serialize for DeleteWorkerNodeRequest {
1959 #[allow(deprecated)]
1960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1961 where
1962 S: serde::Serializer,
1963 {
1964 use serde::ser::SerializeStruct;
1965 let mut len = 0;
1966 if self.host.is_some() {
1967 len += 1;
1968 }
1969 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
1970 if let Some(v) = self.host.as_ref() {
1971 struct_ser.serialize_field("host", v)?;
1972 }
1973 struct_ser.end()
1974 }
1975}
1976impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
1977 #[allow(deprecated)]
1978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1979 where
1980 D: serde::Deserializer<'de>,
1981 {
1982 const FIELDS: &[&str] = &[
1983 "host",
1984 ];
1985
1986 #[allow(clippy::enum_variant_names)]
1987 enum GeneratedField {
1988 Host,
1989 }
1990 impl<'de> serde::Deserialize<'de> for GeneratedField {
1991 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1992 where
1993 D: serde::Deserializer<'de>,
1994 {
1995 struct GeneratedVisitor;
1996
1997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1998 type Value = GeneratedField;
1999
2000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2001 write!(formatter, "expected one of: {:?}", &FIELDS)
2002 }
2003
2004 #[allow(unused_variables)]
2005 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2006 where
2007 E: serde::de::Error,
2008 {
2009 match value {
2010 "host" => Ok(GeneratedField::Host),
2011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2012 }
2013 }
2014 }
2015 deserializer.deserialize_identifier(GeneratedVisitor)
2016 }
2017 }
2018 struct GeneratedVisitor;
2019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2020 type Value = DeleteWorkerNodeRequest;
2021
2022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2023 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2024 }
2025
2026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2027 where
2028 V: serde::de::MapAccess<'de>,
2029 {
2030 let mut host__ = None;
2031 while let Some(k) = map_.next_key()? {
2032 match k {
2033 GeneratedField::Host => {
2034 if host__.is_some() {
2035 return Err(serde::de::Error::duplicate_field("host"));
2036 }
2037 host__ = map_.next_value()?;
2038 }
2039 }
2040 }
2041 Ok(DeleteWorkerNodeRequest {
2042 host: host__,
2043 })
2044 }
2045 }
2046 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2047 }
2048}
2049impl serde::Serialize for DeleteWorkerNodeResponse {
2050 #[allow(deprecated)]
2051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2052 where
2053 S: serde::Serializer,
2054 {
2055 use serde::ser::SerializeStruct;
2056 let mut len = 0;
2057 if self.status.is_some() {
2058 len += 1;
2059 }
2060 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2061 if let Some(v) = self.status.as_ref() {
2062 struct_ser.serialize_field("status", v)?;
2063 }
2064 struct_ser.end()
2065 }
2066}
2067impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2068 #[allow(deprecated)]
2069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2070 where
2071 D: serde::Deserializer<'de>,
2072 {
2073 const FIELDS: &[&str] = &[
2074 "status",
2075 ];
2076
2077 #[allow(clippy::enum_variant_names)]
2078 enum GeneratedField {
2079 Status,
2080 }
2081 impl<'de> serde::Deserialize<'de> for GeneratedField {
2082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083 where
2084 D: serde::Deserializer<'de>,
2085 {
2086 struct GeneratedVisitor;
2087
2088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089 type Value = GeneratedField;
2090
2091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092 write!(formatter, "expected one of: {:?}", &FIELDS)
2093 }
2094
2095 #[allow(unused_variables)]
2096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097 where
2098 E: serde::de::Error,
2099 {
2100 match value {
2101 "status" => Ok(GeneratedField::Status),
2102 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2103 }
2104 }
2105 }
2106 deserializer.deserialize_identifier(GeneratedVisitor)
2107 }
2108 }
2109 struct GeneratedVisitor;
2110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2111 type Value = DeleteWorkerNodeResponse;
2112
2113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2114 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2115 }
2116
2117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2118 where
2119 V: serde::de::MapAccess<'de>,
2120 {
2121 let mut status__ = None;
2122 while let Some(k) = map_.next_key()? {
2123 match k {
2124 GeneratedField::Status => {
2125 if status__.is_some() {
2126 return Err(serde::de::Error::duplicate_field("status"));
2127 }
2128 status__ = map_.next_value()?;
2129 }
2130 }
2131 }
2132 Ok(DeleteWorkerNodeResponse {
2133 status: status__,
2134 })
2135 }
2136 }
2137 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2138 }
2139}
2140impl serde::Serialize for EventLog {
2141 #[allow(deprecated)]
2142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2143 where
2144 S: serde::Serializer,
2145 {
2146 use serde::ser::SerializeStruct;
2147 let mut len = 0;
2148 if self.unique_id.is_some() {
2149 len += 1;
2150 }
2151 if self.timestamp.is_some() {
2152 len += 1;
2153 }
2154 if self.event.is_some() {
2155 len += 1;
2156 }
2157 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2158 if let Some(v) = self.unique_id.as_ref() {
2159 struct_ser.serialize_field("uniqueId", v)?;
2160 }
2161 if let Some(v) = self.timestamp.as_ref() {
2162 #[allow(clippy::needless_borrow)]
2163 #[allow(clippy::needless_borrows_for_generic_args)]
2164 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2165 }
2166 if let Some(v) = self.event.as_ref() {
2167 match v {
2168 event_log::Event::CreateStreamJobFail(v) => {
2169 struct_ser.serialize_field("createStreamJobFail", v)?;
2170 }
2171 event_log::Event::DirtyStreamJobClear(v) => {
2172 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2173 }
2174 event_log::Event::MetaNodeStart(v) => {
2175 struct_ser.serialize_field("metaNodeStart", v)?;
2176 }
2177 event_log::Event::BarrierComplete(v) => {
2178 struct_ser.serialize_field("barrierComplete", v)?;
2179 }
2180 event_log::Event::InjectBarrierFail(v) => {
2181 struct_ser.serialize_field("injectBarrierFail", v)?;
2182 }
2183 event_log::Event::CollectBarrierFail(v) => {
2184 struct_ser.serialize_field("collectBarrierFail", v)?;
2185 }
2186 event_log::Event::WorkerNodePanic(v) => {
2187 struct_ser.serialize_field("workerNodePanic", v)?;
2188 }
2189 event_log::Event::AutoSchemaChangeFail(v) => {
2190 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2191 }
2192 event_log::Event::SinkFail(v) => {
2193 struct_ser.serialize_field("sinkFail", v)?;
2194 }
2195 event_log::Event::Recovery(v) => {
2196 struct_ser.serialize_field("recovery", v)?;
2197 }
2198 }
2199 }
2200 struct_ser.end()
2201 }
2202}
2203impl<'de> serde::Deserialize<'de> for EventLog {
2204 #[allow(deprecated)]
2205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2206 where
2207 D: serde::Deserializer<'de>,
2208 {
2209 const FIELDS: &[&str] = &[
2210 "unique_id",
2211 "uniqueId",
2212 "timestamp",
2213 "create_stream_job_fail",
2214 "createStreamJobFail",
2215 "dirty_stream_job_clear",
2216 "dirtyStreamJobClear",
2217 "meta_node_start",
2218 "metaNodeStart",
2219 "barrier_complete",
2220 "barrierComplete",
2221 "inject_barrier_fail",
2222 "injectBarrierFail",
2223 "collect_barrier_fail",
2224 "collectBarrierFail",
2225 "worker_node_panic",
2226 "workerNodePanic",
2227 "auto_schema_change_fail",
2228 "autoSchemaChangeFail",
2229 "sink_fail",
2230 "sinkFail",
2231 "recovery",
2232 ];
2233
2234 #[allow(clippy::enum_variant_names)]
2235 enum GeneratedField {
2236 UniqueId,
2237 Timestamp,
2238 CreateStreamJobFail,
2239 DirtyStreamJobClear,
2240 MetaNodeStart,
2241 BarrierComplete,
2242 InjectBarrierFail,
2243 CollectBarrierFail,
2244 WorkerNodePanic,
2245 AutoSchemaChangeFail,
2246 SinkFail,
2247 Recovery,
2248 }
2249 impl<'de> serde::Deserialize<'de> for GeneratedField {
2250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2251 where
2252 D: serde::Deserializer<'de>,
2253 {
2254 struct GeneratedVisitor;
2255
2256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2257 type Value = GeneratedField;
2258
2259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2260 write!(formatter, "expected one of: {:?}", &FIELDS)
2261 }
2262
2263 #[allow(unused_variables)]
2264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2265 where
2266 E: serde::de::Error,
2267 {
2268 match value {
2269 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2270 "timestamp" => Ok(GeneratedField::Timestamp),
2271 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2272 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2273 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2274 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2275 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2276 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2277 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2278 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2279 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2280 "recovery" => Ok(GeneratedField::Recovery),
2281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2282 }
2283 }
2284 }
2285 deserializer.deserialize_identifier(GeneratedVisitor)
2286 }
2287 }
2288 struct GeneratedVisitor;
2289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2290 type Value = EventLog;
2291
2292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2293 formatter.write_str("struct meta.EventLog")
2294 }
2295
2296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2297 where
2298 V: serde::de::MapAccess<'de>,
2299 {
2300 let mut unique_id__ = None;
2301 let mut timestamp__ = None;
2302 let mut event__ = None;
2303 while let Some(k) = map_.next_key()? {
2304 match k {
2305 GeneratedField::UniqueId => {
2306 if unique_id__.is_some() {
2307 return Err(serde::de::Error::duplicate_field("uniqueId"));
2308 }
2309 unique_id__ = map_.next_value()?;
2310 }
2311 GeneratedField::Timestamp => {
2312 if timestamp__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("timestamp"));
2314 }
2315 timestamp__ =
2316 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2317 ;
2318 }
2319 GeneratedField::CreateStreamJobFail => {
2320 if event__.is_some() {
2321 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2322 }
2323 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2324;
2325 }
2326 GeneratedField::DirtyStreamJobClear => {
2327 if event__.is_some() {
2328 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2329 }
2330 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2331;
2332 }
2333 GeneratedField::MetaNodeStart => {
2334 if event__.is_some() {
2335 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2336 }
2337 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2338;
2339 }
2340 GeneratedField::BarrierComplete => {
2341 if event__.is_some() {
2342 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2343 }
2344 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2345;
2346 }
2347 GeneratedField::InjectBarrierFail => {
2348 if event__.is_some() {
2349 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2350 }
2351 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2352;
2353 }
2354 GeneratedField::CollectBarrierFail => {
2355 if event__.is_some() {
2356 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2357 }
2358 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2359;
2360 }
2361 GeneratedField::WorkerNodePanic => {
2362 if event__.is_some() {
2363 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2364 }
2365 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2366;
2367 }
2368 GeneratedField::AutoSchemaChangeFail => {
2369 if event__.is_some() {
2370 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2371 }
2372 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2373;
2374 }
2375 GeneratedField::SinkFail => {
2376 if event__.is_some() {
2377 return Err(serde::de::Error::duplicate_field("sinkFail"));
2378 }
2379 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2380;
2381 }
2382 GeneratedField::Recovery => {
2383 if event__.is_some() {
2384 return Err(serde::de::Error::duplicate_field("recovery"));
2385 }
2386 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2387;
2388 }
2389 }
2390 }
2391 Ok(EventLog {
2392 unique_id: unique_id__,
2393 timestamp: timestamp__,
2394 event: event__,
2395 })
2396 }
2397 }
2398 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2399 }
2400}
2401impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2402 #[allow(deprecated)]
2403 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2404 where
2405 S: serde::Serializer,
2406 {
2407 use serde::ser::SerializeStruct;
2408 let mut len = 0;
2409 if self.table_id != 0 {
2410 len += 1;
2411 }
2412 if !self.table_name.is_empty() {
2413 len += 1;
2414 }
2415 if !self.cdc_table_id.is_empty() {
2416 len += 1;
2417 }
2418 if !self.upstream_ddl.is_empty() {
2419 len += 1;
2420 }
2421 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2422 if self.table_id != 0 {
2423 struct_ser.serialize_field("tableId", &self.table_id)?;
2424 }
2425 if !self.table_name.is_empty() {
2426 struct_ser.serialize_field("tableName", &self.table_name)?;
2427 }
2428 if !self.cdc_table_id.is_empty() {
2429 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2430 }
2431 if !self.upstream_ddl.is_empty() {
2432 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2433 }
2434 struct_ser.end()
2435 }
2436}
2437impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2438 #[allow(deprecated)]
2439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440 where
2441 D: serde::Deserializer<'de>,
2442 {
2443 const FIELDS: &[&str] = &[
2444 "table_id",
2445 "tableId",
2446 "table_name",
2447 "tableName",
2448 "cdc_table_id",
2449 "cdcTableId",
2450 "upstream_ddl",
2451 "upstreamDdl",
2452 ];
2453
2454 #[allow(clippy::enum_variant_names)]
2455 enum GeneratedField {
2456 TableId,
2457 TableName,
2458 CdcTableId,
2459 UpstreamDdl,
2460 }
2461 impl<'de> serde::Deserialize<'de> for GeneratedField {
2462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2463 where
2464 D: serde::Deserializer<'de>,
2465 {
2466 struct GeneratedVisitor;
2467
2468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2469 type Value = GeneratedField;
2470
2471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2472 write!(formatter, "expected one of: {:?}", &FIELDS)
2473 }
2474
2475 #[allow(unused_variables)]
2476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2477 where
2478 E: serde::de::Error,
2479 {
2480 match value {
2481 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2482 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2483 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2484 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2485 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2486 }
2487 }
2488 }
2489 deserializer.deserialize_identifier(GeneratedVisitor)
2490 }
2491 }
2492 struct GeneratedVisitor;
2493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2494 type Value = event_log::EventAutoSchemaChangeFail;
2495
2496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2497 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2498 }
2499
2500 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2501 where
2502 V: serde::de::MapAccess<'de>,
2503 {
2504 let mut table_id__ = None;
2505 let mut table_name__ = None;
2506 let mut cdc_table_id__ = None;
2507 let mut upstream_ddl__ = None;
2508 while let Some(k) = map_.next_key()? {
2509 match k {
2510 GeneratedField::TableId => {
2511 if table_id__.is_some() {
2512 return Err(serde::de::Error::duplicate_field("tableId"));
2513 }
2514 table_id__ =
2515 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2516 ;
2517 }
2518 GeneratedField::TableName => {
2519 if table_name__.is_some() {
2520 return Err(serde::de::Error::duplicate_field("tableName"));
2521 }
2522 table_name__ = Some(map_.next_value()?);
2523 }
2524 GeneratedField::CdcTableId => {
2525 if cdc_table_id__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("cdcTableId"));
2527 }
2528 cdc_table_id__ = Some(map_.next_value()?);
2529 }
2530 GeneratedField::UpstreamDdl => {
2531 if upstream_ddl__.is_some() {
2532 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
2533 }
2534 upstream_ddl__ = Some(map_.next_value()?);
2535 }
2536 }
2537 }
2538 Ok(event_log::EventAutoSchemaChangeFail {
2539 table_id: table_id__.unwrap_or_default(),
2540 table_name: table_name__.unwrap_or_default(),
2541 cdc_table_id: cdc_table_id__.unwrap_or_default(),
2542 upstream_ddl: upstream_ddl__.unwrap_or_default(),
2543 })
2544 }
2545 }
2546 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
2547 }
2548}
2549impl serde::Serialize for event_log::EventBarrierComplete {
2550 #[allow(deprecated)]
2551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2552 where
2553 S: serde::Serializer,
2554 {
2555 use serde::ser::SerializeStruct;
2556 let mut len = 0;
2557 if self.prev_epoch != 0 {
2558 len += 1;
2559 }
2560 if self.cur_epoch != 0 {
2561 len += 1;
2562 }
2563 if self.duration_sec != 0. {
2564 len += 1;
2565 }
2566 if !self.command.is_empty() {
2567 len += 1;
2568 }
2569 if !self.barrier_kind.is_empty() {
2570 len += 1;
2571 }
2572 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
2573 if self.prev_epoch != 0 {
2574 #[allow(clippy::needless_borrow)]
2575 #[allow(clippy::needless_borrows_for_generic_args)]
2576 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
2577 }
2578 if self.cur_epoch != 0 {
2579 #[allow(clippy::needless_borrow)]
2580 #[allow(clippy::needless_borrows_for_generic_args)]
2581 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
2582 }
2583 if self.duration_sec != 0. {
2584 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
2585 }
2586 if !self.command.is_empty() {
2587 struct_ser.serialize_field("command", &self.command)?;
2588 }
2589 if !self.barrier_kind.is_empty() {
2590 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
2591 }
2592 struct_ser.end()
2593 }
2594}
2595impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
2596 #[allow(deprecated)]
2597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2598 where
2599 D: serde::Deserializer<'de>,
2600 {
2601 const FIELDS: &[&str] = &[
2602 "prev_epoch",
2603 "prevEpoch",
2604 "cur_epoch",
2605 "curEpoch",
2606 "duration_sec",
2607 "durationSec",
2608 "command",
2609 "barrier_kind",
2610 "barrierKind",
2611 ];
2612
2613 #[allow(clippy::enum_variant_names)]
2614 enum GeneratedField {
2615 PrevEpoch,
2616 CurEpoch,
2617 DurationSec,
2618 Command,
2619 BarrierKind,
2620 }
2621 impl<'de> serde::Deserialize<'de> for GeneratedField {
2622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2623 where
2624 D: serde::Deserializer<'de>,
2625 {
2626 struct GeneratedVisitor;
2627
2628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2629 type Value = GeneratedField;
2630
2631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2632 write!(formatter, "expected one of: {:?}", &FIELDS)
2633 }
2634
2635 #[allow(unused_variables)]
2636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2637 where
2638 E: serde::de::Error,
2639 {
2640 match value {
2641 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
2642 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
2643 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
2644 "command" => Ok(GeneratedField::Command),
2645 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
2646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2647 }
2648 }
2649 }
2650 deserializer.deserialize_identifier(GeneratedVisitor)
2651 }
2652 }
2653 struct GeneratedVisitor;
2654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2655 type Value = event_log::EventBarrierComplete;
2656
2657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2658 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
2659 }
2660
2661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
2662 where
2663 V: serde::de::MapAccess<'de>,
2664 {
2665 let mut prev_epoch__ = None;
2666 let mut cur_epoch__ = None;
2667 let mut duration_sec__ = None;
2668 let mut command__ = None;
2669 let mut barrier_kind__ = None;
2670 while let Some(k) = map_.next_key()? {
2671 match k {
2672 GeneratedField::PrevEpoch => {
2673 if prev_epoch__.is_some() {
2674 return Err(serde::de::Error::duplicate_field("prevEpoch"));
2675 }
2676 prev_epoch__ =
2677 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2678 ;
2679 }
2680 GeneratedField::CurEpoch => {
2681 if cur_epoch__.is_some() {
2682 return Err(serde::de::Error::duplicate_field("curEpoch"));
2683 }
2684 cur_epoch__ =
2685 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2686 ;
2687 }
2688 GeneratedField::DurationSec => {
2689 if duration_sec__.is_some() {
2690 return Err(serde::de::Error::duplicate_field("durationSec"));
2691 }
2692 duration_sec__ =
2693 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2694 ;
2695 }
2696 GeneratedField::Command => {
2697 if command__.is_some() {
2698 return Err(serde::de::Error::duplicate_field("command"));
2699 }
2700 command__ = Some(map_.next_value()?);
2701 }
2702 GeneratedField::BarrierKind => {
2703 if barrier_kind__.is_some() {
2704 return Err(serde::de::Error::duplicate_field("barrierKind"));
2705 }
2706 barrier_kind__ = Some(map_.next_value()?);
2707 }
2708 }
2709 }
2710 Ok(event_log::EventBarrierComplete {
2711 prev_epoch: prev_epoch__.unwrap_or_default(),
2712 cur_epoch: cur_epoch__.unwrap_or_default(),
2713 duration_sec: duration_sec__.unwrap_or_default(),
2714 command: command__.unwrap_or_default(),
2715 barrier_kind: barrier_kind__.unwrap_or_default(),
2716 })
2717 }
2718 }
2719 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
2720 }
2721}
2722impl serde::Serialize for event_log::EventCollectBarrierFail {
2723 #[allow(deprecated)]
2724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2725 where
2726 S: serde::Serializer,
2727 {
2728 use serde::ser::SerializeStruct;
2729 let mut len = 0;
2730 if !self.error.is_empty() {
2731 len += 1;
2732 }
2733 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
2734 if !self.error.is_empty() {
2735 struct_ser.serialize_field("error", &self.error)?;
2736 }
2737 struct_ser.end()
2738 }
2739}
2740impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
2741 #[allow(deprecated)]
2742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2743 where
2744 D: serde::Deserializer<'de>,
2745 {
2746 const FIELDS: &[&str] = &[
2747 "error",
2748 ];
2749
2750 #[allow(clippy::enum_variant_names)]
2751 enum GeneratedField {
2752 Error,
2753 }
2754 impl<'de> serde::Deserialize<'de> for GeneratedField {
2755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2756 where
2757 D: serde::Deserializer<'de>,
2758 {
2759 struct GeneratedVisitor;
2760
2761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2762 type Value = GeneratedField;
2763
2764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2765 write!(formatter, "expected one of: {:?}", &FIELDS)
2766 }
2767
2768 #[allow(unused_variables)]
2769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2770 where
2771 E: serde::de::Error,
2772 {
2773 match value {
2774 "error" => Ok(GeneratedField::Error),
2775 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2776 }
2777 }
2778 }
2779 deserializer.deserialize_identifier(GeneratedVisitor)
2780 }
2781 }
2782 struct GeneratedVisitor;
2783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2784 type Value = event_log::EventCollectBarrierFail;
2785
2786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2787 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
2788 }
2789
2790 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
2791 where
2792 V: serde::de::MapAccess<'de>,
2793 {
2794 let mut error__ = None;
2795 while let Some(k) = map_.next_key()? {
2796 match k {
2797 GeneratedField::Error => {
2798 if error__.is_some() {
2799 return Err(serde::de::Error::duplicate_field("error"));
2800 }
2801 error__ = Some(map_.next_value()?);
2802 }
2803 }
2804 }
2805 Ok(event_log::EventCollectBarrierFail {
2806 error: error__.unwrap_or_default(),
2807 })
2808 }
2809 }
2810 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
2811 }
2812}
2813impl serde::Serialize for event_log::EventCreateStreamJobFail {
2814 #[allow(deprecated)]
2815 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2816 where
2817 S: serde::Serializer,
2818 {
2819 use serde::ser::SerializeStruct;
2820 let mut len = 0;
2821 if self.id != 0 {
2822 len += 1;
2823 }
2824 if !self.name.is_empty() {
2825 len += 1;
2826 }
2827 if !self.definition.is_empty() {
2828 len += 1;
2829 }
2830 if !self.error.is_empty() {
2831 len += 1;
2832 }
2833 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
2834 if self.id != 0 {
2835 struct_ser.serialize_field("id", &self.id)?;
2836 }
2837 if !self.name.is_empty() {
2838 struct_ser.serialize_field("name", &self.name)?;
2839 }
2840 if !self.definition.is_empty() {
2841 struct_ser.serialize_field("definition", &self.definition)?;
2842 }
2843 if !self.error.is_empty() {
2844 struct_ser.serialize_field("error", &self.error)?;
2845 }
2846 struct_ser.end()
2847 }
2848}
2849impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
2850 #[allow(deprecated)]
2851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2852 where
2853 D: serde::Deserializer<'de>,
2854 {
2855 const FIELDS: &[&str] = &[
2856 "id",
2857 "name",
2858 "definition",
2859 "error",
2860 ];
2861
2862 #[allow(clippy::enum_variant_names)]
2863 enum GeneratedField {
2864 Id,
2865 Name,
2866 Definition,
2867 Error,
2868 }
2869 impl<'de> serde::Deserialize<'de> for GeneratedField {
2870 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2871 where
2872 D: serde::Deserializer<'de>,
2873 {
2874 struct GeneratedVisitor;
2875
2876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2877 type Value = GeneratedField;
2878
2879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2880 write!(formatter, "expected one of: {:?}", &FIELDS)
2881 }
2882
2883 #[allow(unused_variables)]
2884 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2885 where
2886 E: serde::de::Error,
2887 {
2888 match value {
2889 "id" => Ok(GeneratedField::Id),
2890 "name" => Ok(GeneratedField::Name),
2891 "definition" => Ok(GeneratedField::Definition),
2892 "error" => Ok(GeneratedField::Error),
2893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2894 }
2895 }
2896 }
2897 deserializer.deserialize_identifier(GeneratedVisitor)
2898 }
2899 }
2900 struct GeneratedVisitor;
2901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2902 type Value = event_log::EventCreateStreamJobFail;
2903
2904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2905 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
2906 }
2907
2908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
2909 where
2910 V: serde::de::MapAccess<'de>,
2911 {
2912 let mut id__ = None;
2913 let mut name__ = None;
2914 let mut definition__ = None;
2915 let mut error__ = None;
2916 while let Some(k) = map_.next_key()? {
2917 match k {
2918 GeneratedField::Id => {
2919 if id__.is_some() {
2920 return Err(serde::de::Error::duplicate_field("id"));
2921 }
2922 id__ =
2923 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2924 ;
2925 }
2926 GeneratedField::Name => {
2927 if name__.is_some() {
2928 return Err(serde::de::Error::duplicate_field("name"));
2929 }
2930 name__ = Some(map_.next_value()?);
2931 }
2932 GeneratedField::Definition => {
2933 if definition__.is_some() {
2934 return Err(serde::de::Error::duplicate_field("definition"));
2935 }
2936 definition__ = Some(map_.next_value()?);
2937 }
2938 GeneratedField::Error => {
2939 if error__.is_some() {
2940 return Err(serde::de::Error::duplicate_field("error"));
2941 }
2942 error__ = Some(map_.next_value()?);
2943 }
2944 }
2945 }
2946 Ok(event_log::EventCreateStreamJobFail {
2947 id: id__.unwrap_or_default(),
2948 name: name__.unwrap_or_default(),
2949 definition: definition__.unwrap_or_default(),
2950 error: error__.unwrap_or_default(),
2951 })
2952 }
2953 }
2954 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
2955 }
2956}
2957impl serde::Serialize for event_log::EventDirtyStreamJobClear {
2958 #[allow(deprecated)]
2959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2960 where
2961 S: serde::Serializer,
2962 {
2963 use serde::ser::SerializeStruct;
2964 let mut len = 0;
2965 if self.id != 0 {
2966 len += 1;
2967 }
2968 if !self.name.is_empty() {
2969 len += 1;
2970 }
2971 if !self.definition.is_empty() {
2972 len += 1;
2973 }
2974 if !self.error.is_empty() {
2975 len += 1;
2976 }
2977 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
2978 if self.id != 0 {
2979 struct_ser.serialize_field("id", &self.id)?;
2980 }
2981 if !self.name.is_empty() {
2982 struct_ser.serialize_field("name", &self.name)?;
2983 }
2984 if !self.definition.is_empty() {
2985 struct_ser.serialize_field("definition", &self.definition)?;
2986 }
2987 if !self.error.is_empty() {
2988 struct_ser.serialize_field("error", &self.error)?;
2989 }
2990 struct_ser.end()
2991 }
2992}
2993impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
2994 #[allow(deprecated)]
2995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2996 where
2997 D: serde::Deserializer<'de>,
2998 {
2999 const FIELDS: &[&str] = &[
3000 "id",
3001 "name",
3002 "definition",
3003 "error",
3004 ];
3005
3006 #[allow(clippy::enum_variant_names)]
3007 enum GeneratedField {
3008 Id,
3009 Name,
3010 Definition,
3011 Error,
3012 }
3013 impl<'de> serde::Deserialize<'de> for GeneratedField {
3014 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3015 where
3016 D: serde::Deserializer<'de>,
3017 {
3018 struct GeneratedVisitor;
3019
3020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3021 type Value = GeneratedField;
3022
3023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3024 write!(formatter, "expected one of: {:?}", &FIELDS)
3025 }
3026
3027 #[allow(unused_variables)]
3028 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3029 where
3030 E: serde::de::Error,
3031 {
3032 match value {
3033 "id" => Ok(GeneratedField::Id),
3034 "name" => Ok(GeneratedField::Name),
3035 "definition" => Ok(GeneratedField::Definition),
3036 "error" => Ok(GeneratedField::Error),
3037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3038 }
3039 }
3040 }
3041 deserializer.deserialize_identifier(GeneratedVisitor)
3042 }
3043 }
3044 struct GeneratedVisitor;
3045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3046 type Value = event_log::EventDirtyStreamJobClear;
3047
3048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3049 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3050 }
3051
3052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3053 where
3054 V: serde::de::MapAccess<'de>,
3055 {
3056 let mut id__ = None;
3057 let mut name__ = None;
3058 let mut definition__ = None;
3059 let mut error__ = None;
3060 while let Some(k) = map_.next_key()? {
3061 match k {
3062 GeneratedField::Id => {
3063 if id__.is_some() {
3064 return Err(serde::de::Error::duplicate_field("id"));
3065 }
3066 id__ =
3067 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3068 ;
3069 }
3070 GeneratedField::Name => {
3071 if name__.is_some() {
3072 return Err(serde::de::Error::duplicate_field("name"));
3073 }
3074 name__ = Some(map_.next_value()?);
3075 }
3076 GeneratedField::Definition => {
3077 if definition__.is_some() {
3078 return Err(serde::de::Error::duplicate_field("definition"));
3079 }
3080 definition__ = Some(map_.next_value()?);
3081 }
3082 GeneratedField::Error => {
3083 if error__.is_some() {
3084 return Err(serde::de::Error::duplicate_field("error"));
3085 }
3086 error__ = Some(map_.next_value()?);
3087 }
3088 }
3089 }
3090 Ok(event_log::EventDirtyStreamJobClear {
3091 id: id__.unwrap_or_default(),
3092 name: name__.unwrap_or_default(),
3093 definition: definition__.unwrap_or_default(),
3094 error: error__.unwrap_or_default(),
3095 })
3096 }
3097 }
3098 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3099 }
3100}
3101impl serde::Serialize for event_log::EventInjectBarrierFail {
3102 #[allow(deprecated)]
3103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3104 where
3105 S: serde::Serializer,
3106 {
3107 use serde::ser::SerializeStruct;
3108 let mut len = 0;
3109 if self.prev_epoch != 0 {
3110 len += 1;
3111 }
3112 if self.cur_epoch != 0 {
3113 len += 1;
3114 }
3115 if !self.error.is_empty() {
3116 len += 1;
3117 }
3118 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3119 if self.prev_epoch != 0 {
3120 #[allow(clippy::needless_borrow)]
3121 #[allow(clippy::needless_borrows_for_generic_args)]
3122 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3123 }
3124 if self.cur_epoch != 0 {
3125 #[allow(clippy::needless_borrow)]
3126 #[allow(clippy::needless_borrows_for_generic_args)]
3127 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3128 }
3129 if !self.error.is_empty() {
3130 struct_ser.serialize_field("error", &self.error)?;
3131 }
3132 struct_ser.end()
3133 }
3134}
3135impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3136 #[allow(deprecated)]
3137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3138 where
3139 D: serde::Deserializer<'de>,
3140 {
3141 const FIELDS: &[&str] = &[
3142 "prev_epoch",
3143 "prevEpoch",
3144 "cur_epoch",
3145 "curEpoch",
3146 "error",
3147 ];
3148
3149 #[allow(clippy::enum_variant_names)]
3150 enum GeneratedField {
3151 PrevEpoch,
3152 CurEpoch,
3153 Error,
3154 }
3155 impl<'de> serde::Deserialize<'de> for GeneratedField {
3156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3157 where
3158 D: serde::Deserializer<'de>,
3159 {
3160 struct GeneratedVisitor;
3161
3162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3163 type Value = GeneratedField;
3164
3165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3166 write!(formatter, "expected one of: {:?}", &FIELDS)
3167 }
3168
3169 #[allow(unused_variables)]
3170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3171 where
3172 E: serde::de::Error,
3173 {
3174 match value {
3175 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3176 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3177 "error" => Ok(GeneratedField::Error),
3178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3179 }
3180 }
3181 }
3182 deserializer.deserialize_identifier(GeneratedVisitor)
3183 }
3184 }
3185 struct GeneratedVisitor;
3186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3187 type Value = event_log::EventInjectBarrierFail;
3188
3189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3190 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3191 }
3192
3193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3194 where
3195 V: serde::de::MapAccess<'de>,
3196 {
3197 let mut prev_epoch__ = None;
3198 let mut cur_epoch__ = None;
3199 let mut error__ = None;
3200 while let Some(k) = map_.next_key()? {
3201 match k {
3202 GeneratedField::PrevEpoch => {
3203 if prev_epoch__.is_some() {
3204 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3205 }
3206 prev_epoch__ =
3207 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3208 ;
3209 }
3210 GeneratedField::CurEpoch => {
3211 if cur_epoch__.is_some() {
3212 return Err(serde::de::Error::duplicate_field("curEpoch"));
3213 }
3214 cur_epoch__ =
3215 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3216 ;
3217 }
3218 GeneratedField::Error => {
3219 if error__.is_some() {
3220 return Err(serde::de::Error::duplicate_field("error"));
3221 }
3222 error__ = Some(map_.next_value()?);
3223 }
3224 }
3225 }
3226 Ok(event_log::EventInjectBarrierFail {
3227 prev_epoch: prev_epoch__.unwrap_or_default(),
3228 cur_epoch: cur_epoch__.unwrap_or_default(),
3229 error: error__.unwrap_or_default(),
3230 })
3231 }
3232 }
3233 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3234 }
3235}
3236impl serde::Serialize for event_log::EventMetaNodeStart {
3237 #[allow(deprecated)]
3238 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3239 where
3240 S: serde::Serializer,
3241 {
3242 use serde::ser::SerializeStruct;
3243 let mut len = 0;
3244 if !self.advertise_addr.is_empty() {
3245 len += 1;
3246 }
3247 if !self.listen_addr.is_empty() {
3248 len += 1;
3249 }
3250 if !self.opts.is_empty() {
3251 len += 1;
3252 }
3253 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3254 if !self.advertise_addr.is_empty() {
3255 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3256 }
3257 if !self.listen_addr.is_empty() {
3258 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3259 }
3260 if !self.opts.is_empty() {
3261 struct_ser.serialize_field("opts", &self.opts)?;
3262 }
3263 struct_ser.end()
3264 }
3265}
3266impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3267 #[allow(deprecated)]
3268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3269 where
3270 D: serde::Deserializer<'de>,
3271 {
3272 const FIELDS: &[&str] = &[
3273 "advertise_addr",
3274 "advertiseAddr",
3275 "listen_addr",
3276 "listenAddr",
3277 "opts",
3278 ];
3279
3280 #[allow(clippy::enum_variant_names)]
3281 enum GeneratedField {
3282 AdvertiseAddr,
3283 ListenAddr,
3284 Opts,
3285 }
3286 impl<'de> serde::Deserialize<'de> for GeneratedField {
3287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3288 where
3289 D: serde::Deserializer<'de>,
3290 {
3291 struct GeneratedVisitor;
3292
3293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3294 type Value = GeneratedField;
3295
3296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3297 write!(formatter, "expected one of: {:?}", &FIELDS)
3298 }
3299
3300 #[allow(unused_variables)]
3301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3302 where
3303 E: serde::de::Error,
3304 {
3305 match value {
3306 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3307 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3308 "opts" => Ok(GeneratedField::Opts),
3309 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3310 }
3311 }
3312 }
3313 deserializer.deserialize_identifier(GeneratedVisitor)
3314 }
3315 }
3316 struct GeneratedVisitor;
3317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3318 type Value = event_log::EventMetaNodeStart;
3319
3320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3321 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3322 }
3323
3324 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3325 where
3326 V: serde::de::MapAccess<'de>,
3327 {
3328 let mut advertise_addr__ = None;
3329 let mut listen_addr__ = None;
3330 let mut opts__ = None;
3331 while let Some(k) = map_.next_key()? {
3332 match k {
3333 GeneratedField::AdvertiseAddr => {
3334 if advertise_addr__.is_some() {
3335 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3336 }
3337 advertise_addr__ = Some(map_.next_value()?);
3338 }
3339 GeneratedField::ListenAddr => {
3340 if listen_addr__.is_some() {
3341 return Err(serde::de::Error::duplicate_field("listenAddr"));
3342 }
3343 listen_addr__ = Some(map_.next_value()?);
3344 }
3345 GeneratedField::Opts => {
3346 if opts__.is_some() {
3347 return Err(serde::de::Error::duplicate_field("opts"));
3348 }
3349 opts__ = Some(map_.next_value()?);
3350 }
3351 }
3352 }
3353 Ok(event_log::EventMetaNodeStart {
3354 advertise_addr: advertise_addr__.unwrap_or_default(),
3355 listen_addr: listen_addr__.unwrap_or_default(),
3356 opts: opts__.unwrap_or_default(),
3357 })
3358 }
3359 }
3360 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3361 }
3362}
3363impl serde::Serialize for event_log::EventRecovery {
3364 #[allow(deprecated)]
3365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3366 where
3367 S: serde::Serializer,
3368 {
3369 use serde::ser::SerializeStruct;
3370 let mut len = 0;
3371 if self.recovery_event.is_some() {
3372 len += 1;
3373 }
3374 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3375 if let Some(v) = self.recovery_event.as_ref() {
3376 match v {
3377 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3378 struct_ser.serialize_field("globalStart", v)?;
3379 }
3380 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3381 struct_ser.serialize_field("globalSuccess", v)?;
3382 }
3383 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3384 struct_ser.serialize_field("globalFailure", v)?;
3385 }
3386 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3387 struct_ser.serialize_field("databaseStart", v)?;
3388 }
3389 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3390 struct_ser.serialize_field("databaseFailure", v)?;
3391 }
3392 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3393 struct_ser.serialize_field("databaseSuccess", v)?;
3394 }
3395 }
3396 }
3397 struct_ser.end()
3398 }
3399}
3400impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3401 #[allow(deprecated)]
3402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3403 where
3404 D: serde::Deserializer<'de>,
3405 {
3406 const FIELDS: &[&str] = &[
3407 "global_start",
3408 "globalStart",
3409 "global_success",
3410 "globalSuccess",
3411 "global_failure",
3412 "globalFailure",
3413 "database_start",
3414 "databaseStart",
3415 "database_failure",
3416 "databaseFailure",
3417 "database_success",
3418 "databaseSuccess",
3419 ];
3420
3421 #[allow(clippy::enum_variant_names)]
3422 enum GeneratedField {
3423 GlobalStart,
3424 GlobalSuccess,
3425 GlobalFailure,
3426 DatabaseStart,
3427 DatabaseFailure,
3428 DatabaseSuccess,
3429 }
3430 impl<'de> serde::Deserialize<'de> for GeneratedField {
3431 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3432 where
3433 D: serde::Deserializer<'de>,
3434 {
3435 struct GeneratedVisitor;
3436
3437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3438 type Value = GeneratedField;
3439
3440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3441 write!(formatter, "expected one of: {:?}", &FIELDS)
3442 }
3443
3444 #[allow(unused_variables)]
3445 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3446 where
3447 E: serde::de::Error,
3448 {
3449 match value {
3450 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3451 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3452 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3453 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3454 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3455 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3457 }
3458 }
3459 }
3460 deserializer.deserialize_identifier(GeneratedVisitor)
3461 }
3462 }
3463 struct GeneratedVisitor;
3464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3465 type Value = event_log::EventRecovery;
3466
3467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3468 formatter.write_str("struct meta.EventLog.EventRecovery")
3469 }
3470
3471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3472 where
3473 V: serde::de::MapAccess<'de>,
3474 {
3475 let mut recovery_event__ = None;
3476 while let Some(k) = map_.next_key()? {
3477 match k {
3478 GeneratedField::GlobalStart => {
3479 if recovery_event__.is_some() {
3480 return Err(serde::de::Error::duplicate_field("globalStart"));
3481 }
3482 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3483;
3484 }
3485 GeneratedField::GlobalSuccess => {
3486 if recovery_event__.is_some() {
3487 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3488 }
3489 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3490;
3491 }
3492 GeneratedField::GlobalFailure => {
3493 if recovery_event__.is_some() {
3494 return Err(serde::de::Error::duplicate_field("globalFailure"));
3495 }
3496 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3497;
3498 }
3499 GeneratedField::DatabaseStart => {
3500 if recovery_event__.is_some() {
3501 return Err(serde::de::Error::duplicate_field("databaseStart"));
3502 }
3503 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3504;
3505 }
3506 GeneratedField::DatabaseFailure => {
3507 if recovery_event__.is_some() {
3508 return Err(serde::de::Error::duplicate_field("databaseFailure"));
3509 }
3510 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
3511;
3512 }
3513 GeneratedField::DatabaseSuccess => {
3514 if recovery_event__.is_some() {
3515 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
3516 }
3517 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
3518;
3519 }
3520 }
3521 }
3522 Ok(event_log::EventRecovery {
3523 recovery_event: recovery_event__,
3524 })
3525 }
3526 }
3527 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
3528 }
3529}
3530impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
3531 #[allow(deprecated)]
3532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3533 where
3534 S: serde::Serializer,
3535 {
3536 use serde::ser::SerializeStruct;
3537 let mut len = 0;
3538 if self.database_id != 0 {
3539 len += 1;
3540 }
3541 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
3542 if self.database_id != 0 {
3543 struct_ser.serialize_field("databaseId", &self.database_id)?;
3544 }
3545 struct_ser.end()
3546 }
3547}
3548impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
3549 #[allow(deprecated)]
3550 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3551 where
3552 D: serde::Deserializer<'de>,
3553 {
3554 const FIELDS: &[&str] = &[
3555 "database_id",
3556 "databaseId",
3557 ];
3558
3559 #[allow(clippy::enum_variant_names)]
3560 enum GeneratedField {
3561 DatabaseId,
3562 }
3563 impl<'de> serde::Deserialize<'de> for GeneratedField {
3564 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3565 where
3566 D: serde::Deserializer<'de>,
3567 {
3568 struct GeneratedVisitor;
3569
3570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3571 type Value = GeneratedField;
3572
3573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3574 write!(formatter, "expected one of: {:?}", &FIELDS)
3575 }
3576
3577 #[allow(unused_variables)]
3578 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3579 where
3580 E: serde::de::Error,
3581 {
3582 match value {
3583 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3584 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3585 }
3586 }
3587 }
3588 deserializer.deserialize_identifier(GeneratedVisitor)
3589 }
3590 }
3591 struct GeneratedVisitor;
3592 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3593 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
3594
3595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3596 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
3597 }
3598
3599 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
3600 where
3601 V: serde::de::MapAccess<'de>,
3602 {
3603 let mut database_id__ = None;
3604 while let Some(k) = map_.next_key()? {
3605 match k {
3606 GeneratedField::DatabaseId => {
3607 if database_id__.is_some() {
3608 return Err(serde::de::Error::duplicate_field("databaseId"));
3609 }
3610 database_id__ =
3611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3612 ;
3613 }
3614 }
3615 }
3616 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
3617 database_id: database_id__.unwrap_or_default(),
3618 })
3619 }
3620 }
3621 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
3622 }
3623}
3624impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
3625 #[allow(deprecated)]
3626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3627 where
3628 S: serde::Serializer,
3629 {
3630 use serde::ser::SerializeStruct;
3631 let mut len = 0;
3632 if self.database_id != 0 {
3633 len += 1;
3634 }
3635 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
3636 if self.database_id != 0 {
3637 struct_ser.serialize_field("databaseId", &self.database_id)?;
3638 }
3639 struct_ser.end()
3640 }
3641}
3642impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
3643 #[allow(deprecated)]
3644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3645 where
3646 D: serde::Deserializer<'de>,
3647 {
3648 const FIELDS: &[&str] = &[
3649 "database_id",
3650 "databaseId",
3651 ];
3652
3653 #[allow(clippy::enum_variant_names)]
3654 enum GeneratedField {
3655 DatabaseId,
3656 }
3657 impl<'de> serde::Deserialize<'de> for GeneratedField {
3658 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3659 where
3660 D: serde::Deserializer<'de>,
3661 {
3662 struct GeneratedVisitor;
3663
3664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3665 type Value = GeneratedField;
3666
3667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3668 write!(formatter, "expected one of: {:?}", &FIELDS)
3669 }
3670
3671 #[allow(unused_variables)]
3672 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3673 where
3674 E: serde::de::Error,
3675 {
3676 match value {
3677 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3678 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3679 }
3680 }
3681 }
3682 deserializer.deserialize_identifier(GeneratedVisitor)
3683 }
3684 }
3685 struct GeneratedVisitor;
3686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3687 type Value = event_log::event_recovery::DatabaseRecoveryStart;
3688
3689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3690 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
3691 }
3692
3693 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
3694 where
3695 V: serde::de::MapAccess<'de>,
3696 {
3697 let mut database_id__ = None;
3698 while let Some(k) = map_.next_key()? {
3699 match k {
3700 GeneratedField::DatabaseId => {
3701 if database_id__.is_some() {
3702 return Err(serde::de::Error::duplicate_field("databaseId"));
3703 }
3704 database_id__ =
3705 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3706 ;
3707 }
3708 }
3709 }
3710 Ok(event_log::event_recovery::DatabaseRecoveryStart {
3711 database_id: database_id__.unwrap_or_default(),
3712 })
3713 }
3714 }
3715 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
3716 }
3717}
3718impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
3719 #[allow(deprecated)]
3720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3721 where
3722 S: serde::Serializer,
3723 {
3724 use serde::ser::SerializeStruct;
3725 let mut len = 0;
3726 if self.database_id != 0 {
3727 len += 1;
3728 }
3729 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
3730 if self.database_id != 0 {
3731 struct_ser.serialize_field("databaseId", &self.database_id)?;
3732 }
3733 struct_ser.end()
3734 }
3735}
3736impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
3737 #[allow(deprecated)]
3738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3739 where
3740 D: serde::Deserializer<'de>,
3741 {
3742 const FIELDS: &[&str] = &[
3743 "database_id",
3744 "databaseId",
3745 ];
3746
3747 #[allow(clippy::enum_variant_names)]
3748 enum GeneratedField {
3749 DatabaseId,
3750 }
3751 impl<'de> serde::Deserialize<'de> for GeneratedField {
3752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3753 where
3754 D: serde::Deserializer<'de>,
3755 {
3756 struct GeneratedVisitor;
3757
3758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3759 type Value = GeneratedField;
3760
3761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3762 write!(formatter, "expected one of: {:?}", &FIELDS)
3763 }
3764
3765 #[allow(unused_variables)]
3766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3767 where
3768 E: serde::de::Error,
3769 {
3770 match value {
3771 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3773 }
3774 }
3775 }
3776 deserializer.deserialize_identifier(GeneratedVisitor)
3777 }
3778 }
3779 struct GeneratedVisitor;
3780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3781 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
3782
3783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3784 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
3785 }
3786
3787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
3788 where
3789 V: serde::de::MapAccess<'de>,
3790 {
3791 let mut database_id__ = None;
3792 while let Some(k) = map_.next_key()? {
3793 match k {
3794 GeneratedField::DatabaseId => {
3795 if database_id__.is_some() {
3796 return Err(serde::de::Error::duplicate_field("databaseId"));
3797 }
3798 database_id__ =
3799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3800 ;
3801 }
3802 }
3803 }
3804 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
3805 database_id: database_id__.unwrap_or_default(),
3806 })
3807 }
3808 }
3809 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
3810 }
3811}
3812impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
3813 #[allow(deprecated)]
3814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3815 where
3816 S: serde::Serializer,
3817 {
3818 use serde::ser::SerializeStruct;
3819 let mut len = 0;
3820 if !self.reason.is_empty() {
3821 len += 1;
3822 }
3823 if !self.error.is_empty() {
3824 len += 1;
3825 }
3826 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
3827 if !self.reason.is_empty() {
3828 struct_ser.serialize_field("reason", &self.reason)?;
3829 }
3830 if !self.error.is_empty() {
3831 struct_ser.serialize_field("error", &self.error)?;
3832 }
3833 struct_ser.end()
3834 }
3835}
3836impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
3837 #[allow(deprecated)]
3838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3839 where
3840 D: serde::Deserializer<'de>,
3841 {
3842 const FIELDS: &[&str] = &[
3843 "reason",
3844 "error",
3845 ];
3846
3847 #[allow(clippy::enum_variant_names)]
3848 enum GeneratedField {
3849 Reason,
3850 Error,
3851 }
3852 impl<'de> serde::Deserialize<'de> for GeneratedField {
3853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3854 where
3855 D: serde::Deserializer<'de>,
3856 {
3857 struct GeneratedVisitor;
3858
3859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3860 type Value = GeneratedField;
3861
3862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3863 write!(formatter, "expected one of: {:?}", &FIELDS)
3864 }
3865
3866 #[allow(unused_variables)]
3867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3868 where
3869 E: serde::de::Error,
3870 {
3871 match value {
3872 "reason" => Ok(GeneratedField::Reason),
3873 "error" => Ok(GeneratedField::Error),
3874 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3875 }
3876 }
3877 }
3878 deserializer.deserialize_identifier(GeneratedVisitor)
3879 }
3880 }
3881 struct GeneratedVisitor;
3882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3883 type Value = event_log::event_recovery::GlobalRecoveryFailure;
3884
3885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3886 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
3887 }
3888
3889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
3890 where
3891 V: serde::de::MapAccess<'de>,
3892 {
3893 let mut reason__ = None;
3894 let mut error__ = None;
3895 while let Some(k) = map_.next_key()? {
3896 match k {
3897 GeneratedField::Reason => {
3898 if reason__.is_some() {
3899 return Err(serde::de::Error::duplicate_field("reason"));
3900 }
3901 reason__ = Some(map_.next_value()?);
3902 }
3903 GeneratedField::Error => {
3904 if error__.is_some() {
3905 return Err(serde::de::Error::duplicate_field("error"));
3906 }
3907 error__ = Some(map_.next_value()?);
3908 }
3909 }
3910 }
3911 Ok(event_log::event_recovery::GlobalRecoveryFailure {
3912 reason: reason__.unwrap_or_default(),
3913 error: error__.unwrap_or_default(),
3914 })
3915 }
3916 }
3917 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
3918 }
3919}
3920impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
3921 #[allow(deprecated)]
3922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3923 where
3924 S: serde::Serializer,
3925 {
3926 use serde::ser::SerializeStruct;
3927 let mut len = 0;
3928 if !self.reason.is_empty() {
3929 len += 1;
3930 }
3931 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
3932 if !self.reason.is_empty() {
3933 struct_ser.serialize_field("reason", &self.reason)?;
3934 }
3935 struct_ser.end()
3936 }
3937}
3938impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
3939 #[allow(deprecated)]
3940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3941 where
3942 D: serde::Deserializer<'de>,
3943 {
3944 const FIELDS: &[&str] = &[
3945 "reason",
3946 ];
3947
3948 #[allow(clippy::enum_variant_names)]
3949 enum GeneratedField {
3950 Reason,
3951 }
3952 impl<'de> serde::Deserialize<'de> for GeneratedField {
3953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3954 where
3955 D: serde::Deserializer<'de>,
3956 {
3957 struct GeneratedVisitor;
3958
3959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3960 type Value = GeneratedField;
3961
3962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3963 write!(formatter, "expected one of: {:?}", &FIELDS)
3964 }
3965
3966 #[allow(unused_variables)]
3967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3968 where
3969 E: serde::de::Error,
3970 {
3971 match value {
3972 "reason" => Ok(GeneratedField::Reason),
3973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3974 }
3975 }
3976 }
3977 deserializer.deserialize_identifier(GeneratedVisitor)
3978 }
3979 }
3980 struct GeneratedVisitor;
3981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3982 type Value = event_log::event_recovery::GlobalRecoveryStart;
3983
3984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3985 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
3986 }
3987
3988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
3989 where
3990 V: serde::de::MapAccess<'de>,
3991 {
3992 let mut reason__ = None;
3993 while let Some(k) = map_.next_key()? {
3994 match k {
3995 GeneratedField::Reason => {
3996 if reason__.is_some() {
3997 return Err(serde::de::Error::duplicate_field("reason"));
3998 }
3999 reason__ = Some(map_.next_value()?);
4000 }
4001 }
4002 }
4003 Ok(event_log::event_recovery::GlobalRecoveryStart {
4004 reason: reason__.unwrap_or_default(),
4005 })
4006 }
4007 }
4008 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4009 }
4010}
4011impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4012 #[allow(deprecated)]
4013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4014 where
4015 S: serde::Serializer,
4016 {
4017 use serde::ser::SerializeStruct;
4018 let mut len = 0;
4019 if !self.reason.is_empty() {
4020 len += 1;
4021 }
4022 if self.duration_secs != 0. {
4023 len += 1;
4024 }
4025 if !self.running_database_ids.is_empty() {
4026 len += 1;
4027 }
4028 if !self.recovering_database_ids.is_empty() {
4029 len += 1;
4030 }
4031 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4032 if !self.reason.is_empty() {
4033 struct_ser.serialize_field("reason", &self.reason)?;
4034 }
4035 if self.duration_secs != 0. {
4036 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4037 }
4038 if !self.running_database_ids.is_empty() {
4039 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4040 }
4041 if !self.recovering_database_ids.is_empty() {
4042 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4043 }
4044 struct_ser.end()
4045 }
4046}
4047impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4048 #[allow(deprecated)]
4049 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4050 where
4051 D: serde::Deserializer<'de>,
4052 {
4053 const FIELDS: &[&str] = &[
4054 "reason",
4055 "duration_secs",
4056 "durationSecs",
4057 "running_database_ids",
4058 "runningDatabaseIds",
4059 "recovering_database_ids",
4060 "recoveringDatabaseIds",
4061 ];
4062
4063 #[allow(clippy::enum_variant_names)]
4064 enum GeneratedField {
4065 Reason,
4066 DurationSecs,
4067 RunningDatabaseIds,
4068 RecoveringDatabaseIds,
4069 }
4070 impl<'de> serde::Deserialize<'de> for GeneratedField {
4071 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4072 where
4073 D: serde::Deserializer<'de>,
4074 {
4075 struct GeneratedVisitor;
4076
4077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4078 type Value = GeneratedField;
4079
4080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4081 write!(formatter, "expected one of: {:?}", &FIELDS)
4082 }
4083
4084 #[allow(unused_variables)]
4085 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4086 where
4087 E: serde::de::Error,
4088 {
4089 match value {
4090 "reason" => Ok(GeneratedField::Reason),
4091 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4092 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4093 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4095 }
4096 }
4097 }
4098 deserializer.deserialize_identifier(GeneratedVisitor)
4099 }
4100 }
4101 struct GeneratedVisitor;
4102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4103 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4107 }
4108
4109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4110 where
4111 V: serde::de::MapAccess<'de>,
4112 {
4113 let mut reason__ = None;
4114 let mut duration_secs__ = None;
4115 let mut running_database_ids__ = None;
4116 let mut recovering_database_ids__ = None;
4117 while let Some(k) = map_.next_key()? {
4118 match k {
4119 GeneratedField::Reason => {
4120 if reason__.is_some() {
4121 return Err(serde::de::Error::duplicate_field("reason"));
4122 }
4123 reason__ = Some(map_.next_value()?);
4124 }
4125 GeneratedField::DurationSecs => {
4126 if duration_secs__.is_some() {
4127 return Err(serde::de::Error::duplicate_field("durationSecs"));
4128 }
4129 duration_secs__ =
4130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4131 ;
4132 }
4133 GeneratedField::RunningDatabaseIds => {
4134 if running_database_ids__.is_some() {
4135 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4136 }
4137 running_database_ids__ =
4138 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4139 .into_iter().map(|x| x.0).collect())
4140 ;
4141 }
4142 GeneratedField::RecoveringDatabaseIds => {
4143 if recovering_database_ids__.is_some() {
4144 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4145 }
4146 recovering_database_ids__ =
4147 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4148 .into_iter().map(|x| x.0).collect())
4149 ;
4150 }
4151 }
4152 }
4153 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4154 reason: reason__.unwrap_or_default(),
4155 duration_secs: duration_secs__.unwrap_or_default(),
4156 running_database_ids: running_database_ids__.unwrap_or_default(),
4157 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4158 })
4159 }
4160 }
4161 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4162 }
4163}
4164impl serde::Serialize for event_log::EventSinkFail {
4165 #[allow(deprecated)]
4166 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4167 where
4168 S: serde::Serializer,
4169 {
4170 use serde::ser::SerializeStruct;
4171 let mut len = 0;
4172 if self.sink_id != 0 {
4173 len += 1;
4174 }
4175 if !self.sink_name.is_empty() {
4176 len += 1;
4177 }
4178 if !self.connector.is_empty() {
4179 len += 1;
4180 }
4181 if !self.error.is_empty() {
4182 len += 1;
4183 }
4184 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4185 if self.sink_id != 0 {
4186 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4187 }
4188 if !self.sink_name.is_empty() {
4189 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4190 }
4191 if !self.connector.is_empty() {
4192 struct_ser.serialize_field("connector", &self.connector)?;
4193 }
4194 if !self.error.is_empty() {
4195 struct_ser.serialize_field("error", &self.error)?;
4196 }
4197 struct_ser.end()
4198 }
4199}
4200impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4201 #[allow(deprecated)]
4202 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4203 where
4204 D: serde::Deserializer<'de>,
4205 {
4206 const FIELDS: &[&str] = &[
4207 "sink_id",
4208 "sinkId",
4209 "sink_name",
4210 "sinkName",
4211 "connector",
4212 "error",
4213 ];
4214
4215 #[allow(clippy::enum_variant_names)]
4216 enum GeneratedField {
4217 SinkId,
4218 SinkName,
4219 Connector,
4220 Error,
4221 }
4222 impl<'de> serde::Deserialize<'de> for GeneratedField {
4223 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4224 where
4225 D: serde::Deserializer<'de>,
4226 {
4227 struct GeneratedVisitor;
4228
4229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230 type Value = GeneratedField;
4231
4232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233 write!(formatter, "expected one of: {:?}", &FIELDS)
4234 }
4235
4236 #[allow(unused_variables)]
4237 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4238 where
4239 E: serde::de::Error,
4240 {
4241 match value {
4242 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4243 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4244 "connector" => Ok(GeneratedField::Connector),
4245 "error" => Ok(GeneratedField::Error),
4246 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4247 }
4248 }
4249 }
4250 deserializer.deserialize_identifier(GeneratedVisitor)
4251 }
4252 }
4253 struct GeneratedVisitor;
4254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4255 type Value = event_log::EventSinkFail;
4256
4257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4258 formatter.write_str("struct meta.EventLog.EventSinkFail")
4259 }
4260
4261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4262 where
4263 V: serde::de::MapAccess<'de>,
4264 {
4265 let mut sink_id__ = None;
4266 let mut sink_name__ = None;
4267 let mut connector__ = None;
4268 let mut error__ = None;
4269 while let Some(k) = map_.next_key()? {
4270 match k {
4271 GeneratedField::SinkId => {
4272 if sink_id__.is_some() {
4273 return Err(serde::de::Error::duplicate_field("sinkId"));
4274 }
4275 sink_id__ =
4276 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4277 ;
4278 }
4279 GeneratedField::SinkName => {
4280 if sink_name__.is_some() {
4281 return Err(serde::de::Error::duplicate_field("sinkName"));
4282 }
4283 sink_name__ = Some(map_.next_value()?);
4284 }
4285 GeneratedField::Connector => {
4286 if connector__.is_some() {
4287 return Err(serde::de::Error::duplicate_field("connector"));
4288 }
4289 connector__ = Some(map_.next_value()?);
4290 }
4291 GeneratedField::Error => {
4292 if error__.is_some() {
4293 return Err(serde::de::Error::duplicate_field("error"));
4294 }
4295 error__ = Some(map_.next_value()?);
4296 }
4297 }
4298 }
4299 Ok(event_log::EventSinkFail {
4300 sink_id: sink_id__.unwrap_or_default(),
4301 sink_name: sink_name__.unwrap_or_default(),
4302 connector: connector__.unwrap_or_default(),
4303 error: error__.unwrap_or_default(),
4304 })
4305 }
4306 }
4307 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4308 }
4309}
4310impl serde::Serialize for event_log::EventWorkerNodePanic {
4311 #[allow(deprecated)]
4312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4313 where
4314 S: serde::Serializer,
4315 {
4316 use serde::ser::SerializeStruct;
4317 let mut len = 0;
4318 if self.worker_id != 0 {
4319 len += 1;
4320 }
4321 if self.worker_type != 0 {
4322 len += 1;
4323 }
4324 if self.host_addr.is_some() {
4325 len += 1;
4326 }
4327 if !self.panic_info.is_empty() {
4328 len += 1;
4329 }
4330 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4331 if self.worker_id != 0 {
4332 struct_ser.serialize_field("workerId", &self.worker_id)?;
4333 }
4334 if self.worker_type != 0 {
4335 let v = super::common::WorkerType::try_from(self.worker_type)
4336 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4337 struct_ser.serialize_field("workerType", &v)?;
4338 }
4339 if let Some(v) = self.host_addr.as_ref() {
4340 struct_ser.serialize_field("hostAddr", v)?;
4341 }
4342 if !self.panic_info.is_empty() {
4343 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4344 }
4345 struct_ser.end()
4346 }
4347}
4348impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4349 #[allow(deprecated)]
4350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4351 where
4352 D: serde::Deserializer<'de>,
4353 {
4354 const FIELDS: &[&str] = &[
4355 "worker_id",
4356 "workerId",
4357 "worker_type",
4358 "workerType",
4359 "host_addr",
4360 "hostAddr",
4361 "panic_info",
4362 "panicInfo",
4363 ];
4364
4365 #[allow(clippy::enum_variant_names)]
4366 enum GeneratedField {
4367 WorkerId,
4368 WorkerType,
4369 HostAddr,
4370 PanicInfo,
4371 }
4372 impl<'de> serde::Deserialize<'de> for GeneratedField {
4373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4374 where
4375 D: serde::Deserializer<'de>,
4376 {
4377 struct GeneratedVisitor;
4378
4379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4380 type Value = GeneratedField;
4381
4382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4383 write!(formatter, "expected one of: {:?}", &FIELDS)
4384 }
4385
4386 #[allow(unused_variables)]
4387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4388 where
4389 E: serde::de::Error,
4390 {
4391 match value {
4392 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4393 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4394 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4395 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4396 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4397 }
4398 }
4399 }
4400 deserializer.deserialize_identifier(GeneratedVisitor)
4401 }
4402 }
4403 struct GeneratedVisitor;
4404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4405 type Value = event_log::EventWorkerNodePanic;
4406
4407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4408 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4409 }
4410
4411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4412 where
4413 V: serde::de::MapAccess<'de>,
4414 {
4415 let mut worker_id__ = None;
4416 let mut worker_type__ = None;
4417 let mut host_addr__ = None;
4418 let mut panic_info__ = None;
4419 while let Some(k) = map_.next_key()? {
4420 match k {
4421 GeneratedField::WorkerId => {
4422 if worker_id__.is_some() {
4423 return Err(serde::de::Error::duplicate_field("workerId"));
4424 }
4425 worker_id__ =
4426 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4427 ;
4428 }
4429 GeneratedField::WorkerType => {
4430 if worker_type__.is_some() {
4431 return Err(serde::de::Error::duplicate_field("workerType"));
4432 }
4433 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4434 }
4435 GeneratedField::HostAddr => {
4436 if host_addr__.is_some() {
4437 return Err(serde::de::Error::duplicate_field("hostAddr"));
4438 }
4439 host_addr__ = map_.next_value()?;
4440 }
4441 GeneratedField::PanicInfo => {
4442 if panic_info__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("panicInfo"));
4444 }
4445 panic_info__ = Some(map_.next_value()?);
4446 }
4447 }
4448 }
4449 Ok(event_log::EventWorkerNodePanic {
4450 worker_id: worker_id__.unwrap_or_default(),
4451 worker_type: worker_type__.unwrap_or_default(),
4452 host_addr: host_addr__,
4453 panic_info: panic_info__.unwrap_or_default(),
4454 })
4455 }
4456 }
4457 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4458 }
4459}
4460impl serde::Serialize for FlushRequest {
4461 #[allow(deprecated)]
4462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4463 where
4464 S: serde::Serializer,
4465 {
4466 use serde::ser::SerializeStruct;
4467 let mut len = 0;
4468 if self.database_id != 0 {
4469 len += 1;
4470 }
4471 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4472 if self.database_id != 0 {
4473 struct_ser.serialize_field("databaseId", &self.database_id)?;
4474 }
4475 struct_ser.end()
4476 }
4477}
4478impl<'de> serde::Deserialize<'de> for FlushRequest {
4479 #[allow(deprecated)]
4480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4481 where
4482 D: serde::Deserializer<'de>,
4483 {
4484 const FIELDS: &[&str] = &[
4485 "database_id",
4486 "databaseId",
4487 ];
4488
4489 #[allow(clippy::enum_variant_names)]
4490 enum GeneratedField {
4491 DatabaseId,
4492 }
4493 impl<'de> serde::Deserialize<'de> for GeneratedField {
4494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4495 where
4496 D: serde::Deserializer<'de>,
4497 {
4498 struct GeneratedVisitor;
4499
4500 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4501 type Value = GeneratedField;
4502
4503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4504 write!(formatter, "expected one of: {:?}", &FIELDS)
4505 }
4506
4507 #[allow(unused_variables)]
4508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4509 where
4510 E: serde::de::Error,
4511 {
4512 match value {
4513 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4515 }
4516 }
4517 }
4518 deserializer.deserialize_identifier(GeneratedVisitor)
4519 }
4520 }
4521 struct GeneratedVisitor;
4522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4523 type Value = FlushRequest;
4524
4525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4526 formatter.write_str("struct meta.FlushRequest")
4527 }
4528
4529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
4530 where
4531 V: serde::de::MapAccess<'de>,
4532 {
4533 let mut database_id__ = None;
4534 while let Some(k) = map_.next_key()? {
4535 match k {
4536 GeneratedField::DatabaseId => {
4537 if database_id__.is_some() {
4538 return Err(serde::de::Error::duplicate_field("databaseId"));
4539 }
4540 database_id__ =
4541 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4542 ;
4543 }
4544 }
4545 }
4546 Ok(FlushRequest {
4547 database_id: database_id__.unwrap_or_default(),
4548 })
4549 }
4550 }
4551 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
4552 }
4553}
4554impl serde::Serialize for FlushResponse {
4555 #[allow(deprecated)]
4556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4557 where
4558 S: serde::Serializer,
4559 {
4560 use serde::ser::SerializeStruct;
4561 let mut len = 0;
4562 if self.status.is_some() {
4563 len += 1;
4564 }
4565 if self.hummock_version_id != 0 {
4566 len += 1;
4567 }
4568 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
4569 if let Some(v) = self.status.as_ref() {
4570 struct_ser.serialize_field("status", v)?;
4571 }
4572 if self.hummock_version_id != 0 {
4573 #[allow(clippy::needless_borrow)]
4574 #[allow(clippy::needless_borrows_for_generic_args)]
4575 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
4576 }
4577 struct_ser.end()
4578 }
4579}
4580impl<'de> serde::Deserialize<'de> for FlushResponse {
4581 #[allow(deprecated)]
4582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4583 where
4584 D: serde::Deserializer<'de>,
4585 {
4586 const FIELDS: &[&str] = &[
4587 "status",
4588 "hummock_version_id",
4589 "hummockVersionId",
4590 ];
4591
4592 #[allow(clippy::enum_variant_names)]
4593 enum GeneratedField {
4594 Status,
4595 HummockVersionId,
4596 }
4597 impl<'de> serde::Deserialize<'de> for GeneratedField {
4598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4599 where
4600 D: serde::Deserializer<'de>,
4601 {
4602 struct GeneratedVisitor;
4603
4604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4605 type Value = GeneratedField;
4606
4607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4608 write!(formatter, "expected one of: {:?}", &FIELDS)
4609 }
4610
4611 #[allow(unused_variables)]
4612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4613 where
4614 E: serde::de::Error,
4615 {
4616 match value {
4617 "status" => Ok(GeneratedField::Status),
4618 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
4619 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4620 }
4621 }
4622 }
4623 deserializer.deserialize_identifier(GeneratedVisitor)
4624 }
4625 }
4626 struct GeneratedVisitor;
4627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4628 type Value = FlushResponse;
4629
4630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4631 formatter.write_str("struct meta.FlushResponse")
4632 }
4633
4634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
4635 where
4636 V: serde::de::MapAccess<'de>,
4637 {
4638 let mut status__ = None;
4639 let mut hummock_version_id__ = None;
4640 while let Some(k) = map_.next_key()? {
4641 match k {
4642 GeneratedField::Status => {
4643 if status__.is_some() {
4644 return Err(serde::de::Error::duplicate_field("status"));
4645 }
4646 status__ = map_.next_value()?;
4647 }
4648 GeneratedField::HummockVersionId => {
4649 if hummock_version_id__.is_some() {
4650 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
4651 }
4652 hummock_version_id__ =
4653 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4654 ;
4655 }
4656 }
4657 }
4658 Ok(FlushResponse {
4659 status: status__,
4660 hummock_version_id: hummock_version_id__.unwrap_or_default(),
4661 })
4662 }
4663 }
4664 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
4665 }
4666}
4667impl serde::Serialize for FragmentIdToActorIdMap {
4668 #[allow(deprecated)]
4669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4670 where
4671 S: serde::Serializer,
4672 {
4673 use serde::ser::SerializeStruct;
4674 let mut len = 0;
4675 if !self.map.is_empty() {
4676 len += 1;
4677 }
4678 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
4679 if !self.map.is_empty() {
4680 struct_ser.serialize_field("map", &self.map)?;
4681 }
4682 struct_ser.end()
4683 }
4684}
4685impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
4686 #[allow(deprecated)]
4687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4688 where
4689 D: serde::Deserializer<'de>,
4690 {
4691 const FIELDS: &[&str] = &[
4692 "map",
4693 ];
4694
4695 #[allow(clippy::enum_variant_names)]
4696 enum GeneratedField {
4697 Map,
4698 }
4699 impl<'de> serde::Deserialize<'de> for GeneratedField {
4700 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4701 where
4702 D: serde::Deserializer<'de>,
4703 {
4704 struct GeneratedVisitor;
4705
4706 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4707 type Value = GeneratedField;
4708
4709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4710 write!(formatter, "expected one of: {:?}", &FIELDS)
4711 }
4712
4713 #[allow(unused_variables)]
4714 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4715 where
4716 E: serde::de::Error,
4717 {
4718 match value {
4719 "map" => Ok(GeneratedField::Map),
4720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4721 }
4722 }
4723 }
4724 deserializer.deserialize_identifier(GeneratedVisitor)
4725 }
4726 }
4727 struct GeneratedVisitor;
4728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4729 type Value = FragmentIdToActorIdMap;
4730
4731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4732 formatter.write_str("struct meta.FragmentIdToActorIdMap")
4733 }
4734
4735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
4736 where
4737 V: serde::de::MapAccess<'de>,
4738 {
4739 let mut map__ = None;
4740 while let Some(k) = map_.next_key()? {
4741 match k {
4742 GeneratedField::Map => {
4743 if map__.is_some() {
4744 return Err(serde::de::Error::duplicate_field("map"));
4745 }
4746 map__ = Some(
4747 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
4748 .into_iter().map(|(k,v)| (k.0, v)).collect()
4749 );
4750 }
4751 }
4752 }
4753 Ok(FragmentIdToActorIdMap {
4754 map: map__.unwrap_or_default(),
4755 })
4756 }
4757 }
4758 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
4759 }
4760}
4761impl serde::Serialize for FragmentToRelationMap {
4762 #[allow(deprecated)]
4763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4764 where
4765 S: serde::Serializer,
4766 {
4767 use serde::ser::SerializeStruct;
4768 let mut len = 0;
4769 if !self.in_map.is_empty() {
4770 len += 1;
4771 }
4772 if !self.out_map.is_empty() {
4773 len += 1;
4774 }
4775 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
4776 if !self.in_map.is_empty() {
4777 struct_ser.serialize_field("inMap", &self.in_map)?;
4778 }
4779 if !self.out_map.is_empty() {
4780 struct_ser.serialize_field("outMap", &self.out_map)?;
4781 }
4782 struct_ser.end()
4783 }
4784}
4785impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
4786 #[allow(deprecated)]
4787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4788 where
4789 D: serde::Deserializer<'de>,
4790 {
4791 const FIELDS: &[&str] = &[
4792 "in_map",
4793 "inMap",
4794 "out_map",
4795 "outMap",
4796 ];
4797
4798 #[allow(clippy::enum_variant_names)]
4799 enum GeneratedField {
4800 InMap,
4801 OutMap,
4802 }
4803 impl<'de> serde::Deserialize<'de> for GeneratedField {
4804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4805 where
4806 D: serde::Deserializer<'de>,
4807 {
4808 struct GeneratedVisitor;
4809
4810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4811 type Value = GeneratedField;
4812
4813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4814 write!(formatter, "expected one of: {:?}", &FIELDS)
4815 }
4816
4817 #[allow(unused_variables)]
4818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4819 where
4820 E: serde::de::Error,
4821 {
4822 match value {
4823 "inMap" | "in_map" => Ok(GeneratedField::InMap),
4824 "outMap" | "out_map" => Ok(GeneratedField::OutMap),
4825 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4826 }
4827 }
4828 }
4829 deserializer.deserialize_identifier(GeneratedVisitor)
4830 }
4831 }
4832 struct GeneratedVisitor;
4833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4834 type Value = FragmentToRelationMap;
4835
4836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4837 formatter.write_str("struct meta.FragmentToRelationMap")
4838 }
4839
4840 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
4841 where
4842 V: serde::de::MapAccess<'de>,
4843 {
4844 let mut in_map__ = None;
4845 let mut out_map__ = None;
4846 while let Some(k) = map_.next_key()? {
4847 match k {
4848 GeneratedField::InMap => {
4849 if in_map__.is_some() {
4850 return Err(serde::de::Error::duplicate_field("inMap"));
4851 }
4852 in_map__ = Some(
4853 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
4854 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
4855 );
4856 }
4857 GeneratedField::OutMap => {
4858 if out_map__.is_some() {
4859 return Err(serde::de::Error::duplicate_field("outMap"));
4860 }
4861 out_map__ = Some(
4862 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
4863 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
4864 );
4865 }
4866 }
4867 }
4868 Ok(FragmentToRelationMap {
4869 in_map: in_map__.unwrap_or_default(),
4870 out_map: out_map__.unwrap_or_default(),
4871 })
4872 }
4873 }
4874 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
4875 }
4876}
4877impl serde::Serialize for FragmentWorkerSlotMapping {
4878 #[allow(deprecated)]
4879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4880 where
4881 S: serde::Serializer,
4882 {
4883 use serde::ser::SerializeStruct;
4884 let mut len = 0;
4885 if self.fragment_id != 0 {
4886 len += 1;
4887 }
4888 if self.mapping.is_some() {
4889 len += 1;
4890 }
4891 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
4892 if self.fragment_id != 0 {
4893 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
4894 }
4895 if let Some(v) = self.mapping.as_ref() {
4896 struct_ser.serialize_field("mapping", v)?;
4897 }
4898 struct_ser.end()
4899 }
4900}
4901impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
4902 #[allow(deprecated)]
4903 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4904 where
4905 D: serde::Deserializer<'de>,
4906 {
4907 const FIELDS: &[&str] = &[
4908 "fragment_id",
4909 "fragmentId",
4910 "mapping",
4911 ];
4912
4913 #[allow(clippy::enum_variant_names)]
4914 enum GeneratedField {
4915 FragmentId,
4916 Mapping,
4917 }
4918 impl<'de> serde::Deserialize<'de> for GeneratedField {
4919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4920 where
4921 D: serde::Deserializer<'de>,
4922 {
4923 struct GeneratedVisitor;
4924
4925 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4926 type Value = GeneratedField;
4927
4928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4929 write!(formatter, "expected one of: {:?}", &FIELDS)
4930 }
4931
4932 #[allow(unused_variables)]
4933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4934 where
4935 E: serde::de::Error,
4936 {
4937 match value {
4938 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
4939 "mapping" => Ok(GeneratedField::Mapping),
4940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4941 }
4942 }
4943 }
4944 deserializer.deserialize_identifier(GeneratedVisitor)
4945 }
4946 }
4947 struct GeneratedVisitor;
4948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4949 type Value = FragmentWorkerSlotMapping;
4950
4951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4952 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
4953 }
4954
4955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
4956 where
4957 V: serde::de::MapAccess<'de>,
4958 {
4959 let mut fragment_id__ = None;
4960 let mut mapping__ = None;
4961 while let Some(k) = map_.next_key()? {
4962 match k {
4963 GeneratedField::FragmentId => {
4964 if fragment_id__.is_some() {
4965 return Err(serde::de::Error::duplicate_field("fragmentId"));
4966 }
4967 fragment_id__ =
4968 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4969 ;
4970 }
4971 GeneratedField::Mapping => {
4972 if mapping__.is_some() {
4973 return Err(serde::de::Error::duplicate_field("mapping"));
4974 }
4975 mapping__ = map_.next_value()?;
4976 }
4977 }
4978 }
4979 Ok(FragmentWorkerSlotMapping {
4980 fragment_id: fragment_id__.unwrap_or_default(),
4981 mapping: mapping__,
4982 })
4983 }
4984 }
4985 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
4986 }
4987}
4988impl serde::Serialize for FragmentWorkerSlotMappings {
4989 #[allow(deprecated)]
4990 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4991 where
4992 S: serde::Serializer,
4993 {
4994 use serde::ser::SerializeStruct;
4995 let mut len = 0;
4996 if !self.mappings.is_empty() {
4997 len += 1;
4998 }
4999 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5000 if !self.mappings.is_empty() {
5001 struct_ser.serialize_field("mappings", &self.mappings)?;
5002 }
5003 struct_ser.end()
5004 }
5005}
5006impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5007 #[allow(deprecated)]
5008 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5009 where
5010 D: serde::Deserializer<'de>,
5011 {
5012 const FIELDS: &[&str] = &[
5013 "mappings",
5014 ];
5015
5016 #[allow(clippy::enum_variant_names)]
5017 enum GeneratedField {
5018 Mappings,
5019 }
5020 impl<'de> serde::Deserialize<'de> for GeneratedField {
5021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5022 where
5023 D: serde::Deserializer<'de>,
5024 {
5025 struct GeneratedVisitor;
5026
5027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5028 type Value = GeneratedField;
5029
5030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5031 write!(formatter, "expected one of: {:?}", &FIELDS)
5032 }
5033
5034 #[allow(unused_variables)]
5035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5036 where
5037 E: serde::de::Error,
5038 {
5039 match value {
5040 "mappings" => Ok(GeneratedField::Mappings),
5041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5042 }
5043 }
5044 }
5045 deserializer.deserialize_identifier(GeneratedVisitor)
5046 }
5047 }
5048 struct GeneratedVisitor;
5049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5050 type Value = FragmentWorkerSlotMappings;
5051
5052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5053 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5054 }
5055
5056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5057 where
5058 V: serde::de::MapAccess<'de>,
5059 {
5060 let mut mappings__ = None;
5061 while let Some(k) = map_.next_key()? {
5062 match k {
5063 GeneratedField::Mappings => {
5064 if mappings__.is_some() {
5065 return Err(serde::de::Error::duplicate_field("mappings"));
5066 }
5067 mappings__ = Some(map_.next_value()?);
5068 }
5069 }
5070 }
5071 Ok(FragmentWorkerSlotMappings {
5072 mappings: mappings__.unwrap_or_default(),
5073 })
5074 }
5075 }
5076 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5077 }
5078}
5079impl serde::Serialize for GetClusterInfoRequest {
5080 #[allow(deprecated)]
5081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5082 where
5083 S: serde::Serializer,
5084 {
5085 use serde::ser::SerializeStruct;
5086 let len = 0;
5087 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5088 struct_ser.end()
5089 }
5090}
5091impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5092 #[allow(deprecated)]
5093 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5094 where
5095 D: serde::Deserializer<'de>,
5096 {
5097 const FIELDS: &[&str] = &[
5098 ];
5099
5100 #[allow(clippy::enum_variant_names)]
5101 enum GeneratedField {
5102 }
5103 impl<'de> serde::Deserialize<'de> for GeneratedField {
5104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5105 where
5106 D: serde::Deserializer<'de>,
5107 {
5108 struct GeneratedVisitor;
5109
5110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5111 type Value = GeneratedField;
5112
5113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5114 write!(formatter, "expected one of: {:?}", &FIELDS)
5115 }
5116
5117 #[allow(unused_variables)]
5118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5119 where
5120 E: serde::de::Error,
5121 {
5122 Err(serde::de::Error::unknown_field(value, FIELDS))
5123 }
5124 }
5125 deserializer.deserialize_identifier(GeneratedVisitor)
5126 }
5127 }
5128 struct GeneratedVisitor;
5129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5130 type Value = GetClusterInfoRequest;
5131
5132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5133 formatter.write_str("struct meta.GetClusterInfoRequest")
5134 }
5135
5136 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5137 where
5138 V: serde::de::MapAccess<'de>,
5139 {
5140 while map_.next_key::<GeneratedField>()?.is_some() {
5141 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5142 }
5143 Ok(GetClusterInfoRequest {
5144 })
5145 }
5146 }
5147 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5148 }
5149}
5150impl serde::Serialize for GetClusterInfoResponse {
5151 #[allow(deprecated)]
5152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5153 where
5154 S: serde::Serializer,
5155 {
5156 use serde::ser::SerializeStruct;
5157 let mut len = 0;
5158 if !self.worker_nodes.is_empty() {
5159 len += 1;
5160 }
5161 if !self.table_fragments.is_empty() {
5162 len += 1;
5163 }
5164 if !self.actor_splits.is_empty() {
5165 len += 1;
5166 }
5167 if !self.source_infos.is_empty() {
5168 len += 1;
5169 }
5170 if self.revision != 0 {
5171 len += 1;
5172 }
5173 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5174 if !self.worker_nodes.is_empty() {
5175 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5176 }
5177 if !self.table_fragments.is_empty() {
5178 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5179 }
5180 if !self.actor_splits.is_empty() {
5181 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5182 }
5183 if !self.source_infos.is_empty() {
5184 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5185 }
5186 if self.revision != 0 {
5187 #[allow(clippy::needless_borrow)]
5188 #[allow(clippy::needless_borrows_for_generic_args)]
5189 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5190 }
5191 struct_ser.end()
5192 }
5193}
5194impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5195 #[allow(deprecated)]
5196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5197 where
5198 D: serde::Deserializer<'de>,
5199 {
5200 const FIELDS: &[&str] = &[
5201 "worker_nodes",
5202 "workerNodes",
5203 "table_fragments",
5204 "tableFragments",
5205 "actor_splits",
5206 "actorSplits",
5207 "source_infos",
5208 "sourceInfos",
5209 "revision",
5210 ];
5211
5212 #[allow(clippy::enum_variant_names)]
5213 enum GeneratedField {
5214 WorkerNodes,
5215 TableFragments,
5216 ActorSplits,
5217 SourceInfos,
5218 Revision,
5219 }
5220 impl<'de> serde::Deserialize<'de> for GeneratedField {
5221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5222 where
5223 D: serde::Deserializer<'de>,
5224 {
5225 struct GeneratedVisitor;
5226
5227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5228 type Value = GeneratedField;
5229
5230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5231 write!(formatter, "expected one of: {:?}", &FIELDS)
5232 }
5233
5234 #[allow(unused_variables)]
5235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5236 where
5237 E: serde::de::Error,
5238 {
5239 match value {
5240 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5241 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5242 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5243 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5244 "revision" => Ok(GeneratedField::Revision),
5245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5246 }
5247 }
5248 }
5249 deserializer.deserialize_identifier(GeneratedVisitor)
5250 }
5251 }
5252 struct GeneratedVisitor;
5253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5254 type Value = GetClusterInfoResponse;
5255
5256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5257 formatter.write_str("struct meta.GetClusterInfoResponse")
5258 }
5259
5260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5261 where
5262 V: serde::de::MapAccess<'de>,
5263 {
5264 let mut worker_nodes__ = None;
5265 let mut table_fragments__ = None;
5266 let mut actor_splits__ = None;
5267 let mut source_infos__ = None;
5268 let mut revision__ = None;
5269 while let Some(k) = map_.next_key()? {
5270 match k {
5271 GeneratedField::WorkerNodes => {
5272 if worker_nodes__.is_some() {
5273 return Err(serde::de::Error::duplicate_field("workerNodes"));
5274 }
5275 worker_nodes__ = Some(map_.next_value()?);
5276 }
5277 GeneratedField::TableFragments => {
5278 if table_fragments__.is_some() {
5279 return Err(serde::de::Error::duplicate_field("tableFragments"));
5280 }
5281 table_fragments__ = Some(map_.next_value()?);
5282 }
5283 GeneratedField::ActorSplits => {
5284 if actor_splits__.is_some() {
5285 return Err(serde::de::Error::duplicate_field("actorSplits"));
5286 }
5287 actor_splits__ = Some(
5288 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5289 .into_iter().map(|(k,v)| (k.0, v)).collect()
5290 );
5291 }
5292 GeneratedField::SourceInfos => {
5293 if source_infos__.is_some() {
5294 return Err(serde::de::Error::duplicate_field("sourceInfos"));
5295 }
5296 source_infos__ = Some(
5297 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5298 .into_iter().map(|(k,v)| (k.0, v)).collect()
5299 );
5300 }
5301 GeneratedField::Revision => {
5302 if revision__.is_some() {
5303 return Err(serde::de::Error::duplicate_field("revision"));
5304 }
5305 revision__ =
5306 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5307 ;
5308 }
5309 }
5310 }
5311 Ok(GetClusterInfoResponse {
5312 worker_nodes: worker_nodes__.unwrap_or_default(),
5313 table_fragments: table_fragments__.unwrap_or_default(),
5314 actor_splits: actor_splits__.unwrap_or_default(),
5315 source_infos: source_infos__.unwrap_or_default(),
5316 revision: revision__.unwrap_or_default(),
5317 })
5318 }
5319 }
5320 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
5321 }
5322}
5323impl serde::Serialize for GetClusterLimitsRequest {
5324 #[allow(deprecated)]
5325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5326 where
5327 S: serde::Serializer,
5328 {
5329 use serde::ser::SerializeStruct;
5330 let len = 0;
5331 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
5332 struct_ser.end()
5333 }
5334}
5335impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
5336 #[allow(deprecated)]
5337 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5338 where
5339 D: serde::Deserializer<'de>,
5340 {
5341 const FIELDS: &[&str] = &[
5342 ];
5343
5344 #[allow(clippy::enum_variant_names)]
5345 enum GeneratedField {
5346 }
5347 impl<'de> serde::Deserialize<'de> for GeneratedField {
5348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5349 where
5350 D: serde::Deserializer<'de>,
5351 {
5352 struct GeneratedVisitor;
5353
5354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5355 type Value = GeneratedField;
5356
5357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5358 write!(formatter, "expected one of: {:?}", &FIELDS)
5359 }
5360
5361 #[allow(unused_variables)]
5362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5363 where
5364 E: serde::de::Error,
5365 {
5366 Err(serde::de::Error::unknown_field(value, FIELDS))
5367 }
5368 }
5369 deserializer.deserialize_identifier(GeneratedVisitor)
5370 }
5371 }
5372 struct GeneratedVisitor;
5373 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5374 type Value = GetClusterLimitsRequest;
5375
5376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5377 formatter.write_str("struct meta.GetClusterLimitsRequest")
5378 }
5379
5380 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
5381 where
5382 V: serde::de::MapAccess<'de>,
5383 {
5384 while map_.next_key::<GeneratedField>()?.is_some() {
5385 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5386 }
5387 Ok(GetClusterLimitsRequest {
5388 })
5389 }
5390 }
5391 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
5392 }
5393}
5394impl serde::Serialize for GetClusterLimitsResponse {
5395 #[allow(deprecated)]
5396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5397 where
5398 S: serde::Serializer,
5399 {
5400 use serde::ser::SerializeStruct;
5401 let mut len = 0;
5402 if !self.active_limits.is_empty() {
5403 len += 1;
5404 }
5405 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
5406 if !self.active_limits.is_empty() {
5407 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
5408 }
5409 struct_ser.end()
5410 }
5411}
5412impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
5413 #[allow(deprecated)]
5414 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5415 where
5416 D: serde::Deserializer<'de>,
5417 {
5418 const FIELDS: &[&str] = &[
5419 "active_limits",
5420 "activeLimits",
5421 ];
5422
5423 #[allow(clippy::enum_variant_names)]
5424 enum GeneratedField {
5425 ActiveLimits,
5426 }
5427 impl<'de> serde::Deserialize<'de> for GeneratedField {
5428 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5429 where
5430 D: serde::Deserializer<'de>,
5431 {
5432 struct GeneratedVisitor;
5433
5434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5435 type Value = GeneratedField;
5436
5437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5438 write!(formatter, "expected one of: {:?}", &FIELDS)
5439 }
5440
5441 #[allow(unused_variables)]
5442 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5443 where
5444 E: serde::de::Error,
5445 {
5446 match value {
5447 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
5448 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5449 }
5450 }
5451 }
5452 deserializer.deserialize_identifier(GeneratedVisitor)
5453 }
5454 }
5455 struct GeneratedVisitor;
5456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5457 type Value = GetClusterLimitsResponse;
5458
5459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5460 formatter.write_str("struct meta.GetClusterLimitsResponse")
5461 }
5462
5463 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
5464 where
5465 V: serde::de::MapAccess<'de>,
5466 {
5467 let mut active_limits__ = None;
5468 while let Some(k) = map_.next_key()? {
5469 match k {
5470 GeneratedField::ActiveLimits => {
5471 if active_limits__.is_some() {
5472 return Err(serde::de::Error::duplicate_field("activeLimits"));
5473 }
5474 active_limits__ = Some(map_.next_value()?);
5475 }
5476 }
5477 }
5478 Ok(GetClusterLimitsResponse {
5479 active_limits: active_limits__.unwrap_or_default(),
5480 })
5481 }
5482 }
5483 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
5484 }
5485}
5486impl serde::Serialize for GetClusterRecoveryStatusRequest {
5487 #[allow(deprecated)]
5488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5489 where
5490 S: serde::Serializer,
5491 {
5492 use serde::ser::SerializeStruct;
5493 let len = 0;
5494 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
5495 struct_ser.end()
5496 }
5497}
5498impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
5499 #[allow(deprecated)]
5500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5501 where
5502 D: serde::Deserializer<'de>,
5503 {
5504 const FIELDS: &[&str] = &[
5505 ];
5506
5507 #[allow(clippy::enum_variant_names)]
5508 enum GeneratedField {
5509 }
5510 impl<'de> serde::Deserialize<'de> for GeneratedField {
5511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5512 where
5513 D: serde::Deserializer<'de>,
5514 {
5515 struct GeneratedVisitor;
5516
5517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5518 type Value = GeneratedField;
5519
5520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5521 write!(formatter, "expected one of: {:?}", &FIELDS)
5522 }
5523
5524 #[allow(unused_variables)]
5525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5526 where
5527 E: serde::de::Error,
5528 {
5529 Err(serde::de::Error::unknown_field(value, FIELDS))
5530 }
5531 }
5532 deserializer.deserialize_identifier(GeneratedVisitor)
5533 }
5534 }
5535 struct GeneratedVisitor;
5536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5537 type Value = GetClusterRecoveryStatusRequest;
5538
5539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5540 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
5541 }
5542
5543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
5544 where
5545 V: serde::de::MapAccess<'de>,
5546 {
5547 while map_.next_key::<GeneratedField>()?.is_some() {
5548 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5549 }
5550 Ok(GetClusterRecoveryStatusRequest {
5551 })
5552 }
5553 }
5554 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
5555 }
5556}
5557impl serde::Serialize for GetClusterRecoveryStatusResponse {
5558 #[allow(deprecated)]
5559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5560 where
5561 S: serde::Serializer,
5562 {
5563 use serde::ser::SerializeStruct;
5564 let mut len = 0;
5565 if self.status != 0 {
5566 len += 1;
5567 }
5568 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
5569 if self.status != 0 {
5570 let v = RecoveryStatus::try_from(self.status)
5571 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
5572 struct_ser.serialize_field("status", &v)?;
5573 }
5574 struct_ser.end()
5575 }
5576}
5577impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
5578 #[allow(deprecated)]
5579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5580 where
5581 D: serde::Deserializer<'de>,
5582 {
5583 const FIELDS: &[&str] = &[
5584 "status",
5585 ];
5586
5587 #[allow(clippy::enum_variant_names)]
5588 enum GeneratedField {
5589 Status,
5590 }
5591 impl<'de> serde::Deserialize<'de> for GeneratedField {
5592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5593 where
5594 D: serde::Deserializer<'de>,
5595 {
5596 struct GeneratedVisitor;
5597
5598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5599 type Value = GeneratedField;
5600
5601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5602 write!(formatter, "expected one of: {:?}", &FIELDS)
5603 }
5604
5605 #[allow(unused_variables)]
5606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5607 where
5608 E: serde::de::Error,
5609 {
5610 match value {
5611 "status" => Ok(GeneratedField::Status),
5612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5613 }
5614 }
5615 }
5616 deserializer.deserialize_identifier(GeneratedVisitor)
5617 }
5618 }
5619 struct GeneratedVisitor;
5620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5621 type Value = GetClusterRecoveryStatusResponse;
5622
5623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5624 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
5625 }
5626
5627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
5628 where
5629 V: serde::de::MapAccess<'de>,
5630 {
5631 let mut status__ = None;
5632 while let Some(k) = map_.next_key()? {
5633 match k {
5634 GeneratedField::Status => {
5635 if status__.is_some() {
5636 return Err(serde::de::Error::duplicate_field("status"));
5637 }
5638 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
5639 }
5640 }
5641 }
5642 Ok(GetClusterRecoveryStatusResponse {
5643 status: status__.unwrap_or_default(),
5644 })
5645 }
5646 }
5647 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
5648 }
5649}
5650impl serde::Serialize for GetMetaStoreInfoRequest {
5651 #[allow(deprecated)]
5652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5653 where
5654 S: serde::Serializer,
5655 {
5656 use serde::ser::SerializeStruct;
5657 let len = 0;
5658 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
5659 struct_ser.end()
5660 }
5661}
5662impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
5663 #[allow(deprecated)]
5664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5665 where
5666 D: serde::Deserializer<'de>,
5667 {
5668 const FIELDS: &[&str] = &[
5669 ];
5670
5671 #[allow(clippy::enum_variant_names)]
5672 enum GeneratedField {
5673 }
5674 impl<'de> serde::Deserialize<'de> for GeneratedField {
5675 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5676 where
5677 D: serde::Deserializer<'de>,
5678 {
5679 struct GeneratedVisitor;
5680
5681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5682 type Value = GeneratedField;
5683
5684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5685 write!(formatter, "expected one of: {:?}", &FIELDS)
5686 }
5687
5688 #[allow(unused_variables)]
5689 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5690 where
5691 E: serde::de::Error,
5692 {
5693 Err(serde::de::Error::unknown_field(value, FIELDS))
5694 }
5695 }
5696 deserializer.deserialize_identifier(GeneratedVisitor)
5697 }
5698 }
5699 struct GeneratedVisitor;
5700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5701 type Value = GetMetaStoreInfoRequest;
5702
5703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5704 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
5705 }
5706
5707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
5708 where
5709 V: serde::de::MapAccess<'de>,
5710 {
5711 while map_.next_key::<GeneratedField>()?.is_some() {
5712 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5713 }
5714 Ok(GetMetaStoreInfoRequest {
5715 })
5716 }
5717 }
5718 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
5719 }
5720}
5721impl serde::Serialize for GetMetaStoreInfoResponse {
5722 #[allow(deprecated)]
5723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5724 where
5725 S: serde::Serializer,
5726 {
5727 use serde::ser::SerializeStruct;
5728 let mut len = 0;
5729 if !self.meta_store_endpoint.is_empty() {
5730 len += 1;
5731 }
5732 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
5733 if !self.meta_store_endpoint.is_empty() {
5734 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
5735 }
5736 struct_ser.end()
5737 }
5738}
5739impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
5740 #[allow(deprecated)]
5741 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5742 where
5743 D: serde::Deserializer<'de>,
5744 {
5745 const FIELDS: &[&str] = &[
5746 "meta_store_endpoint",
5747 "metaStoreEndpoint",
5748 ];
5749
5750 #[allow(clippy::enum_variant_names)]
5751 enum GeneratedField {
5752 MetaStoreEndpoint,
5753 }
5754 impl<'de> serde::Deserialize<'de> for GeneratedField {
5755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5756 where
5757 D: serde::Deserializer<'de>,
5758 {
5759 struct GeneratedVisitor;
5760
5761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5762 type Value = GeneratedField;
5763
5764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5765 write!(formatter, "expected one of: {:?}", &FIELDS)
5766 }
5767
5768 #[allow(unused_variables)]
5769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5770 where
5771 E: serde::de::Error,
5772 {
5773 match value {
5774 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
5775 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5776 }
5777 }
5778 }
5779 deserializer.deserialize_identifier(GeneratedVisitor)
5780 }
5781 }
5782 struct GeneratedVisitor;
5783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5784 type Value = GetMetaStoreInfoResponse;
5785
5786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5787 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
5788 }
5789
5790 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
5791 where
5792 V: serde::de::MapAccess<'de>,
5793 {
5794 let mut meta_store_endpoint__ = None;
5795 while let Some(k) = map_.next_key()? {
5796 match k {
5797 GeneratedField::MetaStoreEndpoint => {
5798 if meta_store_endpoint__.is_some() {
5799 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
5800 }
5801 meta_store_endpoint__ = Some(map_.next_value()?);
5802 }
5803 }
5804 }
5805 Ok(GetMetaStoreInfoResponse {
5806 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
5807 })
5808 }
5809 }
5810 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
5811 }
5812}
5813impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
5814 #[allow(deprecated)]
5815 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5816 where
5817 S: serde::Serializer,
5818 {
5819 use serde::ser::SerializeStruct;
5820 let len = 0;
5821 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
5822 struct_ser.end()
5823 }
5824}
5825impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
5826 #[allow(deprecated)]
5827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5828 where
5829 D: serde::Deserializer<'de>,
5830 {
5831 const FIELDS: &[&str] = &[
5832 ];
5833
5834 #[allow(clippy::enum_variant_names)]
5835 enum GeneratedField {
5836 }
5837 impl<'de> serde::Deserialize<'de> for GeneratedField {
5838 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5839 where
5840 D: serde::Deserializer<'de>,
5841 {
5842 struct GeneratedVisitor;
5843
5844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5845 type Value = GeneratedField;
5846
5847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5848 write!(formatter, "expected one of: {:?}", &FIELDS)
5849 }
5850
5851 #[allow(unused_variables)]
5852 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5853 where
5854 E: serde::de::Error,
5855 {
5856 Err(serde::de::Error::unknown_field(value, FIELDS))
5857 }
5858 }
5859 deserializer.deserialize_identifier(GeneratedVisitor)
5860 }
5861 }
5862 struct GeneratedVisitor;
5863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5864 type Value = GetServerlessStreamingJobsStatusRequest;
5865
5866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5867 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
5868 }
5869
5870 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
5871 where
5872 V: serde::de::MapAccess<'de>,
5873 {
5874 while map_.next_key::<GeneratedField>()?.is_some() {
5875 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5876 }
5877 Ok(GetServerlessStreamingJobsStatusRequest {
5878 })
5879 }
5880 }
5881 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
5882 }
5883}
5884impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
5885 #[allow(deprecated)]
5886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5887 where
5888 S: serde::Serializer,
5889 {
5890 use serde::ser::SerializeStruct;
5891 let mut len = 0;
5892 if !self.streaming_job_statuses.is_empty() {
5893 len += 1;
5894 }
5895 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
5896 if !self.streaming_job_statuses.is_empty() {
5897 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
5898 }
5899 struct_ser.end()
5900 }
5901}
5902impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
5903 #[allow(deprecated)]
5904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5905 where
5906 D: serde::Deserializer<'de>,
5907 {
5908 const FIELDS: &[&str] = &[
5909 "streaming_job_statuses",
5910 "streamingJobStatuses",
5911 ];
5912
5913 #[allow(clippy::enum_variant_names)]
5914 enum GeneratedField {
5915 StreamingJobStatuses,
5916 }
5917 impl<'de> serde::Deserialize<'de> for GeneratedField {
5918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5919 where
5920 D: serde::Deserializer<'de>,
5921 {
5922 struct GeneratedVisitor;
5923
5924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5925 type Value = GeneratedField;
5926
5927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5928 write!(formatter, "expected one of: {:?}", &FIELDS)
5929 }
5930
5931 #[allow(unused_variables)]
5932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5933 where
5934 E: serde::de::Error,
5935 {
5936 match value {
5937 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
5938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5939 }
5940 }
5941 }
5942 deserializer.deserialize_identifier(GeneratedVisitor)
5943 }
5944 }
5945 struct GeneratedVisitor;
5946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5947 type Value = GetServerlessStreamingJobsStatusResponse;
5948
5949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5950 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
5951 }
5952
5953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
5954 where
5955 V: serde::de::MapAccess<'de>,
5956 {
5957 let mut streaming_job_statuses__ = None;
5958 while let Some(k) = map_.next_key()? {
5959 match k {
5960 GeneratedField::StreamingJobStatuses => {
5961 if streaming_job_statuses__.is_some() {
5962 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
5963 }
5964 streaming_job_statuses__ = Some(map_.next_value()?);
5965 }
5966 }
5967 }
5968 Ok(GetServerlessStreamingJobsStatusResponse {
5969 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
5970 })
5971 }
5972 }
5973 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
5974 }
5975}
5976impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
5977 #[allow(deprecated)]
5978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5979 where
5980 S: serde::Serializer,
5981 {
5982 use serde::ser::SerializeStruct;
5983 let mut len = 0;
5984 if self.table_id != 0 {
5985 len += 1;
5986 }
5987 if !self.node_label.is_empty() {
5988 len += 1;
5989 }
5990 if self.backfill_done {
5991 len += 1;
5992 }
5993 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
5994 if self.table_id != 0 {
5995 struct_ser.serialize_field("tableId", &self.table_id)?;
5996 }
5997 if !self.node_label.is_empty() {
5998 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
5999 }
6000 if self.backfill_done {
6001 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6002 }
6003 struct_ser.end()
6004 }
6005}
6006impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6007 #[allow(deprecated)]
6008 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6009 where
6010 D: serde::Deserializer<'de>,
6011 {
6012 const FIELDS: &[&str] = &[
6013 "table_id",
6014 "tableId",
6015 "node_label",
6016 "nodeLabel",
6017 "backfill_done",
6018 "backfillDone",
6019 ];
6020
6021 #[allow(clippy::enum_variant_names)]
6022 enum GeneratedField {
6023 TableId,
6024 NodeLabel,
6025 BackfillDone,
6026 }
6027 impl<'de> serde::Deserialize<'de> for GeneratedField {
6028 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6029 where
6030 D: serde::Deserializer<'de>,
6031 {
6032 struct GeneratedVisitor;
6033
6034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6035 type Value = GeneratedField;
6036
6037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6038 write!(formatter, "expected one of: {:?}", &FIELDS)
6039 }
6040
6041 #[allow(unused_variables)]
6042 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6043 where
6044 E: serde::de::Error,
6045 {
6046 match value {
6047 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6048 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6049 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6051 }
6052 }
6053 }
6054 deserializer.deserialize_identifier(GeneratedVisitor)
6055 }
6056 }
6057 struct GeneratedVisitor;
6058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6059 type Value = get_serverless_streaming_jobs_status_response::Status;
6060
6061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6062 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6063 }
6064
6065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6066 where
6067 V: serde::de::MapAccess<'de>,
6068 {
6069 let mut table_id__ = None;
6070 let mut node_label__ = None;
6071 let mut backfill_done__ = None;
6072 while let Some(k) = map_.next_key()? {
6073 match k {
6074 GeneratedField::TableId => {
6075 if table_id__.is_some() {
6076 return Err(serde::de::Error::duplicate_field("tableId"));
6077 }
6078 table_id__ =
6079 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6080 ;
6081 }
6082 GeneratedField::NodeLabel => {
6083 if node_label__.is_some() {
6084 return Err(serde::de::Error::duplicate_field("nodeLabel"));
6085 }
6086 node_label__ = Some(map_.next_value()?);
6087 }
6088 GeneratedField::BackfillDone => {
6089 if backfill_done__.is_some() {
6090 return Err(serde::de::Error::duplicate_field("backfillDone"));
6091 }
6092 backfill_done__ = Some(map_.next_value()?);
6093 }
6094 }
6095 }
6096 Ok(get_serverless_streaming_jobs_status_response::Status {
6097 table_id: table_id__.unwrap_or_default(),
6098 node_label: node_label__.unwrap_or_default(),
6099 backfill_done: backfill_done__.unwrap_or_default(),
6100 })
6101 }
6102 }
6103 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
6104 }
6105}
6106impl serde::Serialize for GetServingVnodeMappingsRequest {
6107 #[allow(deprecated)]
6108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6109 where
6110 S: serde::Serializer,
6111 {
6112 use serde::ser::SerializeStruct;
6113 let len = 0;
6114 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
6115 struct_ser.end()
6116 }
6117}
6118impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
6119 #[allow(deprecated)]
6120 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6121 where
6122 D: serde::Deserializer<'de>,
6123 {
6124 const FIELDS: &[&str] = &[
6125 ];
6126
6127 #[allow(clippy::enum_variant_names)]
6128 enum GeneratedField {
6129 }
6130 impl<'de> serde::Deserialize<'de> for GeneratedField {
6131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6132 where
6133 D: serde::Deserializer<'de>,
6134 {
6135 struct GeneratedVisitor;
6136
6137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6138 type Value = GeneratedField;
6139
6140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6141 write!(formatter, "expected one of: {:?}", &FIELDS)
6142 }
6143
6144 #[allow(unused_variables)]
6145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6146 where
6147 E: serde::de::Error,
6148 {
6149 Err(serde::de::Error::unknown_field(value, FIELDS))
6150 }
6151 }
6152 deserializer.deserialize_identifier(GeneratedVisitor)
6153 }
6154 }
6155 struct GeneratedVisitor;
6156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6157 type Value = GetServingVnodeMappingsRequest;
6158
6159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6160 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
6161 }
6162
6163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
6164 where
6165 V: serde::de::MapAccess<'de>,
6166 {
6167 while map_.next_key::<GeneratedField>()?.is_some() {
6168 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6169 }
6170 Ok(GetServingVnodeMappingsRequest {
6171 })
6172 }
6173 }
6174 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
6175 }
6176}
6177impl serde::Serialize for GetServingVnodeMappingsResponse {
6178 #[allow(deprecated)]
6179 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6180 where
6181 S: serde::Serializer,
6182 {
6183 use serde::ser::SerializeStruct;
6184 let mut len = 0;
6185 if !self.fragment_to_table.is_empty() {
6186 len += 1;
6187 }
6188 if !self.worker_slot_mappings.is_empty() {
6189 len += 1;
6190 }
6191 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
6192 if !self.fragment_to_table.is_empty() {
6193 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
6194 }
6195 if !self.worker_slot_mappings.is_empty() {
6196 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
6197 }
6198 struct_ser.end()
6199 }
6200}
6201impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
6202 #[allow(deprecated)]
6203 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6204 where
6205 D: serde::Deserializer<'de>,
6206 {
6207 const FIELDS: &[&str] = &[
6208 "fragment_to_table",
6209 "fragmentToTable",
6210 "worker_slot_mappings",
6211 "workerSlotMappings",
6212 ];
6213
6214 #[allow(clippy::enum_variant_names)]
6215 enum GeneratedField {
6216 FragmentToTable,
6217 WorkerSlotMappings,
6218 }
6219 impl<'de> serde::Deserialize<'de> for GeneratedField {
6220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6221 where
6222 D: serde::Deserializer<'de>,
6223 {
6224 struct GeneratedVisitor;
6225
6226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6227 type Value = GeneratedField;
6228
6229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6230 write!(formatter, "expected one of: {:?}", &FIELDS)
6231 }
6232
6233 #[allow(unused_variables)]
6234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6235 where
6236 E: serde::de::Error,
6237 {
6238 match value {
6239 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
6240 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
6241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6242 }
6243 }
6244 }
6245 deserializer.deserialize_identifier(GeneratedVisitor)
6246 }
6247 }
6248 struct GeneratedVisitor;
6249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6250 type Value = GetServingVnodeMappingsResponse;
6251
6252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6253 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
6254 }
6255
6256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
6257 where
6258 V: serde::de::MapAccess<'de>,
6259 {
6260 let mut fragment_to_table__ = None;
6261 let mut worker_slot_mappings__ = None;
6262 while let Some(k) = map_.next_key()? {
6263 match k {
6264 GeneratedField::FragmentToTable => {
6265 if fragment_to_table__.is_some() {
6266 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
6267 }
6268 fragment_to_table__ = Some(
6269 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
6270 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
6271 );
6272 }
6273 GeneratedField::WorkerSlotMappings => {
6274 if worker_slot_mappings__.is_some() {
6275 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
6276 }
6277 worker_slot_mappings__ = Some(map_.next_value()?);
6278 }
6279 }
6280 }
6281 Ok(GetServingVnodeMappingsResponse {
6282 fragment_to_table: fragment_to_table__.unwrap_or_default(),
6283 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
6284 })
6285 }
6286 }
6287 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
6288 }
6289}
6290impl serde::Serialize for GetSessionParamsRequest {
6291 #[allow(deprecated)]
6292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6293 where
6294 S: serde::Serializer,
6295 {
6296 use serde::ser::SerializeStruct;
6297 let len = 0;
6298 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
6299 struct_ser.end()
6300 }
6301}
6302impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
6303 #[allow(deprecated)]
6304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6305 where
6306 D: serde::Deserializer<'de>,
6307 {
6308 const FIELDS: &[&str] = &[
6309 ];
6310
6311 #[allow(clippy::enum_variant_names)]
6312 enum GeneratedField {
6313 }
6314 impl<'de> serde::Deserialize<'de> for GeneratedField {
6315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6316 where
6317 D: serde::Deserializer<'de>,
6318 {
6319 struct GeneratedVisitor;
6320
6321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6322 type Value = GeneratedField;
6323
6324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6325 write!(formatter, "expected one of: {:?}", &FIELDS)
6326 }
6327
6328 #[allow(unused_variables)]
6329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6330 where
6331 E: serde::de::Error,
6332 {
6333 Err(serde::de::Error::unknown_field(value, FIELDS))
6334 }
6335 }
6336 deserializer.deserialize_identifier(GeneratedVisitor)
6337 }
6338 }
6339 struct GeneratedVisitor;
6340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6341 type Value = GetSessionParamsRequest;
6342
6343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6344 formatter.write_str("struct meta.GetSessionParamsRequest")
6345 }
6346
6347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
6348 where
6349 V: serde::de::MapAccess<'de>,
6350 {
6351 while map_.next_key::<GeneratedField>()?.is_some() {
6352 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6353 }
6354 Ok(GetSessionParamsRequest {
6355 })
6356 }
6357 }
6358 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
6359 }
6360}
6361impl serde::Serialize for GetSessionParamsResponse {
6362 #[allow(deprecated)]
6363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6364 where
6365 S: serde::Serializer,
6366 {
6367 use serde::ser::SerializeStruct;
6368 let mut len = 0;
6369 if !self.params.is_empty() {
6370 len += 1;
6371 }
6372 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
6373 if !self.params.is_empty() {
6374 struct_ser.serialize_field("params", &self.params)?;
6375 }
6376 struct_ser.end()
6377 }
6378}
6379impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
6380 #[allow(deprecated)]
6381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6382 where
6383 D: serde::Deserializer<'de>,
6384 {
6385 const FIELDS: &[&str] = &[
6386 "params",
6387 ];
6388
6389 #[allow(clippy::enum_variant_names)]
6390 enum GeneratedField {
6391 Params,
6392 }
6393 impl<'de> serde::Deserialize<'de> for GeneratedField {
6394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6395 where
6396 D: serde::Deserializer<'de>,
6397 {
6398 struct GeneratedVisitor;
6399
6400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6401 type Value = GeneratedField;
6402
6403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6404 write!(formatter, "expected one of: {:?}", &FIELDS)
6405 }
6406
6407 #[allow(unused_variables)]
6408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6409 where
6410 E: serde::de::Error,
6411 {
6412 match value {
6413 "params" => Ok(GeneratedField::Params),
6414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6415 }
6416 }
6417 }
6418 deserializer.deserialize_identifier(GeneratedVisitor)
6419 }
6420 }
6421 struct GeneratedVisitor;
6422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6423 type Value = GetSessionParamsResponse;
6424
6425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6426 formatter.write_str("struct meta.GetSessionParamsResponse")
6427 }
6428
6429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
6430 where
6431 V: serde::de::MapAccess<'de>,
6432 {
6433 let mut params__ = None;
6434 while let Some(k) = map_.next_key()? {
6435 match k {
6436 GeneratedField::Params => {
6437 if params__.is_some() {
6438 return Err(serde::de::Error::duplicate_field("params"));
6439 }
6440 params__ = Some(map_.next_value()?);
6441 }
6442 }
6443 }
6444 Ok(GetSessionParamsResponse {
6445 params: params__.unwrap_or_default(),
6446 })
6447 }
6448 }
6449 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
6450 }
6451}
6452impl serde::Serialize for GetSystemParamsRequest {
6453 #[allow(deprecated)]
6454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6455 where
6456 S: serde::Serializer,
6457 {
6458 use serde::ser::SerializeStruct;
6459 let len = 0;
6460 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
6461 struct_ser.end()
6462 }
6463}
6464impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
6465 #[allow(deprecated)]
6466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6467 where
6468 D: serde::Deserializer<'de>,
6469 {
6470 const FIELDS: &[&str] = &[
6471 ];
6472
6473 #[allow(clippy::enum_variant_names)]
6474 enum GeneratedField {
6475 }
6476 impl<'de> serde::Deserialize<'de> for GeneratedField {
6477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6478 where
6479 D: serde::Deserializer<'de>,
6480 {
6481 struct GeneratedVisitor;
6482
6483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6484 type Value = GeneratedField;
6485
6486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6487 write!(formatter, "expected one of: {:?}", &FIELDS)
6488 }
6489
6490 #[allow(unused_variables)]
6491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6492 where
6493 E: serde::de::Error,
6494 {
6495 Err(serde::de::Error::unknown_field(value, FIELDS))
6496 }
6497 }
6498 deserializer.deserialize_identifier(GeneratedVisitor)
6499 }
6500 }
6501 struct GeneratedVisitor;
6502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6503 type Value = GetSystemParamsRequest;
6504
6505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6506 formatter.write_str("struct meta.GetSystemParamsRequest")
6507 }
6508
6509 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
6510 where
6511 V: serde::de::MapAccess<'de>,
6512 {
6513 while map_.next_key::<GeneratedField>()?.is_some() {
6514 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6515 }
6516 Ok(GetSystemParamsRequest {
6517 })
6518 }
6519 }
6520 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
6521 }
6522}
6523impl serde::Serialize for GetSystemParamsResponse {
6524 #[allow(deprecated)]
6525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6526 where
6527 S: serde::Serializer,
6528 {
6529 use serde::ser::SerializeStruct;
6530 let mut len = 0;
6531 if self.params.is_some() {
6532 len += 1;
6533 }
6534 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
6535 if let Some(v) = self.params.as_ref() {
6536 struct_ser.serialize_field("params", v)?;
6537 }
6538 struct_ser.end()
6539 }
6540}
6541impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
6542 #[allow(deprecated)]
6543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6544 where
6545 D: serde::Deserializer<'de>,
6546 {
6547 const FIELDS: &[&str] = &[
6548 "params",
6549 ];
6550
6551 #[allow(clippy::enum_variant_names)]
6552 enum GeneratedField {
6553 Params,
6554 }
6555 impl<'de> serde::Deserialize<'de> for GeneratedField {
6556 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6557 where
6558 D: serde::Deserializer<'de>,
6559 {
6560 struct GeneratedVisitor;
6561
6562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6563 type Value = GeneratedField;
6564
6565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6566 write!(formatter, "expected one of: {:?}", &FIELDS)
6567 }
6568
6569 #[allow(unused_variables)]
6570 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6571 where
6572 E: serde::de::Error,
6573 {
6574 match value {
6575 "params" => Ok(GeneratedField::Params),
6576 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6577 }
6578 }
6579 }
6580 deserializer.deserialize_identifier(GeneratedVisitor)
6581 }
6582 }
6583 struct GeneratedVisitor;
6584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6585 type Value = GetSystemParamsResponse;
6586
6587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6588 formatter.write_str("struct meta.GetSystemParamsResponse")
6589 }
6590
6591 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
6592 where
6593 V: serde::de::MapAccess<'de>,
6594 {
6595 let mut params__ = None;
6596 while let Some(k) = map_.next_key()? {
6597 match k {
6598 GeneratedField::Params => {
6599 if params__.is_some() {
6600 return Err(serde::de::Error::duplicate_field("params"));
6601 }
6602 params__ = map_.next_value()?;
6603 }
6604 }
6605 }
6606 Ok(GetSystemParamsResponse {
6607 params: params__,
6608 })
6609 }
6610 }
6611 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
6612 }
6613}
6614impl serde::Serialize for GetTelemetryInfoRequest {
6615 #[allow(deprecated)]
6616 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6617 where
6618 S: serde::Serializer,
6619 {
6620 use serde::ser::SerializeStruct;
6621 let len = 0;
6622 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
6623 struct_ser.end()
6624 }
6625}
6626impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
6627 #[allow(deprecated)]
6628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6629 where
6630 D: serde::Deserializer<'de>,
6631 {
6632 const FIELDS: &[&str] = &[
6633 ];
6634
6635 #[allow(clippy::enum_variant_names)]
6636 enum GeneratedField {
6637 }
6638 impl<'de> serde::Deserialize<'de> for GeneratedField {
6639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6640 where
6641 D: serde::Deserializer<'de>,
6642 {
6643 struct GeneratedVisitor;
6644
6645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6646 type Value = GeneratedField;
6647
6648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6649 write!(formatter, "expected one of: {:?}", &FIELDS)
6650 }
6651
6652 #[allow(unused_variables)]
6653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6654 where
6655 E: serde::de::Error,
6656 {
6657 Err(serde::de::Error::unknown_field(value, FIELDS))
6658 }
6659 }
6660 deserializer.deserialize_identifier(GeneratedVisitor)
6661 }
6662 }
6663 struct GeneratedVisitor;
6664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6665 type Value = GetTelemetryInfoRequest;
6666
6667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6668 formatter.write_str("struct meta.GetTelemetryInfoRequest")
6669 }
6670
6671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
6672 where
6673 V: serde::de::MapAccess<'de>,
6674 {
6675 while map_.next_key::<GeneratedField>()?.is_some() {
6676 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6677 }
6678 Ok(GetTelemetryInfoRequest {
6679 })
6680 }
6681 }
6682 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
6683 }
6684}
6685impl serde::Serialize for HeartbeatRequest {
6686 #[allow(deprecated)]
6687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6688 where
6689 S: serde::Serializer,
6690 {
6691 use serde::ser::SerializeStruct;
6692 let mut len = 0;
6693 if self.node_id != 0 {
6694 len += 1;
6695 }
6696 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
6697 if self.node_id != 0 {
6698 struct_ser.serialize_field("nodeId", &self.node_id)?;
6699 }
6700 struct_ser.end()
6701 }
6702}
6703impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
6704 #[allow(deprecated)]
6705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6706 where
6707 D: serde::Deserializer<'de>,
6708 {
6709 const FIELDS: &[&str] = &[
6710 "node_id",
6711 "nodeId",
6712 ];
6713
6714 #[allow(clippy::enum_variant_names)]
6715 enum GeneratedField {
6716 NodeId,
6717 }
6718 impl<'de> serde::Deserialize<'de> for GeneratedField {
6719 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6720 where
6721 D: serde::Deserializer<'de>,
6722 {
6723 struct GeneratedVisitor;
6724
6725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6726 type Value = GeneratedField;
6727
6728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6729 write!(formatter, "expected one of: {:?}", &FIELDS)
6730 }
6731
6732 #[allow(unused_variables)]
6733 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6734 where
6735 E: serde::de::Error,
6736 {
6737 match value {
6738 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
6739 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6740 }
6741 }
6742 }
6743 deserializer.deserialize_identifier(GeneratedVisitor)
6744 }
6745 }
6746 struct GeneratedVisitor;
6747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6748 type Value = HeartbeatRequest;
6749
6750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6751 formatter.write_str("struct meta.HeartbeatRequest")
6752 }
6753
6754 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
6755 where
6756 V: serde::de::MapAccess<'de>,
6757 {
6758 let mut node_id__ = None;
6759 while let Some(k) = map_.next_key()? {
6760 match k {
6761 GeneratedField::NodeId => {
6762 if node_id__.is_some() {
6763 return Err(serde::de::Error::duplicate_field("nodeId"));
6764 }
6765 node_id__ =
6766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6767 ;
6768 }
6769 }
6770 }
6771 Ok(HeartbeatRequest {
6772 node_id: node_id__.unwrap_or_default(),
6773 })
6774 }
6775 }
6776 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
6777 }
6778}
6779impl serde::Serialize for HeartbeatResponse {
6780 #[allow(deprecated)]
6781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6782 where
6783 S: serde::Serializer,
6784 {
6785 use serde::ser::SerializeStruct;
6786 let mut len = 0;
6787 if self.status.is_some() {
6788 len += 1;
6789 }
6790 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
6791 if let Some(v) = self.status.as_ref() {
6792 struct_ser.serialize_field("status", v)?;
6793 }
6794 struct_ser.end()
6795 }
6796}
6797impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
6798 #[allow(deprecated)]
6799 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6800 where
6801 D: serde::Deserializer<'de>,
6802 {
6803 const FIELDS: &[&str] = &[
6804 "status",
6805 ];
6806
6807 #[allow(clippy::enum_variant_names)]
6808 enum GeneratedField {
6809 Status,
6810 }
6811 impl<'de> serde::Deserialize<'de> for GeneratedField {
6812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6813 where
6814 D: serde::Deserializer<'de>,
6815 {
6816 struct GeneratedVisitor;
6817
6818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6819 type Value = GeneratedField;
6820
6821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6822 write!(formatter, "expected one of: {:?}", &FIELDS)
6823 }
6824
6825 #[allow(unused_variables)]
6826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6827 where
6828 E: serde::de::Error,
6829 {
6830 match value {
6831 "status" => Ok(GeneratedField::Status),
6832 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6833 }
6834 }
6835 }
6836 deserializer.deserialize_identifier(GeneratedVisitor)
6837 }
6838 }
6839 struct GeneratedVisitor;
6840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6841 type Value = HeartbeatResponse;
6842
6843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6844 formatter.write_str("struct meta.HeartbeatResponse")
6845 }
6846
6847 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
6848 where
6849 V: serde::de::MapAccess<'de>,
6850 {
6851 let mut status__ = None;
6852 while let Some(k) = map_.next_key()? {
6853 match k {
6854 GeneratedField::Status => {
6855 if status__.is_some() {
6856 return Err(serde::de::Error::duplicate_field("status"));
6857 }
6858 status__ = map_.next_value()?;
6859 }
6860 }
6861 }
6862 Ok(HeartbeatResponse {
6863 status: status__,
6864 })
6865 }
6866 }
6867 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
6868 }
6869}
6870impl serde::Serialize for ListActorSplitsRequest {
6871 #[allow(deprecated)]
6872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6873 where
6874 S: serde::Serializer,
6875 {
6876 use serde::ser::SerializeStruct;
6877 let len = 0;
6878 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
6879 struct_ser.end()
6880 }
6881}
6882impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
6883 #[allow(deprecated)]
6884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6885 where
6886 D: serde::Deserializer<'de>,
6887 {
6888 const FIELDS: &[&str] = &[
6889 ];
6890
6891 #[allow(clippy::enum_variant_names)]
6892 enum GeneratedField {
6893 }
6894 impl<'de> serde::Deserialize<'de> for GeneratedField {
6895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6896 where
6897 D: serde::Deserializer<'de>,
6898 {
6899 struct GeneratedVisitor;
6900
6901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6902 type Value = GeneratedField;
6903
6904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6905 write!(formatter, "expected one of: {:?}", &FIELDS)
6906 }
6907
6908 #[allow(unused_variables)]
6909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6910 where
6911 E: serde::de::Error,
6912 {
6913 Err(serde::de::Error::unknown_field(value, FIELDS))
6914 }
6915 }
6916 deserializer.deserialize_identifier(GeneratedVisitor)
6917 }
6918 }
6919 struct GeneratedVisitor;
6920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6921 type Value = ListActorSplitsRequest;
6922
6923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6924 formatter.write_str("struct meta.ListActorSplitsRequest")
6925 }
6926
6927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
6928 where
6929 V: serde::de::MapAccess<'de>,
6930 {
6931 while map_.next_key::<GeneratedField>()?.is_some() {
6932 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6933 }
6934 Ok(ListActorSplitsRequest {
6935 })
6936 }
6937 }
6938 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
6939 }
6940}
6941impl serde::Serialize for ListActorSplitsResponse {
6942 #[allow(deprecated)]
6943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6944 where
6945 S: serde::Serializer,
6946 {
6947 use serde::ser::SerializeStruct;
6948 let mut len = 0;
6949 if !self.actor_splits.is_empty() {
6950 len += 1;
6951 }
6952 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
6953 if !self.actor_splits.is_empty() {
6954 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6955 }
6956 struct_ser.end()
6957 }
6958}
6959impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
6960 #[allow(deprecated)]
6961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6962 where
6963 D: serde::Deserializer<'de>,
6964 {
6965 const FIELDS: &[&str] = &[
6966 "actor_splits",
6967 "actorSplits",
6968 ];
6969
6970 #[allow(clippy::enum_variant_names)]
6971 enum GeneratedField {
6972 ActorSplits,
6973 }
6974 impl<'de> serde::Deserialize<'de> for GeneratedField {
6975 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6976 where
6977 D: serde::Deserializer<'de>,
6978 {
6979 struct GeneratedVisitor;
6980
6981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6982 type Value = GeneratedField;
6983
6984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6985 write!(formatter, "expected one of: {:?}", &FIELDS)
6986 }
6987
6988 #[allow(unused_variables)]
6989 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6990 where
6991 E: serde::de::Error,
6992 {
6993 match value {
6994 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6996 }
6997 }
6998 }
6999 deserializer.deserialize_identifier(GeneratedVisitor)
7000 }
7001 }
7002 struct GeneratedVisitor;
7003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7004 type Value = ListActorSplitsResponse;
7005
7006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7007 formatter.write_str("struct meta.ListActorSplitsResponse")
7008 }
7009
7010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7011 where
7012 V: serde::de::MapAccess<'de>,
7013 {
7014 let mut actor_splits__ = None;
7015 while let Some(k) = map_.next_key()? {
7016 match k {
7017 GeneratedField::ActorSplits => {
7018 if actor_splits__.is_some() {
7019 return Err(serde::de::Error::duplicate_field("actorSplits"));
7020 }
7021 actor_splits__ = Some(map_.next_value()?);
7022 }
7023 }
7024 }
7025 Ok(ListActorSplitsResponse {
7026 actor_splits: actor_splits__.unwrap_or_default(),
7027 })
7028 }
7029 }
7030 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7031 }
7032}
7033impl serde::Serialize for list_actor_splits_response::ActorSplit {
7034 #[allow(deprecated)]
7035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7036 where
7037 S: serde::Serializer,
7038 {
7039 use serde::ser::SerializeStruct;
7040 let mut len = 0;
7041 if self.actor_id != 0 {
7042 len += 1;
7043 }
7044 if self.fragment_id != 0 {
7045 len += 1;
7046 }
7047 if self.source_id != 0 {
7048 len += 1;
7049 }
7050 if !self.split_id.is_empty() {
7051 len += 1;
7052 }
7053 if self.fragment_type != 0 {
7054 len += 1;
7055 }
7056 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7057 if self.actor_id != 0 {
7058 struct_ser.serialize_field("actorId", &self.actor_id)?;
7059 }
7060 if self.fragment_id != 0 {
7061 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7062 }
7063 if self.source_id != 0 {
7064 struct_ser.serialize_field("sourceId", &self.source_id)?;
7065 }
7066 if !self.split_id.is_empty() {
7067 struct_ser.serialize_field("splitId", &self.split_id)?;
7068 }
7069 if self.fragment_type != 0 {
7070 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7071 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7072 struct_ser.serialize_field("fragmentType", &v)?;
7073 }
7074 struct_ser.end()
7075 }
7076}
7077impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7078 #[allow(deprecated)]
7079 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7080 where
7081 D: serde::Deserializer<'de>,
7082 {
7083 const FIELDS: &[&str] = &[
7084 "actor_id",
7085 "actorId",
7086 "fragment_id",
7087 "fragmentId",
7088 "source_id",
7089 "sourceId",
7090 "split_id",
7091 "splitId",
7092 "fragment_type",
7093 "fragmentType",
7094 ];
7095
7096 #[allow(clippy::enum_variant_names)]
7097 enum GeneratedField {
7098 ActorId,
7099 FragmentId,
7100 SourceId,
7101 SplitId,
7102 FragmentType,
7103 }
7104 impl<'de> serde::Deserialize<'de> for GeneratedField {
7105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7106 where
7107 D: serde::Deserializer<'de>,
7108 {
7109 struct GeneratedVisitor;
7110
7111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7112 type Value = GeneratedField;
7113
7114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7115 write!(formatter, "expected one of: {:?}", &FIELDS)
7116 }
7117
7118 #[allow(unused_variables)]
7119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7120 where
7121 E: serde::de::Error,
7122 {
7123 match value {
7124 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7125 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7126 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7127 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
7128 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
7129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7130 }
7131 }
7132 }
7133 deserializer.deserialize_identifier(GeneratedVisitor)
7134 }
7135 }
7136 struct GeneratedVisitor;
7137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7138 type Value = list_actor_splits_response::ActorSplit;
7139
7140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7141 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
7142 }
7143
7144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
7145 where
7146 V: serde::de::MapAccess<'de>,
7147 {
7148 let mut actor_id__ = None;
7149 let mut fragment_id__ = None;
7150 let mut source_id__ = None;
7151 let mut split_id__ = None;
7152 let mut fragment_type__ = None;
7153 while let Some(k) = map_.next_key()? {
7154 match k {
7155 GeneratedField::ActorId => {
7156 if actor_id__.is_some() {
7157 return Err(serde::de::Error::duplicate_field("actorId"));
7158 }
7159 actor_id__ =
7160 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7161 ;
7162 }
7163 GeneratedField::FragmentId => {
7164 if fragment_id__.is_some() {
7165 return Err(serde::de::Error::duplicate_field("fragmentId"));
7166 }
7167 fragment_id__ =
7168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7169 ;
7170 }
7171 GeneratedField::SourceId => {
7172 if source_id__.is_some() {
7173 return Err(serde::de::Error::duplicate_field("sourceId"));
7174 }
7175 source_id__ =
7176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7177 ;
7178 }
7179 GeneratedField::SplitId => {
7180 if split_id__.is_some() {
7181 return Err(serde::de::Error::duplicate_field("splitId"));
7182 }
7183 split_id__ = Some(map_.next_value()?);
7184 }
7185 GeneratedField::FragmentType => {
7186 if fragment_type__.is_some() {
7187 return Err(serde::de::Error::duplicate_field("fragmentType"));
7188 }
7189 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
7190 }
7191 }
7192 }
7193 Ok(list_actor_splits_response::ActorSplit {
7194 actor_id: actor_id__.unwrap_or_default(),
7195 fragment_id: fragment_id__.unwrap_or_default(),
7196 source_id: source_id__.unwrap_or_default(),
7197 split_id: split_id__.unwrap_or_default(),
7198 fragment_type: fragment_type__.unwrap_or_default(),
7199 })
7200 }
7201 }
7202 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
7203 }
7204}
7205impl serde::Serialize for list_actor_splits_response::FragmentType {
7206 #[allow(deprecated)]
7207 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7208 where
7209 S: serde::Serializer,
7210 {
7211 let variant = match self {
7212 Self::Unspecified => "UNSPECIFIED",
7213 Self::NonSharedSource => "NON_SHARED_SOURCE",
7214 Self::SharedSource => "SHARED_SOURCE",
7215 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
7216 };
7217 serializer.serialize_str(variant)
7218 }
7219}
7220impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
7221 #[allow(deprecated)]
7222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7223 where
7224 D: serde::Deserializer<'de>,
7225 {
7226 const FIELDS: &[&str] = &[
7227 "UNSPECIFIED",
7228 "NON_SHARED_SOURCE",
7229 "SHARED_SOURCE",
7230 "SHARED_SOURCE_BACKFILL",
7231 ];
7232
7233 struct GeneratedVisitor;
7234
7235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7236 type Value = list_actor_splits_response::FragmentType;
7237
7238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7239 write!(formatter, "expected one of: {:?}", &FIELDS)
7240 }
7241
7242 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7243 where
7244 E: serde::de::Error,
7245 {
7246 i32::try_from(v)
7247 .ok()
7248 .and_then(|x| x.try_into().ok())
7249 .ok_or_else(|| {
7250 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7251 })
7252 }
7253
7254 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7255 where
7256 E: serde::de::Error,
7257 {
7258 i32::try_from(v)
7259 .ok()
7260 .and_then(|x| x.try_into().ok())
7261 .ok_or_else(|| {
7262 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7263 })
7264 }
7265
7266 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7267 where
7268 E: serde::de::Error,
7269 {
7270 match value {
7271 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
7272 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
7273 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
7274 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
7275 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7276 }
7277 }
7278 }
7279 deserializer.deserialize_any(GeneratedVisitor)
7280 }
7281}
7282impl serde::Serialize for ListActorStatesRequest {
7283 #[allow(deprecated)]
7284 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7285 where
7286 S: serde::Serializer,
7287 {
7288 use serde::ser::SerializeStruct;
7289 let len = 0;
7290 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
7291 struct_ser.end()
7292 }
7293}
7294impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
7295 #[allow(deprecated)]
7296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7297 where
7298 D: serde::Deserializer<'de>,
7299 {
7300 const FIELDS: &[&str] = &[
7301 ];
7302
7303 #[allow(clippy::enum_variant_names)]
7304 enum GeneratedField {
7305 }
7306 impl<'de> serde::Deserialize<'de> for GeneratedField {
7307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7308 where
7309 D: serde::Deserializer<'de>,
7310 {
7311 struct GeneratedVisitor;
7312
7313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7314 type Value = GeneratedField;
7315
7316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7317 write!(formatter, "expected one of: {:?}", &FIELDS)
7318 }
7319
7320 #[allow(unused_variables)]
7321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7322 where
7323 E: serde::de::Error,
7324 {
7325 Err(serde::de::Error::unknown_field(value, FIELDS))
7326 }
7327 }
7328 deserializer.deserialize_identifier(GeneratedVisitor)
7329 }
7330 }
7331 struct GeneratedVisitor;
7332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333 type Value = ListActorStatesRequest;
7334
7335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336 formatter.write_str("struct meta.ListActorStatesRequest")
7337 }
7338
7339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
7340 where
7341 V: serde::de::MapAccess<'de>,
7342 {
7343 while map_.next_key::<GeneratedField>()?.is_some() {
7344 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7345 }
7346 Ok(ListActorStatesRequest {
7347 })
7348 }
7349 }
7350 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
7351 }
7352}
7353impl serde::Serialize for ListActorStatesResponse {
7354 #[allow(deprecated)]
7355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7356 where
7357 S: serde::Serializer,
7358 {
7359 use serde::ser::SerializeStruct;
7360 let mut len = 0;
7361 if !self.states.is_empty() {
7362 len += 1;
7363 }
7364 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
7365 if !self.states.is_empty() {
7366 struct_ser.serialize_field("states", &self.states)?;
7367 }
7368 struct_ser.end()
7369 }
7370}
7371impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
7372 #[allow(deprecated)]
7373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7374 where
7375 D: serde::Deserializer<'de>,
7376 {
7377 const FIELDS: &[&str] = &[
7378 "states",
7379 ];
7380
7381 #[allow(clippy::enum_variant_names)]
7382 enum GeneratedField {
7383 States,
7384 }
7385 impl<'de> serde::Deserialize<'de> for GeneratedField {
7386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7387 where
7388 D: serde::Deserializer<'de>,
7389 {
7390 struct GeneratedVisitor;
7391
7392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7393 type Value = GeneratedField;
7394
7395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7396 write!(formatter, "expected one of: {:?}", &FIELDS)
7397 }
7398
7399 #[allow(unused_variables)]
7400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7401 where
7402 E: serde::de::Error,
7403 {
7404 match value {
7405 "states" => Ok(GeneratedField::States),
7406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7407 }
7408 }
7409 }
7410 deserializer.deserialize_identifier(GeneratedVisitor)
7411 }
7412 }
7413 struct GeneratedVisitor;
7414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7415 type Value = ListActorStatesResponse;
7416
7417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7418 formatter.write_str("struct meta.ListActorStatesResponse")
7419 }
7420
7421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
7422 where
7423 V: serde::de::MapAccess<'de>,
7424 {
7425 let mut states__ = None;
7426 while let Some(k) = map_.next_key()? {
7427 match k {
7428 GeneratedField::States => {
7429 if states__.is_some() {
7430 return Err(serde::de::Error::duplicate_field("states"));
7431 }
7432 states__ = Some(map_.next_value()?);
7433 }
7434 }
7435 }
7436 Ok(ListActorStatesResponse {
7437 states: states__.unwrap_or_default(),
7438 })
7439 }
7440 }
7441 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
7442 }
7443}
7444impl serde::Serialize for list_actor_states_response::ActorState {
7445 #[allow(deprecated)]
7446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7447 where
7448 S: serde::Serializer,
7449 {
7450 use serde::ser::SerializeStruct;
7451 let mut len = 0;
7452 if self.actor_id != 0 {
7453 len += 1;
7454 }
7455 if self.fragment_id != 0 {
7456 len += 1;
7457 }
7458 if self.state != 0 {
7459 len += 1;
7460 }
7461 if self.worker_id != 0 {
7462 len += 1;
7463 }
7464 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
7465 if self.actor_id != 0 {
7466 struct_ser.serialize_field("actorId", &self.actor_id)?;
7467 }
7468 if self.fragment_id != 0 {
7469 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7470 }
7471 if self.state != 0 {
7472 let v = table_fragments::actor_status::ActorState::try_from(self.state)
7473 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
7474 struct_ser.serialize_field("state", &v)?;
7475 }
7476 if self.worker_id != 0 {
7477 struct_ser.serialize_field("workerId", &self.worker_id)?;
7478 }
7479 struct_ser.end()
7480 }
7481}
7482impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
7483 #[allow(deprecated)]
7484 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7485 where
7486 D: serde::Deserializer<'de>,
7487 {
7488 const FIELDS: &[&str] = &[
7489 "actor_id",
7490 "actorId",
7491 "fragment_id",
7492 "fragmentId",
7493 "state",
7494 "worker_id",
7495 "workerId",
7496 ];
7497
7498 #[allow(clippy::enum_variant_names)]
7499 enum GeneratedField {
7500 ActorId,
7501 FragmentId,
7502 State,
7503 WorkerId,
7504 }
7505 impl<'de> serde::Deserialize<'de> for GeneratedField {
7506 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7507 where
7508 D: serde::Deserializer<'de>,
7509 {
7510 struct GeneratedVisitor;
7511
7512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7513 type Value = GeneratedField;
7514
7515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7516 write!(formatter, "expected one of: {:?}", &FIELDS)
7517 }
7518
7519 #[allow(unused_variables)]
7520 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7521 where
7522 E: serde::de::Error,
7523 {
7524 match value {
7525 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7526 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7527 "state" => Ok(GeneratedField::State),
7528 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
7529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7530 }
7531 }
7532 }
7533 deserializer.deserialize_identifier(GeneratedVisitor)
7534 }
7535 }
7536 struct GeneratedVisitor;
7537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7538 type Value = list_actor_states_response::ActorState;
7539
7540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7541 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
7542 }
7543
7544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
7545 where
7546 V: serde::de::MapAccess<'de>,
7547 {
7548 let mut actor_id__ = None;
7549 let mut fragment_id__ = None;
7550 let mut state__ = None;
7551 let mut worker_id__ = None;
7552 while let Some(k) = map_.next_key()? {
7553 match k {
7554 GeneratedField::ActorId => {
7555 if actor_id__.is_some() {
7556 return Err(serde::de::Error::duplicate_field("actorId"));
7557 }
7558 actor_id__ =
7559 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7560 ;
7561 }
7562 GeneratedField::FragmentId => {
7563 if fragment_id__.is_some() {
7564 return Err(serde::de::Error::duplicate_field("fragmentId"));
7565 }
7566 fragment_id__ =
7567 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7568 ;
7569 }
7570 GeneratedField::State => {
7571 if state__.is_some() {
7572 return Err(serde::de::Error::duplicate_field("state"));
7573 }
7574 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
7575 }
7576 GeneratedField::WorkerId => {
7577 if worker_id__.is_some() {
7578 return Err(serde::de::Error::duplicate_field("workerId"));
7579 }
7580 worker_id__ =
7581 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7582 ;
7583 }
7584 }
7585 }
7586 Ok(list_actor_states_response::ActorState {
7587 actor_id: actor_id__.unwrap_or_default(),
7588 fragment_id: fragment_id__.unwrap_or_default(),
7589 state: state__.unwrap_or_default(),
7590 worker_id: worker_id__.unwrap_or_default(),
7591 })
7592 }
7593 }
7594 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
7595 }
7596}
7597impl serde::Serialize for ListAllNodesRequest {
7598 #[allow(deprecated)]
7599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7600 where
7601 S: serde::Serializer,
7602 {
7603 use serde::ser::SerializeStruct;
7604 let mut len = 0;
7605 if self.worker_type.is_some() {
7606 len += 1;
7607 }
7608 if self.include_starting_nodes {
7609 len += 1;
7610 }
7611 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
7612 if let Some(v) = self.worker_type.as_ref() {
7613 let v = super::common::WorkerType::try_from(*v)
7614 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
7615 struct_ser.serialize_field("workerType", &v)?;
7616 }
7617 if self.include_starting_nodes {
7618 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
7619 }
7620 struct_ser.end()
7621 }
7622}
7623impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
7624 #[allow(deprecated)]
7625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7626 where
7627 D: serde::Deserializer<'de>,
7628 {
7629 const FIELDS: &[&str] = &[
7630 "worker_type",
7631 "workerType",
7632 "include_starting_nodes",
7633 "includeStartingNodes",
7634 ];
7635
7636 #[allow(clippy::enum_variant_names)]
7637 enum GeneratedField {
7638 WorkerType,
7639 IncludeStartingNodes,
7640 }
7641 impl<'de> serde::Deserialize<'de> for GeneratedField {
7642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7643 where
7644 D: serde::Deserializer<'de>,
7645 {
7646 struct GeneratedVisitor;
7647
7648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7649 type Value = GeneratedField;
7650
7651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7652 write!(formatter, "expected one of: {:?}", &FIELDS)
7653 }
7654
7655 #[allow(unused_variables)]
7656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7657 where
7658 E: serde::de::Error,
7659 {
7660 match value {
7661 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
7662 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
7663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7664 }
7665 }
7666 }
7667 deserializer.deserialize_identifier(GeneratedVisitor)
7668 }
7669 }
7670 struct GeneratedVisitor;
7671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7672 type Value = ListAllNodesRequest;
7673
7674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7675 formatter.write_str("struct meta.ListAllNodesRequest")
7676 }
7677
7678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
7679 where
7680 V: serde::de::MapAccess<'de>,
7681 {
7682 let mut worker_type__ = None;
7683 let mut include_starting_nodes__ = None;
7684 while let Some(k) = map_.next_key()? {
7685 match k {
7686 GeneratedField::WorkerType => {
7687 if worker_type__.is_some() {
7688 return Err(serde::de::Error::duplicate_field("workerType"));
7689 }
7690 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
7691 }
7692 GeneratedField::IncludeStartingNodes => {
7693 if include_starting_nodes__.is_some() {
7694 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
7695 }
7696 include_starting_nodes__ = Some(map_.next_value()?);
7697 }
7698 }
7699 }
7700 Ok(ListAllNodesRequest {
7701 worker_type: worker_type__,
7702 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
7703 })
7704 }
7705 }
7706 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
7707 }
7708}
7709impl serde::Serialize for ListAllNodesResponse {
7710 #[allow(deprecated)]
7711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7712 where
7713 S: serde::Serializer,
7714 {
7715 use serde::ser::SerializeStruct;
7716 let mut len = 0;
7717 if self.status.is_some() {
7718 len += 1;
7719 }
7720 if !self.nodes.is_empty() {
7721 len += 1;
7722 }
7723 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
7724 if let Some(v) = self.status.as_ref() {
7725 struct_ser.serialize_field("status", v)?;
7726 }
7727 if !self.nodes.is_empty() {
7728 struct_ser.serialize_field("nodes", &self.nodes)?;
7729 }
7730 struct_ser.end()
7731 }
7732}
7733impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
7734 #[allow(deprecated)]
7735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7736 where
7737 D: serde::Deserializer<'de>,
7738 {
7739 const FIELDS: &[&str] = &[
7740 "status",
7741 "nodes",
7742 ];
7743
7744 #[allow(clippy::enum_variant_names)]
7745 enum GeneratedField {
7746 Status,
7747 Nodes,
7748 }
7749 impl<'de> serde::Deserialize<'de> for GeneratedField {
7750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7751 where
7752 D: serde::Deserializer<'de>,
7753 {
7754 struct GeneratedVisitor;
7755
7756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7757 type Value = GeneratedField;
7758
7759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7760 write!(formatter, "expected one of: {:?}", &FIELDS)
7761 }
7762
7763 #[allow(unused_variables)]
7764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7765 where
7766 E: serde::de::Error,
7767 {
7768 match value {
7769 "status" => Ok(GeneratedField::Status),
7770 "nodes" => Ok(GeneratedField::Nodes),
7771 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7772 }
7773 }
7774 }
7775 deserializer.deserialize_identifier(GeneratedVisitor)
7776 }
7777 }
7778 struct GeneratedVisitor;
7779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7780 type Value = ListAllNodesResponse;
7781
7782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7783 formatter.write_str("struct meta.ListAllNodesResponse")
7784 }
7785
7786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
7787 where
7788 V: serde::de::MapAccess<'de>,
7789 {
7790 let mut status__ = None;
7791 let mut nodes__ = None;
7792 while let Some(k) = map_.next_key()? {
7793 match k {
7794 GeneratedField::Status => {
7795 if status__.is_some() {
7796 return Err(serde::de::Error::duplicate_field("status"));
7797 }
7798 status__ = map_.next_value()?;
7799 }
7800 GeneratedField::Nodes => {
7801 if nodes__.is_some() {
7802 return Err(serde::de::Error::duplicate_field("nodes"));
7803 }
7804 nodes__ = Some(map_.next_value()?);
7805 }
7806 }
7807 }
7808 Ok(ListAllNodesResponse {
7809 status: status__,
7810 nodes: nodes__.unwrap_or_default(),
7811 })
7812 }
7813 }
7814 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
7815 }
7816}
7817impl serde::Serialize for ListEventLogRequest {
7818 #[allow(deprecated)]
7819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7820 where
7821 S: serde::Serializer,
7822 {
7823 use serde::ser::SerializeStruct;
7824 let len = 0;
7825 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
7826 struct_ser.end()
7827 }
7828}
7829impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
7830 #[allow(deprecated)]
7831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7832 where
7833 D: serde::Deserializer<'de>,
7834 {
7835 const FIELDS: &[&str] = &[
7836 ];
7837
7838 #[allow(clippy::enum_variant_names)]
7839 enum GeneratedField {
7840 }
7841 impl<'de> serde::Deserialize<'de> for GeneratedField {
7842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7843 where
7844 D: serde::Deserializer<'de>,
7845 {
7846 struct GeneratedVisitor;
7847
7848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7849 type Value = GeneratedField;
7850
7851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7852 write!(formatter, "expected one of: {:?}", &FIELDS)
7853 }
7854
7855 #[allow(unused_variables)]
7856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7857 where
7858 E: serde::de::Error,
7859 {
7860 Err(serde::de::Error::unknown_field(value, FIELDS))
7861 }
7862 }
7863 deserializer.deserialize_identifier(GeneratedVisitor)
7864 }
7865 }
7866 struct GeneratedVisitor;
7867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7868 type Value = ListEventLogRequest;
7869
7870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7871 formatter.write_str("struct meta.ListEventLogRequest")
7872 }
7873
7874 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
7875 where
7876 V: serde::de::MapAccess<'de>,
7877 {
7878 while map_.next_key::<GeneratedField>()?.is_some() {
7879 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7880 }
7881 Ok(ListEventLogRequest {
7882 })
7883 }
7884 }
7885 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
7886 }
7887}
7888impl serde::Serialize for ListEventLogResponse {
7889 #[allow(deprecated)]
7890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7891 where
7892 S: serde::Serializer,
7893 {
7894 use serde::ser::SerializeStruct;
7895 let mut len = 0;
7896 if !self.event_logs.is_empty() {
7897 len += 1;
7898 }
7899 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
7900 if !self.event_logs.is_empty() {
7901 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
7902 }
7903 struct_ser.end()
7904 }
7905}
7906impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
7907 #[allow(deprecated)]
7908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7909 where
7910 D: serde::Deserializer<'de>,
7911 {
7912 const FIELDS: &[&str] = &[
7913 "event_logs",
7914 "eventLogs",
7915 ];
7916
7917 #[allow(clippy::enum_variant_names)]
7918 enum GeneratedField {
7919 EventLogs,
7920 }
7921 impl<'de> serde::Deserialize<'de> for GeneratedField {
7922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7923 where
7924 D: serde::Deserializer<'de>,
7925 {
7926 struct GeneratedVisitor;
7927
7928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7929 type Value = GeneratedField;
7930
7931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7932 write!(formatter, "expected one of: {:?}", &FIELDS)
7933 }
7934
7935 #[allow(unused_variables)]
7936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7937 where
7938 E: serde::de::Error,
7939 {
7940 match value {
7941 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
7942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7943 }
7944 }
7945 }
7946 deserializer.deserialize_identifier(GeneratedVisitor)
7947 }
7948 }
7949 struct GeneratedVisitor;
7950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7951 type Value = ListEventLogResponse;
7952
7953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7954 formatter.write_str("struct meta.ListEventLogResponse")
7955 }
7956
7957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
7958 where
7959 V: serde::de::MapAccess<'de>,
7960 {
7961 let mut event_logs__ = None;
7962 while let Some(k) = map_.next_key()? {
7963 match k {
7964 GeneratedField::EventLogs => {
7965 if event_logs__.is_some() {
7966 return Err(serde::de::Error::duplicate_field("eventLogs"));
7967 }
7968 event_logs__ = Some(map_.next_value()?);
7969 }
7970 }
7971 }
7972 Ok(ListEventLogResponse {
7973 event_logs: event_logs__.unwrap_or_default(),
7974 })
7975 }
7976 }
7977 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
7978 }
7979}
7980impl serde::Serialize for ListFragmentDistributionRequest {
7981 #[allow(deprecated)]
7982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7983 where
7984 S: serde::Serializer,
7985 {
7986 use serde::ser::SerializeStruct;
7987 let len = 0;
7988 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
7989 struct_ser.end()
7990 }
7991}
7992impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
7993 #[allow(deprecated)]
7994 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7995 where
7996 D: serde::Deserializer<'de>,
7997 {
7998 const FIELDS: &[&str] = &[
7999 ];
8000
8001 #[allow(clippy::enum_variant_names)]
8002 enum GeneratedField {
8003 }
8004 impl<'de> serde::Deserialize<'de> for GeneratedField {
8005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8006 where
8007 D: serde::Deserializer<'de>,
8008 {
8009 struct GeneratedVisitor;
8010
8011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8012 type Value = GeneratedField;
8013
8014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8015 write!(formatter, "expected one of: {:?}", &FIELDS)
8016 }
8017
8018 #[allow(unused_variables)]
8019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8020 where
8021 E: serde::de::Error,
8022 {
8023 Err(serde::de::Error::unknown_field(value, FIELDS))
8024 }
8025 }
8026 deserializer.deserialize_identifier(GeneratedVisitor)
8027 }
8028 }
8029 struct GeneratedVisitor;
8030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8031 type Value = ListFragmentDistributionRequest;
8032
8033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8034 formatter.write_str("struct meta.ListFragmentDistributionRequest")
8035 }
8036
8037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
8038 where
8039 V: serde::de::MapAccess<'de>,
8040 {
8041 while map_.next_key::<GeneratedField>()?.is_some() {
8042 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8043 }
8044 Ok(ListFragmentDistributionRequest {
8045 })
8046 }
8047 }
8048 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8049 }
8050}
8051impl serde::Serialize for ListFragmentDistributionResponse {
8052 #[allow(deprecated)]
8053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8054 where
8055 S: serde::Serializer,
8056 {
8057 use serde::ser::SerializeStruct;
8058 let mut len = 0;
8059 if !self.distributions.is_empty() {
8060 len += 1;
8061 }
8062 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
8063 if !self.distributions.is_empty() {
8064 struct_ser.serialize_field("distributions", &self.distributions)?;
8065 }
8066 struct_ser.end()
8067 }
8068}
8069impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
8070 #[allow(deprecated)]
8071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8072 where
8073 D: serde::Deserializer<'de>,
8074 {
8075 const FIELDS: &[&str] = &[
8076 "distributions",
8077 ];
8078
8079 #[allow(clippy::enum_variant_names)]
8080 enum GeneratedField {
8081 Distributions,
8082 }
8083 impl<'de> serde::Deserialize<'de> for GeneratedField {
8084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8085 where
8086 D: serde::Deserializer<'de>,
8087 {
8088 struct GeneratedVisitor;
8089
8090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8091 type Value = GeneratedField;
8092
8093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8094 write!(formatter, "expected one of: {:?}", &FIELDS)
8095 }
8096
8097 #[allow(unused_variables)]
8098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8099 where
8100 E: serde::de::Error,
8101 {
8102 match value {
8103 "distributions" => Ok(GeneratedField::Distributions),
8104 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8105 }
8106 }
8107 }
8108 deserializer.deserialize_identifier(GeneratedVisitor)
8109 }
8110 }
8111 struct GeneratedVisitor;
8112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8113 type Value = ListFragmentDistributionResponse;
8114
8115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8116 formatter.write_str("struct meta.ListFragmentDistributionResponse")
8117 }
8118
8119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
8120 where
8121 V: serde::de::MapAccess<'de>,
8122 {
8123 let mut distributions__ = None;
8124 while let Some(k) = map_.next_key()? {
8125 match k {
8126 GeneratedField::Distributions => {
8127 if distributions__.is_some() {
8128 return Err(serde::de::Error::duplicate_field("distributions"));
8129 }
8130 distributions__ = Some(map_.next_value()?);
8131 }
8132 }
8133 }
8134 Ok(ListFragmentDistributionResponse {
8135 distributions: distributions__.unwrap_or_default(),
8136 })
8137 }
8138 }
8139 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
8140 }
8141}
8142impl serde::Serialize for list_fragment_distribution_response::FragmentDistribution {
8143 #[allow(deprecated)]
8144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8145 where
8146 S: serde::Serializer,
8147 {
8148 use serde::ser::SerializeStruct;
8149 let mut len = 0;
8150 if self.fragment_id != 0 {
8151 len += 1;
8152 }
8153 if self.table_id != 0 {
8154 len += 1;
8155 }
8156 if self.distribution_type != 0 {
8157 len += 1;
8158 }
8159 if !self.state_table_ids.is_empty() {
8160 len += 1;
8161 }
8162 if !self.upstream_fragment_ids.is_empty() {
8163 len += 1;
8164 }
8165 if self.fragment_type_mask != 0 {
8166 len += 1;
8167 }
8168 if self.parallelism != 0 {
8169 len += 1;
8170 }
8171 if self.vnode_count != 0 {
8172 len += 1;
8173 }
8174 if self.node.is_some() {
8175 len += 1;
8176 }
8177 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse.FragmentDistribution", len)?;
8178 if self.fragment_id != 0 {
8179 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8180 }
8181 if self.table_id != 0 {
8182 struct_ser.serialize_field("tableId", &self.table_id)?;
8183 }
8184 if self.distribution_type != 0 {
8185 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
8186 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
8187 struct_ser.serialize_field("distributionType", &v)?;
8188 }
8189 if !self.state_table_ids.is_empty() {
8190 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
8191 }
8192 if !self.upstream_fragment_ids.is_empty() {
8193 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
8194 }
8195 if self.fragment_type_mask != 0 {
8196 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
8197 }
8198 if self.parallelism != 0 {
8199 struct_ser.serialize_field("parallelism", &self.parallelism)?;
8200 }
8201 if self.vnode_count != 0 {
8202 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
8203 }
8204 if let Some(v) = self.node.as_ref() {
8205 struct_ser.serialize_field("node", v)?;
8206 }
8207 struct_ser.end()
8208 }
8209}
8210impl<'de> serde::Deserialize<'de> for list_fragment_distribution_response::FragmentDistribution {
8211 #[allow(deprecated)]
8212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8213 where
8214 D: serde::Deserializer<'de>,
8215 {
8216 const FIELDS: &[&str] = &[
8217 "fragment_id",
8218 "fragmentId",
8219 "table_id",
8220 "tableId",
8221 "distribution_type",
8222 "distributionType",
8223 "state_table_ids",
8224 "stateTableIds",
8225 "upstream_fragment_ids",
8226 "upstreamFragmentIds",
8227 "fragment_type_mask",
8228 "fragmentTypeMask",
8229 "parallelism",
8230 "vnode_count",
8231 "vnodeCount",
8232 "node",
8233 ];
8234
8235 #[allow(clippy::enum_variant_names)]
8236 enum GeneratedField {
8237 FragmentId,
8238 TableId,
8239 DistributionType,
8240 StateTableIds,
8241 UpstreamFragmentIds,
8242 FragmentTypeMask,
8243 Parallelism,
8244 VnodeCount,
8245 Node,
8246 }
8247 impl<'de> serde::Deserialize<'de> for GeneratedField {
8248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8249 where
8250 D: serde::Deserializer<'de>,
8251 {
8252 struct GeneratedVisitor;
8253
8254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8255 type Value = GeneratedField;
8256
8257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8258 write!(formatter, "expected one of: {:?}", &FIELDS)
8259 }
8260
8261 #[allow(unused_variables)]
8262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8263 where
8264 E: serde::de::Error,
8265 {
8266 match value {
8267 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8268 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8269 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
8270 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
8271 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
8272 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
8273 "parallelism" => Ok(GeneratedField::Parallelism),
8274 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
8275 "node" => Ok(GeneratedField::Node),
8276 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8277 }
8278 }
8279 }
8280 deserializer.deserialize_identifier(GeneratedVisitor)
8281 }
8282 }
8283 struct GeneratedVisitor;
8284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8285 type Value = list_fragment_distribution_response::FragmentDistribution;
8286
8287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8288 formatter.write_str("struct meta.ListFragmentDistributionResponse.FragmentDistribution")
8289 }
8290
8291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_fragment_distribution_response::FragmentDistribution, V::Error>
8292 where
8293 V: serde::de::MapAccess<'de>,
8294 {
8295 let mut fragment_id__ = None;
8296 let mut table_id__ = None;
8297 let mut distribution_type__ = None;
8298 let mut state_table_ids__ = None;
8299 let mut upstream_fragment_ids__ = None;
8300 let mut fragment_type_mask__ = None;
8301 let mut parallelism__ = None;
8302 let mut vnode_count__ = None;
8303 let mut node__ = None;
8304 while let Some(k) = map_.next_key()? {
8305 match k {
8306 GeneratedField::FragmentId => {
8307 if fragment_id__.is_some() {
8308 return Err(serde::de::Error::duplicate_field("fragmentId"));
8309 }
8310 fragment_id__ =
8311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8312 ;
8313 }
8314 GeneratedField::TableId => {
8315 if table_id__.is_some() {
8316 return Err(serde::de::Error::duplicate_field("tableId"));
8317 }
8318 table_id__ =
8319 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8320 ;
8321 }
8322 GeneratedField::DistributionType => {
8323 if distribution_type__.is_some() {
8324 return Err(serde::de::Error::duplicate_field("distributionType"));
8325 }
8326 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
8327 }
8328 GeneratedField::StateTableIds => {
8329 if state_table_ids__.is_some() {
8330 return Err(serde::de::Error::duplicate_field("stateTableIds"));
8331 }
8332 state_table_ids__ =
8333 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8334 .into_iter().map(|x| x.0).collect())
8335 ;
8336 }
8337 GeneratedField::UpstreamFragmentIds => {
8338 if upstream_fragment_ids__.is_some() {
8339 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
8340 }
8341 upstream_fragment_ids__ =
8342 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8343 .into_iter().map(|x| x.0).collect())
8344 ;
8345 }
8346 GeneratedField::FragmentTypeMask => {
8347 if fragment_type_mask__.is_some() {
8348 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
8349 }
8350 fragment_type_mask__ =
8351 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8352 ;
8353 }
8354 GeneratedField::Parallelism => {
8355 if parallelism__.is_some() {
8356 return Err(serde::de::Error::duplicate_field("parallelism"));
8357 }
8358 parallelism__ =
8359 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8360 ;
8361 }
8362 GeneratedField::VnodeCount => {
8363 if vnode_count__.is_some() {
8364 return Err(serde::de::Error::duplicate_field("vnodeCount"));
8365 }
8366 vnode_count__ =
8367 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8368 ;
8369 }
8370 GeneratedField::Node => {
8371 if node__.is_some() {
8372 return Err(serde::de::Error::duplicate_field("node"));
8373 }
8374 node__ = map_.next_value()?;
8375 }
8376 }
8377 }
8378 Ok(list_fragment_distribution_response::FragmentDistribution {
8379 fragment_id: fragment_id__.unwrap_or_default(),
8380 table_id: table_id__.unwrap_or_default(),
8381 distribution_type: distribution_type__.unwrap_or_default(),
8382 state_table_ids: state_table_ids__.unwrap_or_default(),
8383 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
8384 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
8385 parallelism: parallelism__.unwrap_or_default(),
8386 vnode_count: vnode_count__.unwrap_or_default(),
8387 node: node__,
8388 })
8389 }
8390 }
8391 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse.FragmentDistribution", FIELDS, GeneratedVisitor)
8392 }
8393}
8394impl serde::Serialize for ListObjectDependenciesRequest {
8395 #[allow(deprecated)]
8396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8397 where
8398 S: serde::Serializer,
8399 {
8400 use serde::ser::SerializeStruct;
8401 let len = 0;
8402 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
8403 struct_ser.end()
8404 }
8405}
8406impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
8407 #[allow(deprecated)]
8408 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8409 where
8410 D: serde::Deserializer<'de>,
8411 {
8412 const FIELDS: &[&str] = &[
8413 ];
8414
8415 #[allow(clippy::enum_variant_names)]
8416 enum GeneratedField {
8417 }
8418 impl<'de> serde::Deserialize<'de> for GeneratedField {
8419 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8420 where
8421 D: serde::Deserializer<'de>,
8422 {
8423 struct GeneratedVisitor;
8424
8425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8426 type Value = GeneratedField;
8427
8428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8429 write!(formatter, "expected one of: {:?}", &FIELDS)
8430 }
8431
8432 #[allow(unused_variables)]
8433 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8434 where
8435 E: serde::de::Error,
8436 {
8437 Err(serde::de::Error::unknown_field(value, FIELDS))
8438 }
8439 }
8440 deserializer.deserialize_identifier(GeneratedVisitor)
8441 }
8442 }
8443 struct GeneratedVisitor;
8444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8445 type Value = ListObjectDependenciesRequest;
8446
8447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8448 formatter.write_str("struct meta.ListObjectDependenciesRequest")
8449 }
8450
8451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
8452 where
8453 V: serde::de::MapAccess<'de>,
8454 {
8455 while map_.next_key::<GeneratedField>()?.is_some() {
8456 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8457 }
8458 Ok(ListObjectDependenciesRequest {
8459 })
8460 }
8461 }
8462 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
8463 }
8464}
8465impl serde::Serialize for ListObjectDependenciesResponse {
8466 #[allow(deprecated)]
8467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8468 where
8469 S: serde::Serializer,
8470 {
8471 use serde::ser::SerializeStruct;
8472 let mut len = 0;
8473 if !self.dependencies.is_empty() {
8474 len += 1;
8475 }
8476 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
8477 if !self.dependencies.is_empty() {
8478 struct_ser.serialize_field("dependencies", &self.dependencies)?;
8479 }
8480 struct_ser.end()
8481 }
8482}
8483impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
8484 #[allow(deprecated)]
8485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8486 where
8487 D: serde::Deserializer<'de>,
8488 {
8489 const FIELDS: &[&str] = &[
8490 "dependencies",
8491 ];
8492
8493 #[allow(clippy::enum_variant_names)]
8494 enum GeneratedField {
8495 Dependencies,
8496 }
8497 impl<'de> serde::Deserialize<'de> for GeneratedField {
8498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8499 where
8500 D: serde::Deserializer<'de>,
8501 {
8502 struct GeneratedVisitor;
8503
8504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8505 type Value = GeneratedField;
8506
8507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8508 write!(formatter, "expected one of: {:?}", &FIELDS)
8509 }
8510
8511 #[allow(unused_variables)]
8512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8513 where
8514 E: serde::de::Error,
8515 {
8516 match value {
8517 "dependencies" => Ok(GeneratedField::Dependencies),
8518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8519 }
8520 }
8521 }
8522 deserializer.deserialize_identifier(GeneratedVisitor)
8523 }
8524 }
8525 struct GeneratedVisitor;
8526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8527 type Value = ListObjectDependenciesResponse;
8528
8529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8530 formatter.write_str("struct meta.ListObjectDependenciesResponse")
8531 }
8532
8533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
8534 where
8535 V: serde::de::MapAccess<'de>,
8536 {
8537 let mut dependencies__ = None;
8538 while let Some(k) = map_.next_key()? {
8539 match k {
8540 GeneratedField::Dependencies => {
8541 if dependencies__.is_some() {
8542 return Err(serde::de::Error::duplicate_field("dependencies"));
8543 }
8544 dependencies__ = Some(map_.next_value()?);
8545 }
8546 }
8547 }
8548 Ok(ListObjectDependenciesResponse {
8549 dependencies: dependencies__.unwrap_or_default(),
8550 })
8551 }
8552 }
8553 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
8554 }
8555}
8556impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
8557 #[allow(deprecated)]
8558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8559 where
8560 S: serde::Serializer,
8561 {
8562 use serde::ser::SerializeStruct;
8563 let mut len = 0;
8564 if self.object_id != 0 {
8565 len += 1;
8566 }
8567 if self.referenced_object_id != 0 {
8568 len += 1;
8569 }
8570 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
8571 if self.object_id != 0 {
8572 struct_ser.serialize_field("objectId", &self.object_id)?;
8573 }
8574 if self.referenced_object_id != 0 {
8575 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
8576 }
8577 struct_ser.end()
8578 }
8579}
8580impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
8581 #[allow(deprecated)]
8582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8583 where
8584 D: serde::Deserializer<'de>,
8585 {
8586 const FIELDS: &[&str] = &[
8587 "object_id",
8588 "objectId",
8589 "referenced_object_id",
8590 "referencedObjectId",
8591 ];
8592
8593 #[allow(clippy::enum_variant_names)]
8594 enum GeneratedField {
8595 ObjectId,
8596 ReferencedObjectId,
8597 }
8598 impl<'de> serde::Deserialize<'de> for GeneratedField {
8599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8600 where
8601 D: serde::Deserializer<'de>,
8602 {
8603 struct GeneratedVisitor;
8604
8605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8606 type Value = GeneratedField;
8607
8608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8609 write!(formatter, "expected one of: {:?}", &FIELDS)
8610 }
8611
8612 #[allow(unused_variables)]
8613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8614 where
8615 E: serde::de::Error,
8616 {
8617 match value {
8618 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
8619 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
8620 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8621 }
8622 }
8623 }
8624 deserializer.deserialize_identifier(GeneratedVisitor)
8625 }
8626 }
8627 struct GeneratedVisitor;
8628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8629 type Value = list_object_dependencies_response::ObjectDependencies;
8630
8631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8632 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
8633 }
8634
8635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
8636 where
8637 V: serde::de::MapAccess<'de>,
8638 {
8639 let mut object_id__ = None;
8640 let mut referenced_object_id__ = None;
8641 while let Some(k) = map_.next_key()? {
8642 match k {
8643 GeneratedField::ObjectId => {
8644 if object_id__.is_some() {
8645 return Err(serde::de::Error::duplicate_field("objectId"));
8646 }
8647 object_id__ =
8648 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8649 ;
8650 }
8651 GeneratedField::ReferencedObjectId => {
8652 if referenced_object_id__.is_some() {
8653 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
8654 }
8655 referenced_object_id__ =
8656 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8657 ;
8658 }
8659 }
8660 }
8661 Ok(list_object_dependencies_response::ObjectDependencies {
8662 object_id: object_id__.unwrap_or_default(),
8663 referenced_object_id: referenced_object_id__.unwrap_or_default(),
8664 })
8665 }
8666 }
8667 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
8668 }
8669}
8670impl serde::Serialize for ListRateLimitsRequest {
8671 #[allow(deprecated)]
8672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8673 where
8674 S: serde::Serializer,
8675 {
8676 use serde::ser::SerializeStruct;
8677 let len = 0;
8678 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
8679 struct_ser.end()
8680 }
8681}
8682impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
8683 #[allow(deprecated)]
8684 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8685 where
8686 D: serde::Deserializer<'de>,
8687 {
8688 const FIELDS: &[&str] = &[
8689 ];
8690
8691 #[allow(clippy::enum_variant_names)]
8692 enum GeneratedField {
8693 }
8694 impl<'de> serde::Deserialize<'de> for GeneratedField {
8695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8696 where
8697 D: serde::Deserializer<'de>,
8698 {
8699 struct GeneratedVisitor;
8700
8701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8702 type Value = GeneratedField;
8703
8704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8705 write!(formatter, "expected one of: {:?}", &FIELDS)
8706 }
8707
8708 #[allow(unused_variables)]
8709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8710 where
8711 E: serde::de::Error,
8712 {
8713 Err(serde::de::Error::unknown_field(value, FIELDS))
8714 }
8715 }
8716 deserializer.deserialize_identifier(GeneratedVisitor)
8717 }
8718 }
8719 struct GeneratedVisitor;
8720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8721 type Value = ListRateLimitsRequest;
8722
8723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8724 formatter.write_str("struct meta.ListRateLimitsRequest")
8725 }
8726
8727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
8728 where
8729 V: serde::de::MapAccess<'de>,
8730 {
8731 while map_.next_key::<GeneratedField>()?.is_some() {
8732 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8733 }
8734 Ok(ListRateLimitsRequest {
8735 })
8736 }
8737 }
8738 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
8739 }
8740}
8741impl serde::Serialize for ListRateLimitsResponse {
8742 #[allow(deprecated)]
8743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8744 where
8745 S: serde::Serializer,
8746 {
8747 use serde::ser::SerializeStruct;
8748 let mut len = 0;
8749 if !self.rate_limits.is_empty() {
8750 len += 1;
8751 }
8752 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
8753 if !self.rate_limits.is_empty() {
8754 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
8755 }
8756 struct_ser.end()
8757 }
8758}
8759impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
8760 #[allow(deprecated)]
8761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8762 where
8763 D: serde::Deserializer<'de>,
8764 {
8765 const FIELDS: &[&str] = &[
8766 "rate_limits",
8767 "rateLimits",
8768 ];
8769
8770 #[allow(clippy::enum_variant_names)]
8771 enum GeneratedField {
8772 RateLimits,
8773 }
8774 impl<'de> serde::Deserialize<'de> for GeneratedField {
8775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8776 where
8777 D: serde::Deserializer<'de>,
8778 {
8779 struct GeneratedVisitor;
8780
8781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8782 type Value = GeneratedField;
8783
8784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8785 write!(formatter, "expected one of: {:?}", &FIELDS)
8786 }
8787
8788 #[allow(unused_variables)]
8789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8790 where
8791 E: serde::de::Error,
8792 {
8793 match value {
8794 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
8795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8796 }
8797 }
8798 }
8799 deserializer.deserialize_identifier(GeneratedVisitor)
8800 }
8801 }
8802 struct GeneratedVisitor;
8803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8804 type Value = ListRateLimitsResponse;
8805
8806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8807 formatter.write_str("struct meta.ListRateLimitsResponse")
8808 }
8809
8810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
8811 where
8812 V: serde::de::MapAccess<'de>,
8813 {
8814 let mut rate_limits__ = None;
8815 while let Some(k) = map_.next_key()? {
8816 match k {
8817 GeneratedField::RateLimits => {
8818 if rate_limits__.is_some() {
8819 return Err(serde::de::Error::duplicate_field("rateLimits"));
8820 }
8821 rate_limits__ = Some(map_.next_value()?);
8822 }
8823 }
8824 }
8825 Ok(ListRateLimitsResponse {
8826 rate_limits: rate_limits__.unwrap_or_default(),
8827 })
8828 }
8829 }
8830 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
8831 }
8832}
8833impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
8834 #[allow(deprecated)]
8835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8836 where
8837 S: serde::Serializer,
8838 {
8839 use serde::ser::SerializeStruct;
8840 let mut len = 0;
8841 if self.fragment_id != 0 {
8842 len += 1;
8843 }
8844 if self.job_id != 0 {
8845 len += 1;
8846 }
8847 if self.fragment_type_mask != 0 {
8848 len += 1;
8849 }
8850 if self.rate_limit != 0 {
8851 len += 1;
8852 }
8853 if !self.node_name.is_empty() {
8854 len += 1;
8855 }
8856 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
8857 if self.fragment_id != 0 {
8858 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8859 }
8860 if self.job_id != 0 {
8861 struct_ser.serialize_field("jobId", &self.job_id)?;
8862 }
8863 if self.fragment_type_mask != 0 {
8864 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
8865 }
8866 if self.rate_limit != 0 {
8867 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
8868 }
8869 if !self.node_name.is_empty() {
8870 struct_ser.serialize_field("nodeName", &self.node_name)?;
8871 }
8872 struct_ser.end()
8873 }
8874}
8875impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
8876 #[allow(deprecated)]
8877 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8878 where
8879 D: serde::Deserializer<'de>,
8880 {
8881 const FIELDS: &[&str] = &[
8882 "fragment_id",
8883 "fragmentId",
8884 "job_id",
8885 "jobId",
8886 "fragment_type_mask",
8887 "fragmentTypeMask",
8888 "rate_limit",
8889 "rateLimit",
8890 "node_name",
8891 "nodeName",
8892 ];
8893
8894 #[allow(clippy::enum_variant_names)]
8895 enum GeneratedField {
8896 FragmentId,
8897 JobId,
8898 FragmentTypeMask,
8899 RateLimit,
8900 NodeName,
8901 }
8902 impl<'de> serde::Deserialize<'de> for GeneratedField {
8903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8904 where
8905 D: serde::Deserializer<'de>,
8906 {
8907 struct GeneratedVisitor;
8908
8909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8910 type Value = GeneratedField;
8911
8912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8913 write!(formatter, "expected one of: {:?}", &FIELDS)
8914 }
8915
8916 #[allow(unused_variables)]
8917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8918 where
8919 E: serde::de::Error,
8920 {
8921 match value {
8922 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8923 "jobId" | "job_id" => Ok(GeneratedField::JobId),
8924 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
8925 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8926 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
8927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8928 }
8929 }
8930 }
8931 deserializer.deserialize_identifier(GeneratedVisitor)
8932 }
8933 }
8934 struct GeneratedVisitor;
8935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8936 type Value = list_rate_limits_response::RateLimitInfo;
8937
8938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8939 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
8940 }
8941
8942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
8943 where
8944 V: serde::de::MapAccess<'de>,
8945 {
8946 let mut fragment_id__ = None;
8947 let mut job_id__ = None;
8948 let mut fragment_type_mask__ = None;
8949 let mut rate_limit__ = None;
8950 let mut node_name__ = None;
8951 while let Some(k) = map_.next_key()? {
8952 match k {
8953 GeneratedField::FragmentId => {
8954 if fragment_id__.is_some() {
8955 return Err(serde::de::Error::duplicate_field("fragmentId"));
8956 }
8957 fragment_id__ =
8958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8959 ;
8960 }
8961 GeneratedField::JobId => {
8962 if job_id__.is_some() {
8963 return Err(serde::de::Error::duplicate_field("jobId"));
8964 }
8965 job_id__ =
8966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8967 ;
8968 }
8969 GeneratedField::FragmentTypeMask => {
8970 if fragment_type_mask__.is_some() {
8971 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
8972 }
8973 fragment_type_mask__ =
8974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8975 ;
8976 }
8977 GeneratedField::RateLimit => {
8978 if rate_limit__.is_some() {
8979 return Err(serde::de::Error::duplicate_field("rateLimit"));
8980 }
8981 rate_limit__ =
8982 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8983 ;
8984 }
8985 GeneratedField::NodeName => {
8986 if node_name__.is_some() {
8987 return Err(serde::de::Error::duplicate_field("nodeName"));
8988 }
8989 node_name__ = Some(map_.next_value()?);
8990 }
8991 }
8992 }
8993 Ok(list_rate_limits_response::RateLimitInfo {
8994 fragment_id: fragment_id__.unwrap_or_default(),
8995 job_id: job_id__.unwrap_or_default(),
8996 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
8997 rate_limit: rate_limit__.unwrap_or_default(),
8998 node_name: node_name__.unwrap_or_default(),
8999 })
9000 }
9001 }
9002 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
9003 }
9004}
9005impl serde::Serialize for ListStreamingJobStatesRequest {
9006 #[allow(deprecated)]
9007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9008 where
9009 S: serde::Serializer,
9010 {
9011 use serde::ser::SerializeStruct;
9012 let len = 0;
9013 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
9014 struct_ser.end()
9015 }
9016}
9017impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
9018 #[allow(deprecated)]
9019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9020 where
9021 D: serde::Deserializer<'de>,
9022 {
9023 const FIELDS: &[&str] = &[
9024 ];
9025
9026 #[allow(clippy::enum_variant_names)]
9027 enum GeneratedField {
9028 }
9029 impl<'de> serde::Deserialize<'de> for GeneratedField {
9030 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9031 where
9032 D: serde::Deserializer<'de>,
9033 {
9034 struct GeneratedVisitor;
9035
9036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9037 type Value = GeneratedField;
9038
9039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9040 write!(formatter, "expected one of: {:?}", &FIELDS)
9041 }
9042
9043 #[allow(unused_variables)]
9044 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9045 where
9046 E: serde::de::Error,
9047 {
9048 Err(serde::de::Error::unknown_field(value, FIELDS))
9049 }
9050 }
9051 deserializer.deserialize_identifier(GeneratedVisitor)
9052 }
9053 }
9054 struct GeneratedVisitor;
9055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9056 type Value = ListStreamingJobStatesRequest;
9057
9058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9059 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
9060 }
9061
9062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
9063 where
9064 V: serde::de::MapAccess<'de>,
9065 {
9066 while map_.next_key::<GeneratedField>()?.is_some() {
9067 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9068 }
9069 Ok(ListStreamingJobStatesRequest {
9070 })
9071 }
9072 }
9073 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
9074 }
9075}
9076impl serde::Serialize for ListStreamingJobStatesResponse {
9077 #[allow(deprecated)]
9078 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9079 where
9080 S: serde::Serializer,
9081 {
9082 use serde::ser::SerializeStruct;
9083 let mut len = 0;
9084 if !self.states.is_empty() {
9085 len += 1;
9086 }
9087 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
9088 if !self.states.is_empty() {
9089 struct_ser.serialize_field("states", &self.states)?;
9090 }
9091 struct_ser.end()
9092 }
9093}
9094impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
9095 #[allow(deprecated)]
9096 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9097 where
9098 D: serde::Deserializer<'de>,
9099 {
9100 const FIELDS: &[&str] = &[
9101 "states",
9102 ];
9103
9104 #[allow(clippy::enum_variant_names)]
9105 enum GeneratedField {
9106 States,
9107 }
9108 impl<'de> serde::Deserialize<'de> for GeneratedField {
9109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9110 where
9111 D: serde::Deserializer<'de>,
9112 {
9113 struct GeneratedVisitor;
9114
9115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9116 type Value = GeneratedField;
9117
9118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9119 write!(formatter, "expected one of: {:?}", &FIELDS)
9120 }
9121
9122 #[allow(unused_variables)]
9123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9124 where
9125 E: serde::de::Error,
9126 {
9127 match value {
9128 "states" => Ok(GeneratedField::States),
9129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9130 }
9131 }
9132 }
9133 deserializer.deserialize_identifier(GeneratedVisitor)
9134 }
9135 }
9136 struct GeneratedVisitor;
9137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9138 type Value = ListStreamingJobStatesResponse;
9139
9140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9141 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
9142 }
9143
9144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
9145 where
9146 V: serde::de::MapAccess<'de>,
9147 {
9148 let mut states__ = None;
9149 while let Some(k) = map_.next_key()? {
9150 match k {
9151 GeneratedField::States => {
9152 if states__.is_some() {
9153 return Err(serde::de::Error::duplicate_field("states"));
9154 }
9155 states__ = Some(map_.next_value()?);
9156 }
9157 }
9158 }
9159 Ok(ListStreamingJobStatesResponse {
9160 states: states__.unwrap_or_default(),
9161 })
9162 }
9163 }
9164 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
9165 }
9166}
9167impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
9168 #[allow(deprecated)]
9169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9170 where
9171 S: serde::Serializer,
9172 {
9173 use serde::ser::SerializeStruct;
9174 let mut len = 0;
9175 if self.table_id != 0 {
9176 len += 1;
9177 }
9178 if self.state != 0 {
9179 len += 1;
9180 }
9181 if self.parallelism.is_some() {
9182 len += 1;
9183 }
9184 if self.max_parallelism != 0 {
9185 len += 1;
9186 }
9187 if !self.name.is_empty() {
9188 len += 1;
9189 }
9190 if !self.resource_group.is_empty() {
9191 len += 1;
9192 }
9193 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
9194 if self.table_id != 0 {
9195 struct_ser.serialize_field("tableId", &self.table_id)?;
9196 }
9197 if self.state != 0 {
9198 let v = table_fragments::State::try_from(self.state)
9199 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
9200 struct_ser.serialize_field("state", &v)?;
9201 }
9202 if let Some(v) = self.parallelism.as_ref() {
9203 struct_ser.serialize_field("parallelism", v)?;
9204 }
9205 if self.max_parallelism != 0 {
9206 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
9207 }
9208 if !self.name.is_empty() {
9209 struct_ser.serialize_field("name", &self.name)?;
9210 }
9211 if !self.resource_group.is_empty() {
9212 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
9213 }
9214 struct_ser.end()
9215 }
9216}
9217impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
9218 #[allow(deprecated)]
9219 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9220 where
9221 D: serde::Deserializer<'de>,
9222 {
9223 const FIELDS: &[&str] = &[
9224 "table_id",
9225 "tableId",
9226 "state",
9227 "parallelism",
9228 "max_parallelism",
9229 "maxParallelism",
9230 "name",
9231 "resource_group",
9232 "resourceGroup",
9233 ];
9234
9235 #[allow(clippy::enum_variant_names)]
9236 enum GeneratedField {
9237 TableId,
9238 State,
9239 Parallelism,
9240 MaxParallelism,
9241 Name,
9242 ResourceGroup,
9243 }
9244 impl<'de> serde::Deserialize<'de> for GeneratedField {
9245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9246 where
9247 D: serde::Deserializer<'de>,
9248 {
9249 struct GeneratedVisitor;
9250
9251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9252 type Value = GeneratedField;
9253
9254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9255 write!(formatter, "expected one of: {:?}", &FIELDS)
9256 }
9257
9258 #[allow(unused_variables)]
9259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9260 where
9261 E: serde::de::Error,
9262 {
9263 match value {
9264 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9265 "state" => Ok(GeneratedField::State),
9266 "parallelism" => Ok(GeneratedField::Parallelism),
9267 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
9268 "name" => Ok(GeneratedField::Name),
9269 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
9270 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9271 }
9272 }
9273 }
9274 deserializer.deserialize_identifier(GeneratedVisitor)
9275 }
9276 }
9277 struct GeneratedVisitor;
9278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9279 type Value = list_streaming_job_states_response::StreamingJobState;
9280
9281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9282 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
9283 }
9284
9285 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
9286 where
9287 V: serde::de::MapAccess<'de>,
9288 {
9289 let mut table_id__ = None;
9290 let mut state__ = None;
9291 let mut parallelism__ = None;
9292 let mut max_parallelism__ = None;
9293 let mut name__ = None;
9294 let mut resource_group__ = None;
9295 while let Some(k) = map_.next_key()? {
9296 match k {
9297 GeneratedField::TableId => {
9298 if table_id__.is_some() {
9299 return Err(serde::de::Error::duplicate_field("tableId"));
9300 }
9301 table_id__ =
9302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9303 ;
9304 }
9305 GeneratedField::State => {
9306 if state__.is_some() {
9307 return Err(serde::de::Error::duplicate_field("state"));
9308 }
9309 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
9310 }
9311 GeneratedField::Parallelism => {
9312 if parallelism__.is_some() {
9313 return Err(serde::de::Error::duplicate_field("parallelism"));
9314 }
9315 parallelism__ = map_.next_value()?;
9316 }
9317 GeneratedField::MaxParallelism => {
9318 if max_parallelism__.is_some() {
9319 return Err(serde::de::Error::duplicate_field("maxParallelism"));
9320 }
9321 max_parallelism__ =
9322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9323 ;
9324 }
9325 GeneratedField::Name => {
9326 if name__.is_some() {
9327 return Err(serde::de::Error::duplicate_field("name"));
9328 }
9329 name__ = Some(map_.next_value()?);
9330 }
9331 GeneratedField::ResourceGroup => {
9332 if resource_group__.is_some() {
9333 return Err(serde::de::Error::duplicate_field("resourceGroup"));
9334 }
9335 resource_group__ = Some(map_.next_value()?);
9336 }
9337 }
9338 }
9339 Ok(list_streaming_job_states_response::StreamingJobState {
9340 table_id: table_id__.unwrap_or_default(),
9341 state: state__.unwrap_or_default(),
9342 parallelism: parallelism__,
9343 max_parallelism: max_parallelism__.unwrap_or_default(),
9344 name: name__.unwrap_or_default(),
9345 resource_group: resource_group__.unwrap_or_default(),
9346 })
9347 }
9348 }
9349 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
9350 }
9351}
9352impl serde::Serialize for ListTableFragmentsRequest {
9353 #[allow(deprecated)]
9354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9355 where
9356 S: serde::Serializer,
9357 {
9358 use serde::ser::SerializeStruct;
9359 let mut len = 0;
9360 if !self.table_ids.is_empty() {
9361 len += 1;
9362 }
9363 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
9364 if !self.table_ids.is_empty() {
9365 struct_ser.serialize_field("tableIds", &self.table_ids)?;
9366 }
9367 struct_ser.end()
9368 }
9369}
9370impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
9371 #[allow(deprecated)]
9372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9373 where
9374 D: serde::Deserializer<'de>,
9375 {
9376 const FIELDS: &[&str] = &[
9377 "table_ids",
9378 "tableIds",
9379 ];
9380
9381 #[allow(clippy::enum_variant_names)]
9382 enum GeneratedField {
9383 TableIds,
9384 }
9385 impl<'de> serde::Deserialize<'de> for GeneratedField {
9386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9387 where
9388 D: serde::Deserializer<'de>,
9389 {
9390 struct GeneratedVisitor;
9391
9392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9393 type Value = GeneratedField;
9394
9395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9396 write!(formatter, "expected one of: {:?}", &FIELDS)
9397 }
9398
9399 #[allow(unused_variables)]
9400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9401 where
9402 E: serde::de::Error,
9403 {
9404 match value {
9405 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
9406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9407 }
9408 }
9409 }
9410 deserializer.deserialize_identifier(GeneratedVisitor)
9411 }
9412 }
9413 struct GeneratedVisitor;
9414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9415 type Value = ListTableFragmentsRequest;
9416
9417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9418 formatter.write_str("struct meta.ListTableFragmentsRequest")
9419 }
9420
9421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
9422 where
9423 V: serde::de::MapAccess<'de>,
9424 {
9425 let mut table_ids__ = None;
9426 while let Some(k) = map_.next_key()? {
9427 match k {
9428 GeneratedField::TableIds => {
9429 if table_ids__.is_some() {
9430 return Err(serde::de::Error::duplicate_field("tableIds"));
9431 }
9432 table_ids__ =
9433 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9434 .into_iter().map(|x| x.0).collect())
9435 ;
9436 }
9437 }
9438 }
9439 Ok(ListTableFragmentsRequest {
9440 table_ids: table_ids__.unwrap_or_default(),
9441 })
9442 }
9443 }
9444 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
9445 }
9446}
9447impl serde::Serialize for ListTableFragmentsResponse {
9448 #[allow(deprecated)]
9449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9450 where
9451 S: serde::Serializer,
9452 {
9453 use serde::ser::SerializeStruct;
9454 let mut len = 0;
9455 if !self.table_fragments.is_empty() {
9456 len += 1;
9457 }
9458 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
9459 if !self.table_fragments.is_empty() {
9460 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
9461 }
9462 struct_ser.end()
9463 }
9464}
9465impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
9466 #[allow(deprecated)]
9467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9468 where
9469 D: serde::Deserializer<'de>,
9470 {
9471 const FIELDS: &[&str] = &[
9472 "table_fragments",
9473 "tableFragments",
9474 ];
9475
9476 #[allow(clippy::enum_variant_names)]
9477 enum GeneratedField {
9478 TableFragments,
9479 }
9480 impl<'de> serde::Deserialize<'de> for GeneratedField {
9481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9482 where
9483 D: serde::Deserializer<'de>,
9484 {
9485 struct GeneratedVisitor;
9486
9487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9488 type Value = GeneratedField;
9489
9490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9491 write!(formatter, "expected one of: {:?}", &FIELDS)
9492 }
9493
9494 #[allow(unused_variables)]
9495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9496 where
9497 E: serde::de::Error,
9498 {
9499 match value {
9500 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
9501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9502 }
9503 }
9504 }
9505 deserializer.deserialize_identifier(GeneratedVisitor)
9506 }
9507 }
9508 struct GeneratedVisitor;
9509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9510 type Value = ListTableFragmentsResponse;
9511
9512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9513 formatter.write_str("struct meta.ListTableFragmentsResponse")
9514 }
9515
9516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
9517 where
9518 V: serde::de::MapAccess<'de>,
9519 {
9520 let mut table_fragments__ = None;
9521 while let Some(k) = map_.next_key()? {
9522 match k {
9523 GeneratedField::TableFragments => {
9524 if table_fragments__.is_some() {
9525 return Err(serde::de::Error::duplicate_field("tableFragments"));
9526 }
9527 table_fragments__ = Some(
9528 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9529 .into_iter().map(|(k,v)| (k.0, v)).collect()
9530 );
9531 }
9532 }
9533 }
9534 Ok(ListTableFragmentsResponse {
9535 table_fragments: table_fragments__.unwrap_or_default(),
9536 })
9537 }
9538 }
9539 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
9540 }
9541}
9542impl serde::Serialize for list_table_fragments_response::ActorInfo {
9543 #[allow(deprecated)]
9544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9545 where
9546 S: serde::Serializer,
9547 {
9548 use serde::ser::SerializeStruct;
9549 let mut len = 0;
9550 if self.id != 0 {
9551 len += 1;
9552 }
9553 if self.node.is_some() {
9554 len += 1;
9555 }
9556 if !self.dispatcher.is_empty() {
9557 len += 1;
9558 }
9559 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
9560 if self.id != 0 {
9561 struct_ser.serialize_field("id", &self.id)?;
9562 }
9563 if let Some(v) = self.node.as_ref() {
9564 struct_ser.serialize_field("node", v)?;
9565 }
9566 if !self.dispatcher.is_empty() {
9567 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9568 }
9569 struct_ser.end()
9570 }
9571}
9572impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
9573 #[allow(deprecated)]
9574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9575 where
9576 D: serde::Deserializer<'de>,
9577 {
9578 const FIELDS: &[&str] = &[
9579 "id",
9580 "node",
9581 "dispatcher",
9582 ];
9583
9584 #[allow(clippy::enum_variant_names)]
9585 enum GeneratedField {
9586 Id,
9587 Node,
9588 Dispatcher,
9589 }
9590 impl<'de> serde::Deserialize<'de> for GeneratedField {
9591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9592 where
9593 D: serde::Deserializer<'de>,
9594 {
9595 struct GeneratedVisitor;
9596
9597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9598 type Value = GeneratedField;
9599
9600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9601 write!(formatter, "expected one of: {:?}", &FIELDS)
9602 }
9603
9604 #[allow(unused_variables)]
9605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9606 where
9607 E: serde::de::Error,
9608 {
9609 match value {
9610 "id" => Ok(GeneratedField::Id),
9611 "node" => Ok(GeneratedField::Node),
9612 "dispatcher" => Ok(GeneratedField::Dispatcher),
9613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9614 }
9615 }
9616 }
9617 deserializer.deserialize_identifier(GeneratedVisitor)
9618 }
9619 }
9620 struct GeneratedVisitor;
9621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9622 type Value = list_table_fragments_response::ActorInfo;
9623
9624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9625 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
9626 }
9627
9628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
9629 where
9630 V: serde::de::MapAccess<'de>,
9631 {
9632 let mut id__ = None;
9633 let mut node__ = None;
9634 let mut dispatcher__ = None;
9635 while let Some(k) = map_.next_key()? {
9636 match k {
9637 GeneratedField::Id => {
9638 if id__.is_some() {
9639 return Err(serde::de::Error::duplicate_field("id"));
9640 }
9641 id__ =
9642 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9643 ;
9644 }
9645 GeneratedField::Node => {
9646 if node__.is_some() {
9647 return Err(serde::de::Error::duplicate_field("node"));
9648 }
9649 node__ = map_.next_value()?;
9650 }
9651 GeneratedField::Dispatcher => {
9652 if dispatcher__.is_some() {
9653 return Err(serde::de::Error::duplicate_field("dispatcher"));
9654 }
9655 dispatcher__ = Some(map_.next_value()?);
9656 }
9657 }
9658 }
9659 Ok(list_table_fragments_response::ActorInfo {
9660 id: id__.unwrap_or_default(),
9661 node: node__,
9662 dispatcher: dispatcher__.unwrap_or_default(),
9663 })
9664 }
9665 }
9666 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
9667 }
9668}
9669impl serde::Serialize for list_table_fragments_response::FragmentInfo {
9670 #[allow(deprecated)]
9671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9672 where
9673 S: serde::Serializer,
9674 {
9675 use serde::ser::SerializeStruct;
9676 let mut len = 0;
9677 if self.id != 0 {
9678 len += 1;
9679 }
9680 if !self.actors.is_empty() {
9681 len += 1;
9682 }
9683 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
9684 if self.id != 0 {
9685 struct_ser.serialize_field("id", &self.id)?;
9686 }
9687 if !self.actors.is_empty() {
9688 struct_ser.serialize_field("actors", &self.actors)?;
9689 }
9690 struct_ser.end()
9691 }
9692}
9693impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
9694 #[allow(deprecated)]
9695 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9696 where
9697 D: serde::Deserializer<'de>,
9698 {
9699 const FIELDS: &[&str] = &[
9700 "id",
9701 "actors",
9702 ];
9703
9704 #[allow(clippy::enum_variant_names)]
9705 enum GeneratedField {
9706 Id,
9707 Actors,
9708 }
9709 impl<'de> serde::Deserialize<'de> for GeneratedField {
9710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9711 where
9712 D: serde::Deserializer<'de>,
9713 {
9714 struct GeneratedVisitor;
9715
9716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9717 type Value = GeneratedField;
9718
9719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9720 write!(formatter, "expected one of: {:?}", &FIELDS)
9721 }
9722
9723 #[allow(unused_variables)]
9724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9725 where
9726 E: serde::de::Error,
9727 {
9728 match value {
9729 "id" => Ok(GeneratedField::Id),
9730 "actors" => Ok(GeneratedField::Actors),
9731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9732 }
9733 }
9734 }
9735 deserializer.deserialize_identifier(GeneratedVisitor)
9736 }
9737 }
9738 struct GeneratedVisitor;
9739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9740 type Value = list_table_fragments_response::FragmentInfo;
9741
9742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9743 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
9744 }
9745
9746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
9747 where
9748 V: serde::de::MapAccess<'de>,
9749 {
9750 let mut id__ = None;
9751 let mut actors__ = None;
9752 while let Some(k) = map_.next_key()? {
9753 match k {
9754 GeneratedField::Id => {
9755 if id__.is_some() {
9756 return Err(serde::de::Error::duplicate_field("id"));
9757 }
9758 id__ =
9759 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9760 ;
9761 }
9762 GeneratedField::Actors => {
9763 if actors__.is_some() {
9764 return Err(serde::de::Error::duplicate_field("actors"));
9765 }
9766 actors__ = Some(map_.next_value()?);
9767 }
9768 }
9769 }
9770 Ok(list_table_fragments_response::FragmentInfo {
9771 id: id__.unwrap_or_default(),
9772 actors: actors__.unwrap_or_default(),
9773 })
9774 }
9775 }
9776 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
9777 }
9778}
9779impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
9780 #[allow(deprecated)]
9781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9782 where
9783 S: serde::Serializer,
9784 {
9785 use serde::ser::SerializeStruct;
9786 let mut len = 0;
9787 if !self.fragments.is_empty() {
9788 len += 1;
9789 }
9790 if self.ctx.is_some() {
9791 len += 1;
9792 }
9793 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
9794 if !self.fragments.is_empty() {
9795 struct_ser.serialize_field("fragments", &self.fragments)?;
9796 }
9797 if let Some(v) = self.ctx.as_ref() {
9798 struct_ser.serialize_field("ctx", v)?;
9799 }
9800 struct_ser.end()
9801 }
9802}
9803impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
9804 #[allow(deprecated)]
9805 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9806 where
9807 D: serde::Deserializer<'de>,
9808 {
9809 const FIELDS: &[&str] = &[
9810 "fragments",
9811 "ctx",
9812 ];
9813
9814 #[allow(clippy::enum_variant_names)]
9815 enum GeneratedField {
9816 Fragments,
9817 Ctx,
9818 }
9819 impl<'de> serde::Deserialize<'de> for GeneratedField {
9820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9821 where
9822 D: serde::Deserializer<'de>,
9823 {
9824 struct GeneratedVisitor;
9825
9826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9827 type Value = GeneratedField;
9828
9829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9830 write!(formatter, "expected one of: {:?}", &FIELDS)
9831 }
9832
9833 #[allow(unused_variables)]
9834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9835 where
9836 E: serde::de::Error,
9837 {
9838 match value {
9839 "fragments" => Ok(GeneratedField::Fragments),
9840 "ctx" => Ok(GeneratedField::Ctx),
9841 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9842 }
9843 }
9844 }
9845 deserializer.deserialize_identifier(GeneratedVisitor)
9846 }
9847 }
9848 struct GeneratedVisitor;
9849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9850 type Value = list_table_fragments_response::TableFragmentInfo;
9851
9852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9853 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
9854 }
9855
9856 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
9857 where
9858 V: serde::de::MapAccess<'de>,
9859 {
9860 let mut fragments__ = None;
9861 let mut ctx__ = None;
9862 while let Some(k) = map_.next_key()? {
9863 match k {
9864 GeneratedField::Fragments => {
9865 if fragments__.is_some() {
9866 return Err(serde::de::Error::duplicate_field("fragments"));
9867 }
9868 fragments__ = Some(map_.next_value()?);
9869 }
9870 GeneratedField::Ctx => {
9871 if ctx__.is_some() {
9872 return Err(serde::de::Error::duplicate_field("ctx"));
9873 }
9874 ctx__ = map_.next_value()?;
9875 }
9876 }
9877 }
9878 Ok(list_table_fragments_response::TableFragmentInfo {
9879 fragments: fragments__.unwrap_or_default(),
9880 ctx: ctx__,
9881 })
9882 }
9883 }
9884 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
9885 }
9886}
9887impl serde::Serialize for MembersRequest {
9888 #[allow(deprecated)]
9889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9890 where
9891 S: serde::Serializer,
9892 {
9893 use serde::ser::SerializeStruct;
9894 let len = 0;
9895 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
9896 struct_ser.end()
9897 }
9898}
9899impl<'de> serde::Deserialize<'de> for MembersRequest {
9900 #[allow(deprecated)]
9901 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9902 where
9903 D: serde::Deserializer<'de>,
9904 {
9905 const FIELDS: &[&str] = &[
9906 ];
9907
9908 #[allow(clippy::enum_variant_names)]
9909 enum GeneratedField {
9910 }
9911 impl<'de> serde::Deserialize<'de> for GeneratedField {
9912 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9913 where
9914 D: serde::Deserializer<'de>,
9915 {
9916 struct GeneratedVisitor;
9917
9918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9919 type Value = GeneratedField;
9920
9921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9922 write!(formatter, "expected one of: {:?}", &FIELDS)
9923 }
9924
9925 #[allow(unused_variables)]
9926 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9927 where
9928 E: serde::de::Error,
9929 {
9930 Err(serde::de::Error::unknown_field(value, FIELDS))
9931 }
9932 }
9933 deserializer.deserialize_identifier(GeneratedVisitor)
9934 }
9935 }
9936 struct GeneratedVisitor;
9937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9938 type Value = MembersRequest;
9939
9940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9941 formatter.write_str("struct meta.MembersRequest")
9942 }
9943
9944 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
9945 where
9946 V: serde::de::MapAccess<'de>,
9947 {
9948 while map_.next_key::<GeneratedField>()?.is_some() {
9949 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9950 }
9951 Ok(MembersRequest {
9952 })
9953 }
9954 }
9955 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
9956 }
9957}
9958impl serde::Serialize for MembersResponse {
9959 #[allow(deprecated)]
9960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9961 where
9962 S: serde::Serializer,
9963 {
9964 use serde::ser::SerializeStruct;
9965 let mut len = 0;
9966 if !self.members.is_empty() {
9967 len += 1;
9968 }
9969 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
9970 if !self.members.is_empty() {
9971 struct_ser.serialize_field("members", &self.members)?;
9972 }
9973 struct_ser.end()
9974 }
9975}
9976impl<'de> serde::Deserialize<'de> for MembersResponse {
9977 #[allow(deprecated)]
9978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9979 where
9980 D: serde::Deserializer<'de>,
9981 {
9982 const FIELDS: &[&str] = &[
9983 "members",
9984 ];
9985
9986 #[allow(clippy::enum_variant_names)]
9987 enum GeneratedField {
9988 Members,
9989 }
9990 impl<'de> serde::Deserialize<'de> for GeneratedField {
9991 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9992 where
9993 D: serde::Deserializer<'de>,
9994 {
9995 struct GeneratedVisitor;
9996
9997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9998 type Value = GeneratedField;
9999
10000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10001 write!(formatter, "expected one of: {:?}", &FIELDS)
10002 }
10003
10004 #[allow(unused_variables)]
10005 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10006 where
10007 E: serde::de::Error,
10008 {
10009 match value {
10010 "members" => Ok(GeneratedField::Members),
10011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10012 }
10013 }
10014 }
10015 deserializer.deserialize_identifier(GeneratedVisitor)
10016 }
10017 }
10018 struct GeneratedVisitor;
10019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10020 type Value = MembersResponse;
10021
10022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10023 formatter.write_str("struct meta.MembersResponse")
10024 }
10025
10026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
10027 where
10028 V: serde::de::MapAccess<'de>,
10029 {
10030 let mut members__ = None;
10031 while let Some(k) = map_.next_key()? {
10032 match k {
10033 GeneratedField::Members => {
10034 if members__.is_some() {
10035 return Err(serde::de::Error::duplicate_field("members"));
10036 }
10037 members__ = Some(map_.next_value()?);
10038 }
10039 }
10040 }
10041 Ok(MembersResponse {
10042 members: members__.unwrap_or_default(),
10043 })
10044 }
10045 }
10046 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
10047 }
10048}
10049impl serde::Serialize for MetaMember {
10050 #[allow(deprecated)]
10051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10052 where
10053 S: serde::Serializer,
10054 {
10055 use serde::ser::SerializeStruct;
10056 let mut len = 0;
10057 if self.address.is_some() {
10058 len += 1;
10059 }
10060 if self.is_leader {
10061 len += 1;
10062 }
10063 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
10064 if let Some(v) = self.address.as_ref() {
10065 struct_ser.serialize_field("address", v)?;
10066 }
10067 if self.is_leader {
10068 struct_ser.serialize_field("isLeader", &self.is_leader)?;
10069 }
10070 struct_ser.end()
10071 }
10072}
10073impl<'de> serde::Deserialize<'de> for MetaMember {
10074 #[allow(deprecated)]
10075 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10076 where
10077 D: serde::Deserializer<'de>,
10078 {
10079 const FIELDS: &[&str] = &[
10080 "address",
10081 "is_leader",
10082 "isLeader",
10083 ];
10084
10085 #[allow(clippy::enum_variant_names)]
10086 enum GeneratedField {
10087 Address,
10088 IsLeader,
10089 }
10090 impl<'de> serde::Deserialize<'de> for GeneratedField {
10091 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10092 where
10093 D: serde::Deserializer<'de>,
10094 {
10095 struct GeneratedVisitor;
10096
10097 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10098 type Value = GeneratedField;
10099
10100 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10101 write!(formatter, "expected one of: {:?}", &FIELDS)
10102 }
10103
10104 #[allow(unused_variables)]
10105 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10106 where
10107 E: serde::de::Error,
10108 {
10109 match value {
10110 "address" => Ok(GeneratedField::Address),
10111 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
10112 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10113 }
10114 }
10115 }
10116 deserializer.deserialize_identifier(GeneratedVisitor)
10117 }
10118 }
10119 struct GeneratedVisitor;
10120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10121 type Value = MetaMember;
10122
10123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10124 formatter.write_str("struct meta.MetaMember")
10125 }
10126
10127 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
10128 where
10129 V: serde::de::MapAccess<'de>,
10130 {
10131 let mut address__ = None;
10132 let mut is_leader__ = None;
10133 while let Some(k) = map_.next_key()? {
10134 match k {
10135 GeneratedField::Address => {
10136 if address__.is_some() {
10137 return Err(serde::de::Error::duplicate_field("address"));
10138 }
10139 address__ = map_.next_value()?;
10140 }
10141 GeneratedField::IsLeader => {
10142 if is_leader__.is_some() {
10143 return Err(serde::de::Error::duplicate_field("isLeader"));
10144 }
10145 is_leader__ = Some(map_.next_value()?);
10146 }
10147 }
10148 }
10149 Ok(MetaMember {
10150 address: address__,
10151 is_leader: is_leader__.unwrap_or_default(),
10152 })
10153 }
10154 }
10155 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
10156 }
10157}
10158impl serde::Serialize for MetaSnapshot {
10159 #[allow(deprecated)]
10160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10161 where
10162 S: serde::Serializer,
10163 {
10164 use serde::ser::SerializeStruct;
10165 let mut len = 0;
10166 if !self.databases.is_empty() {
10167 len += 1;
10168 }
10169 if !self.schemas.is_empty() {
10170 len += 1;
10171 }
10172 if !self.sources.is_empty() {
10173 len += 1;
10174 }
10175 if !self.sinks.is_empty() {
10176 len += 1;
10177 }
10178 if !self.tables.is_empty() {
10179 len += 1;
10180 }
10181 if !self.indexes.is_empty() {
10182 len += 1;
10183 }
10184 if !self.views.is_empty() {
10185 len += 1;
10186 }
10187 if !self.functions.is_empty() {
10188 len += 1;
10189 }
10190 if !self.connections.is_empty() {
10191 len += 1;
10192 }
10193 if !self.subscriptions.is_empty() {
10194 len += 1;
10195 }
10196 if !self.users.is_empty() {
10197 len += 1;
10198 }
10199 if self.session_params.is_some() {
10200 len += 1;
10201 }
10202 if !self.secrets.is_empty() {
10203 len += 1;
10204 }
10205 if self.compute_node_total_cpu_count != 0 {
10206 len += 1;
10207 }
10208 if !self.nodes.is_empty() {
10209 len += 1;
10210 }
10211 if self.hummock_version.is_some() {
10212 len += 1;
10213 }
10214 if self.meta_backup_manifest_id.is_some() {
10215 len += 1;
10216 }
10217 if self.hummock_write_limits.is_some() {
10218 len += 1;
10219 }
10220 if !self.streaming_worker_slot_mappings.is_empty() {
10221 len += 1;
10222 }
10223 if !self.serving_worker_slot_mappings.is_empty() {
10224 len += 1;
10225 }
10226 if self.version.is_some() {
10227 len += 1;
10228 }
10229 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
10230 if !self.databases.is_empty() {
10231 struct_ser.serialize_field("databases", &self.databases)?;
10232 }
10233 if !self.schemas.is_empty() {
10234 struct_ser.serialize_field("schemas", &self.schemas)?;
10235 }
10236 if !self.sources.is_empty() {
10237 struct_ser.serialize_field("sources", &self.sources)?;
10238 }
10239 if !self.sinks.is_empty() {
10240 struct_ser.serialize_field("sinks", &self.sinks)?;
10241 }
10242 if !self.tables.is_empty() {
10243 struct_ser.serialize_field("tables", &self.tables)?;
10244 }
10245 if !self.indexes.is_empty() {
10246 struct_ser.serialize_field("indexes", &self.indexes)?;
10247 }
10248 if !self.views.is_empty() {
10249 struct_ser.serialize_field("views", &self.views)?;
10250 }
10251 if !self.functions.is_empty() {
10252 struct_ser.serialize_field("functions", &self.functions)?;
10253 }
10254 if !self.connections.is_empty() {
10255 struct_ser.serialize_field("connections", &self.connections)?;
10256 }
10257 if !self.subscriptions.is_empty() {
10258 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
10259 }
10260 if !self.users.is_empty() {
10261 struct_ser.serialize_field("users", &self.users)?;
10262 }
10263 if let Some(v) = self.session_params.as_ref() {
10264 struct_ser.serialize_field("sessionParams", v)?;
10265 }
10266 if !self.secrets.is_empty() {
10267 struct_ser.serialize_field("secrets", &self.secrets)?;
10268 }
10269 if self.compute_node_total_cpu_count != 0 {
10270 #[allow(clippy::needless_borrow)]
10271 #[allow(clippy::needless_borrows_for_generic_args)]
10272 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
10273 }
10274 if !self.nodes.is_empty() {
10275 struct_ser.serialize_field("nodes", &self.nodes)?;
10276 }
10277 if let Some(v) = self.hummock_version.as_ref() {
10278 struct_ser.serialize_field("hummockVersion", v)?;
10279 }
10280 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
10281 struct_ser.serialize_field("metaBackupManifestId", v)?;
10282 }
10283 if let Some(v) = self.hummock_write_limits.as_ref() {
10284 struct_ser.serialize_field("hummockWriteLimits", v)?;
10285 }
10286 if !self.streaming_worker_slot_mappings.is_empty() {
10287 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
10288 }
10289 if !self.serving_worker_slot_mappings.is_empty() {
10290 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
10291 }
10292 if let Some(v) = self.version.as_ref() {
10293 struct_ser.serialize_field("version", v)?;
10294 }
10295 struct_ser.end()
10296 }
10297}
10298impl<'de> serde::Deserialize<'de> for MetaSnapshot {
10299 #[allow(deprecated)]
10300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10301 where
10302 D: serde::Deserializer<'de>,
10303 {
10304 const FIELDS: &[&str] = &[
10305 "databases",
10306 "schemas",
10307 "sources",
10308 "sinks",
10309 "tables",
10310 "indexes",
10311 "views",
10312 "functions",
10313 "connections",
10314 "subscriptions",
10315 "users",
10316 "session_params",
10317 "sessionParams",
10318 "secrets",
10319 "compute_node_total_cpu_count",
10320 "computeNodeTotalCpuCount",
10321 "nodes",
10322 "hummock_version",
10323 "hummockVersion",
10324 "meta_backup_manifest_id",
10325 "metaBackupManifestId",
10326 "hummock_write_limits",
10327 "hummockWriteLimits",
10328 "streaming_worker_slot_mappings",
10329 "streamingWorkerSlotMappings",
10330 "serving_worker_slot_mappings",
10331 "servingWorkerSlotMappings",
10332 "version",
10333 ];
10334
10335 #[allow(clippy::enum_variant_names)]
10336 enum GeneratedField {
10337 Databases,
10338 Schemas,
10339 Sources,
10340 Sinks,
10341 Tables,
10342 Indexes,
10343 Views,
10344 Functions,
10345 Connections,
10346 Subscriptions,
10347 Users,
10348 SessionParams,
10349 Secrets,
10350 ComputeNodeTotalCpuCount,
10351 Nodes,
10352 HummockVersion,
10353 MetaBackupManifestId,
10354 HummockWriteLimits,
10355 StreamingWorkerSlotMappings,
10356 ServingWorkerSlotMappings,
10357 Version,
10358 }
10359 impl<'de> serde::Deserialize<'de> for GeneratedField {
10360 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10361 where
10362 D: serde::Deserializer<'de>,
10363 {
10364 struct GeneratedVisitor;
10365
10366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10367 type Value = GeneratedField;
10368
10369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10370 write!(formatter, "expected one of: {:?}", &FIELDS)
10371 }
10372
10373 #[allow(unused_variables)]
10374 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10375 where
10376 E: serde::de::Error,
10377 {
10378 match value {
10379 "databases" => Ok(GeneratedField::Databases),
10380 "schemas" => Ok(GeneratedField::Schemas),
10381 "sources" => Ok(GeneratedField::Sources),
10382 "sinks" => Ok(GeneratedField::Sinks),
10383 "tables" => Ok(GeneratedField::Tables),
10384 "indexes" => Ok(GeneratedField::Indexes),
10385 "views" => Ok(GeneratedField::Views),
10386 "functions" => Ok(GeneratedField::Functions),
10387 "connections" => Ok(GeneratedField::Connections),
10388 "subscriptions" => Ok(GeneratedField::Subscriptions),
10389 "users" => Ok(GeneratedField::Users),
10390 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
10391 "secrets" => Ok(GeneratedField::Secrets),
10392 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
10393 "nodes" => Ok(GeneratedField::Nodes),
10394 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
10395 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
10396 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
10397 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
10398 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
10399 "version" => Ok(GeneratedField::Version),
10400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10401 }
10402 }
10403 }
10404 deserializer.deserialize_identifier(GeneratedVisitor)
10405 }
10406 }
10407 struct GeneratedVisitor;
10408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10409 type Value = MetaSnapshot;
10410
10411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10412 formatter.write_str("struct meta.MetaSnapshot")
10413 }
10414
10415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
10416 where
10417 V: serde::de::MapAccess<'de>,
10418 {
10419 let mut databases__ = None;
10420 let mut schemas__ = None;
10421 let mut sources__ = None;
10422 let mut sinks__ = None;
10423 let mut tables__ = None;
10424 let mut indexes__ = None;
10425 let mut views__ = None;
10426 let mut functions__ = None;
10427 let mut connections__ = None;
10428 let mut subscriptions__ = None;
10429 let mut users__ = None;
10430 let mut session_params__ = None;
10431 let mut secrets__ = None;
10432 let mut compute_node_total_cpu_count__ = None;
10433 let mut nodes__ = None;
10434 let mut hummock_version__ = None;
10435 let mut meta_backup_manifest_id__ = None;
10436 let mut hummock_write_limits__ = None;
10437 let mut streaming_worker_slot_mappings__ = None;
10438 let mut serving_worker_slot_mappings__ = None;
10439 let mut version__ = None;
10440 while let Some(k) = map_.next_key()? {
10441 match k {
10442 GeneratedField::Databases => {
10443 if databases__.is_some() {
10444 return Err(serde::de::Error::duplicate_field("databases"));
10445 }
10446 databases__ = Some(map_.next_value()?);
10447 }
10448 GeneratedField::Schemas => {
10449 if schemas__.is_some() {
10450 return Err(serde::de::Error::duplicate_field("schemas"));
10451 }
10452 schemas__ = Some(map_.next_value()?);
10453 }
10454 GeneratedField::Sources => {
10455 if sources__.is_some() {
10456 return Err(serde::de::Error::duplicate_field("sources"));
10457 }
10458 sources__ = Some(map_.next_value()?);
10459 }
10460 GeneratedField::Sinks => {
10461 if sinks__.is_some() {
10462 return Err(serde::de::Error::duplicate_field("sinks"));
10463 }
10464 sinks__ = Some(map_.next_value()?);
10465 }
10466 GeneratedField::Tables => {
10467 if tables__.is_some() {
10468 return Err(serde::de::Error::duplicate_field("tables"));
10469 }
10470 tables__ = Some(map_.next_value()?);
10471 }
10472 GeneratedField::Indexes => {
10473 if indexes__.is_some() {
10474 return Err(serde::de::Error::duplicate_field("indexes"));
10475 }
10476 indexes__ = Some(map_.next_value()?);
10477 }
10478 GeneratedField::Views => {
10479 if views__.is_some() {
10480 return Err(serde::de::Error::duplicate_field("views"));
10481 }
10482 views__ = Some(map_.next_value()?);
10483 }
10484 GeneratedField::Functions => {
10485 if functions__.is_some() {
10486 return Err(serde::de::Error::duplicate_field("functions"));
10487 }
10488 functions__ = Some(map_.next_value()?);
10489 }
10490 GeneratedField::Connections => {
10491 if connections__.is_some() {
10492 return Err(serde::de::Error::duplicate_field("connections"));
10493 }
10494 connections__ = Some(map_.next_value()?);
10495 }
10496 GeneratedField::Subscriptions => {
10497 if subscriptions__.is_some() {
10498 return Err(serde::de::Error::duplicate_field("subscriptions"));
10499 }
10500 subscriptions__ = Some(map_.next_value()?);
10501 }
10502 GeneratedField::Users => {
10503 if users__.is_some() {
10504 return Err(serde::de::Error::duplicate_field("users"));
10505 }
10506 users__ = Some(map_.next_value()?);
10507 }
10508 GeneratedField::SessionParams => {
10509 if session_params__.is_some() {
10510 return Err(serde::de::Error::duplicate_field("sessionParams"));
10511 }
10512 session_params__ = map_.next_value()?;
10513 }
10514 GeneratedField::Secrets => {
10515 if secrets__.is_some() {
10516 return Err(serde::de::Error::duplicate_field("secrets"));
10517 }
10518 secrets__ = Some(map_.next_value()?);
10519 }
10520 GeneratedField::ComputeNodeTotalCpuCount => {
10521 if compute_node_total_cpu_count__.is_some() {
10522 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
10523 }
10524 compute_node_total_cpu_count__ =
10525 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10526 ;
10527 }
10528 GeneratedField::Nodes => {
10529 if nodes__.is_some() {
10530 return Err(serde::de::Error::duplicate_field("nodes"));
10531 }
10532 nodes__ = Some(map_.next_value()?);
10533 }
10534 GeneratedField::HummockVersion => {
10535 if hummock_version__.is_some() {
10536 return Err(serde::de::Error::duplicate_field("hummockVersion"));
10537 }
10538 hummock_version__ = map_.next_value()?;
10539 }
10540 GeneratedField::MetaBackupManifestId => {
10541 if meta_backup_manifest_id__.is_some() {
10542 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
10543 }
10544 meta_backup_manifest_id__ = map_.next_value()?;
10545 }
10546 GeneratedField::HummockWriteLimits => {
10547 if hummock_write_limits__.is_some() {
10548 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
10549 }
10550 hummock_write_limits__ = map_.next_value()?;
10551 }
10552 GeneratedField::StreamingWorkerSlotMappings => {
10553 if streaming_worker_slot_mappings__.is_some() {
10554 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
10555 }
10556 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
10557 }
10558 GeneratedField::ServingWorkerSlotMappings => {
10559 if serving_worker_slot_mappings__.is_some() {
10560 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
10561 }
10562 serving_worker_slot_mappings__ = Some(map_.next_value()?);
10563 }
10564 GeneratedField::Version => {
10565 if version__.is_some() {
10566 return Err(serde::de::Error::duplicate_field("version"));
10567 }
10568 version__ = map_.next_value()?;
10569 }
10570 }
10571 }
10572 Ok(MetaSnapshot {
10573 databases: databases__.unwrap_or_default(),
10574 schemas: schemas__.unwrap_or_default(),
10575 sources: sources__.unwrap_or_default(),
10576 sinks: sinks__.unwrap_or_default(),
10577 tables: tables__.unwrap_or_default(),
10578 indexes: indexes__.unwrap_or_default(),
10579 views: views__.unwrap_or_default(),
10580 functions: functions__.unwrap_or_default(),
10581 connections: connections__.unwrap_or_default(),
10582 subscriptions: subscriptions__.unwrap_or_default(),
10583 users: users__.unwrap_or_default(),
10584 session_params: session_params__,
10585 secrets: secrets__.unwrap_or_default(),
10586 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
10587 nodes: nodes__.unwrap_or_default(),
10588 hummock_version: hummock_version__,
10589 meta_backup_manifest_id: meta_backup_manifest_id__,
10590 hummock_write_limits: hummock_write_limits__,
10591 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
10592 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
10593 version: version__,
10594 })
10595 }
10596 }
10597 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
10598 }
10599}
10600impl serde::Serialize for meta_snapshot::SnapshotVersion {
10601 #[allow(deprecated)]
10602 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10603 where
10604 S: serde::Serializer,
10605 {
10606 use serde::ser::SerializeStruct;
10607 let mut len = 0;
10608 if self.catalog_version != 0 {
10609 len += 1;
10610 }
10611 if self.worker_node_version != 0 {
10612 len += 1;
10613 }
10614 if self.streaming_worker_slot_mapping_version != 0 {
10615 len += 1;
10616 }
10617 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
10618 if self.catalog_version != 0 {
10619 #[allow(clippy::needless_borrow)]
10620 #[allow(clippy::needless_borrows_for_generic_args)]
10621 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
10622 }
10623 if self.worker_node_version != 0 {
10624 #[allow(clippy::needless_borrow)]
10625 #[allow(clippy::needless_borrows_for_generic_args)]
10626 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
10627 }
10628 if self.streaming_worker_slot_mapping_version != 0 {
10629 #[allow(clippy::needless_borrow)]
10630 #[allow(clippy::needless_borrows_for_generic_args)]
10631 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
10632 }
10633 struct_ser.end()
10634 }
10635}
10636impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
10637 #[allow(deprecated)]
10638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10639 where
10640 D: serde::Deserializer<'de>,
10641 {
10642 const FIELDS: &[&str] = &[
10643 "catalog_version",
10644 "catalogVersion",
10645 "worker_node_version",
10646 "workerNodeVersion",
10647 "streaming_worker_slot_mapping_version",
10648 "streamingWorkerSlotMappingVersion",
10649 ];
10650
10651 #[allow(clippy::enum_variant_names)]
10652 enum GeneratedField {
10653 CatalogVersion,
10654 WorkerNodeVersion,
10655 StreamingWorkerSlotMappingVersion,
10656 }
10657 impl<'de> serde::Deserialize<'de> for GeneratedField {
10658 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10659 where
10660 D: serde::Deserializer<'de>,
10661 {
10662 struct GeneratedVisitor;
10663
10664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10665 type Value = GeneratedField;
10666
10667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10668 write!(formatter, "expected one of: {:?}", &FIELDS)
10669 }
10670
10671 #[allow(unused_variables)]
10672 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10673 where
10674 E: serde::de::Error,
10675 {
10676 match value {
10677 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
10678 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
10679 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
10680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10681 }
10682 }
10683 }
10684 deserializer.deserialize_identifier(GeneratedVisitor)
10685 }
10686 }
10687 struct GeneratedVisitor;
10688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10689 type Value = meta_snapshot::SnapshotVersion;
10690
10691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10692 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
10693 }
10694
10695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
10696 where
10697 V: serde::de::MapAccess<'de>,
10698 {
10699 let mut catalog_version__ = None;
10700 let mut worker_node_version__ = None;
10701 let mut streaming_worker_slot_mapping_version__ = None;
10702 while let Some(k) = map_.next_key()? {
10703 match k {
10704 GeneratedField::CatalogVersion => {
10705 if catalog_version__.is_some() {
10706 return Err(serde::de::Error::duplicate_field("catalogVersion"));
10707 }
10708 catalog_version__ =
10709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10710 ;
10711 }
10712 GeneratedField::WorkerNodeVersion => {
10713 if worker_node_version__.is_some() {
10714 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
10715 }
10716 worker_node_version__ =
10717 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10718 ;
10719 }
10720 GeneratedField::StreamingWorkerSlotMappingVersion => {
10721 if streaming_worker_slot_mapping_version__.is_some() {
10722 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
10723 }
10724 streaming_worker_slot_mapping_version__ =
10725 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10726 ;
10727 }
10728 }
10729 }
10730 Ok(meta_snapshot::SnapshotVersion {
10731 catalog_version: catalog_version__.unwrap_or_default(),
10732 worker_node_version: worker_node_version__.unwrap_or_default(),
10733 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
10734 })
10735 }
10736 }
10737 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
10738 }
10739}
10740impl serde::Serialize for MigrationPlan {
10741 #[allow(deprecated)]
10742 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10743 where
10744 S: serde::Serializer,
10745 {
10746 use serde::ser::SerializeStruct;
10747 let mut len = 0;
10748 if !self.worker_slot_migration_plan.is_empty() {
10749 len += 1;
10750 }
10751 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
10752 if !self.worker_slot_migration_plan.is_empty() {
10753 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
10754 .map(|(k, v)| (k, v.to_string())).collect();
10755 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
10756 }
10757 struct_ser.end()
10758 }
10759}
10760impl<'de> serde::Deserialize<'de> for MigrationPlan {
10761 #[allow(deprecated)]
10762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10763 where
10764 D: serde::Deserializer<'de>,
10765 {
10766 const FIELDS: &[&str] = &[
10767 "worker_slot_migration_plan",
10768 "workerSlotMigrationPlan",
10769 ];
10770
10771 #[allow(clippy::enum_variant_names)]
10772 enum GeneratedField {
10773 WorkerSlotMigrationPlan,
10774 }
10775 impl<'de> serde::Deserialize<'de> for GeneratedField {
10776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10777 where
10778 D: serde::Deserializer<'de>,
10779 {
10780 struct GeneratedVisitor;
10781
10782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10783 type Value = GeneratedField;
10784
10785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10786 write!(formatter, "expected one of: {:?}", &FIELDS)
10787 }
10788
10789 #[allow(unused_variables)]
10790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10791 where
10792 E: serde::de::Error,
10793 {
10794 match value {
10795 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
10796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10797 }
10798 }
10799 }
10800 deserializer.deserialize_identifier(GeneratedVisitor)
10801 }
10802 }
10803 struct GeneratedVisitor;
10804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10805 type Value = MigrationPlan;
10806
10807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10808 formatter.write_str("struct meta.MigrationPlan")
10809 }
10810
10811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
10812 where
10813 V: serde::de::MapAccess<'de>,
10814 {
10815 let mut worker_slot_migration_plan__ = None;
10816 while let Some(k) = map_.next_key()? {
10817 match k {
10818 GeneratedField::WorkerSlotMigrationPlan => {
10819 if worker_slot_migration_plan__.is_some() {
10820 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
10821 }
10822 worker_slot_migration_plan__ = Some(
10823 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
10824 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
10825 );
10826 }
10827 }
10828 }
10829 Ok(MigrationPlan {
10830 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
10831 })
10832 }
10833 }
10834 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
10835 }
10836}
10837impl serde::Serialize for Object {
10838 #[allow(deprecated)]
10839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10840 where
10841 S: serde::Serializer,
10842 {
10843 use serde::ser::SerializeStruct;
10844 let mut len = 0;
10845 if self.object_info.is_some() {
10846 len += 1;
10847 }
10848 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
10849 if let Some(v) = self.object_info.as_ref() {
10850 match v {
10851 object::ObjectInfo::Database(v) => {
10852 struct_ser.serialize_field("database", v)?;
10853 }
10854 object::ObjectInfo::Schema(v) => {
10855 struct_ser.serialize_field("schema", v)?;
10856 }
10857 object::ObjectInfo::Table(v) => {
10858 struct_ser.serialize_field("table", v)?;
10859 }
10860 object::ObjectInfo::Index(v) => {
10861 struct_ser.serialize_field("index", v)?;
10862 }
10863 object::ObjectInfo::Source(v) => {
10864 struct_ser.serialize_field("source", v)?;
10865 }
10866 object::ObjectInfo::Sink(v) => {
10867 struct_ser.serialize_field("sink", v)?;
10868 }
10869 object::ObjectInfo::View(v) => {
10870 struct_ser.serialize_field("view", v)?;
10871 }
10872 object::ObjectInfo::Function(v) => {
10873 struct_ser.serialize_field("function", v)?;
10874 }
10875 object::ObjectInfo::Connection(v) => {
10876 struct_ser.serialize_field("connection", v)?;
10877 }
10878 object::ObjectInfo::Subscription(v) => {
10879 struct_ser.serialize_field("subscription", v)?;
10880 }
10881 object::ObjectInfo::Secret(v) => {
10882 struct_ser.serialize_field("secret", v)?;
10883 }
10884 }
10885 }
10886 struct_ser.end()
10887 }
10888}
10889impl<'de> serde::Deserialize<'de> for Object {
10890 #[allow(deprecated)]
10891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10892 where
10893 D: serde::Deserializer<'de>,
10894 {
10895 const FIELDS: &[&str] = &[
10896 "database",
10897 "schema",
10898 "table",
10899 "index",
10900 "source",
10901 "sink",
10902 "view",
10903 "function",
10904 "connection",
10905 "subscription",
10906 "secret",
10907 ];
10908
10909 #[allow(clippy::enum_variant_names)]
10910 enum GeneratedField {
10911 Database,
10912 Schema,
10913 Table,
10914 Index,
10915 Source,
10916 Sink,
10917 View,
10918 Function,
10919 Connection,
10920 Subscription,
10921 Secret,
10922 }
10923 impl<'de> serde::Deserialize<'de> for GeneratedField {
10924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10925 where
10926 D: serde::Deserializer<'de>,
10927 {
10928 struct GeneratedVisitor;
10929
10930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10931 type Value = GeneratedField;
10932
10933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10934 write!(formatter, "expected one of: {:?}", &FIELDS)
10935 }
10936
10937 #[allow(unused_variables)]
10938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10939 where
10940 E: serde::de::Error,
10941 {
10942 match value {
10943 "database" => Ok(GeneratedField::Database),
10944 "schema" => Ok(GeneratedField::Schema),
10945 "table" => Ok(GeneratedField::Table),
10946 "index" => Ok(GeneratedField::Index),
10947 "source" => Ok(GeneratedField::Source),
10948 "sink" => Ok(GeneratedField::Sink),
10949 "view" => Ok(GeneratedField::View),
10950 "function" => Ok(GeneratedField::Function),
10951 "connection" => Ok(GeneratedField::Connection),
10952 "subscription" => Ok(GeneratedField::Subscription),
10953 "secret" => Ok(GeneratedField::Secret),
10954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10955 }
10956 }
10957 }
10958 deserializer.deserialize_identifier(GeneratedVisitor)
10959 }
10960 }
10961 struct GeneratedVisitor;
10962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10963 type Value = Object;
10964
10965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10966 formatter.write_str("struct meta.Object")
10967 }
10968
10969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
10970 where
10971 V: serde::de::MapAccess<'de>,
10972 {
10973 let mut object_info__ = None;
10974 while let Some(k) = map_.next_key()? {
10975 match k {
10976 GeneratedField::Database => {
10977 if object_info__.is_some() {
10978 return Err(serde::de::Error::duplicate_field("database"));
10979 }
10980 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
10981;
10982 }
10983 GeneratedField::Schema => {
10984 if object_info__.is_some() {
10985 return Err(serde::de::Error::duplicate_field("schema"));
10986 }
10987 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
10988;
10989 }
10990 GeneratedField::Table => {
10991 if object_info__.is_some() {
10992 return Err(serde::de::Error::duplicate_field("table"));
10993 }
10994 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
10995;
10996 }
10997 GeneratedField::Index => {
10998 if object_info__.is_some() {
10999 return Err(serde::de::Error::duplicate_field("index"));
11000 }
11001 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
11002;
11003 }
11004 GeneratedField::Source => {
11005 if object_info__.is_some() {
11006 return Err(serde::de::Error::duplicate_field("source"));
11007 }
11008 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
11009;
11010 }
11011 GeneratedField::Sink => {
11012 if object_info__.is_some() {
11013 return Err(serde::de::Error::duplicate_field("sink"));
11014 }
11015 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
11016;
11017 }
11018 GeneratedField::View => {
11019 if object_info__.is_some() {
11020 return Err(serde::de::Error::duplicate_field("view"));
11021 }
11022 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
11023;
11024 }
11025 GeneratedField::Function => {
11026 if object_info__.is_some() {
11027 return Err(serde::de::Error::duplicate_field("function"));
11028 }
11029 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
11030;
11031 }
11032 GeneratedField::Connection => {
11033 if object_info__.is_some() {
11034 return Err(serde::de::Error::duplicate_field("connection"));
11035 }
11036 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
11037;
11038 }
11039 GeneratedField::Subscription => {
11040 if object_info__.is_some() {
11041 return Err(serde::de::Error::duplicate_field("subscription"));
11042 }
11043 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
11044;
11045 }
11046 GeneratedField::Secret => {
11047 if object_info__.is_some() {
11048 return Err(serde::de::Error::duplicate_field("secret"));
11049 }
11050 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
11051;
11052 }
11053 }
11054 }
11055 Ok(Object {
11056 object_info: object_info__,
11057 })
11058 }
11059 }
11060 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
11061 }
11062}
11063impl serde::Serialize for ObjectGroup {
11064 #[allow(deprecated)]
11065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11066 where
11067 S: serde::Serializer,
11068 {
11069 use serde::ser::SerializeStruct;
11070 let mut len = 0;
11071 if !self.objects.is_empty() {
11072 len += 1;
11073 }
11074 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
11075 if !self.objects.is_empty() {
11076 struct_ser.serialize_field("objects", &self.objects)?;
11077 }
11078 struct_ser.end()
11079 }
11080}
11081impl<'de> serde::Deserialize<'de> for ObjectGroup {
11082 #[allow(deprecated)]
11083 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11084 where
11085 D: serde::Deserializer<'de>,
11086 {
11087 const FIELDS: &[&str] = &[
11088 "objects",
11089 ];
11090
11091 #[allow(clippy::enum_variant_names)]
11092 enum GeneratedField {
11093 Objects,
11094 }
11095 impl<'de> serde::Deserialize<'de> for GeneratedField {
11096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11097 where
11098 D: serde::Deserializer<'de>,
11099 {
11100 struct GeneratedVisitor;
11101
11102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11103 type Value = GeneratedField;
11104
11105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11106 write!(formatter, "expected one of: {:?}", &FIELDS)
11107 }
11108
11109 #[allow(unused_variables)]
11110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11111 where
11112 E: serde::de::Error,
11113 {
11114 match value {
11115 "objects" => Ok(GeneratedField::Objects),
11116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11117 }
11118 }
11119 }
11120 deserializer.deserialize_identifier(GeneratedVisitor)
11121 }
11122 }
11123 struct GeneratedVisitor;
11124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11125 type Value = ObjectGroup;
11126
11127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11128 formatter.write_str("struct meta.ObjectGroup")
11129 }
11130
11131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
11132 where
11133 V: serde::de::MapAccess<'de>,
11134 {
11135 let mut objects__ = None;
11136 while let Some(k) = map_.next_key()? {
11137 match k {
11138 GeneratedField::Objects => {
11139 if objects__.is_some() {
11140 return Err(serde::de::Error::duplicate_field("objects"));
11141 }
11142 objects__ = Some(map_.next_value()?);
11143 }
11144 }
11145 }
11146 Ok(ObjectGroup {
11147 objects: objects__.unwrap_or_default(),
11148 })
11149 }
11150 }
11151 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
11152 }
11153}
11154impl serde::Serialize for PauseRequest {
11155 #[allow(deprecated)]
11156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11157 where
11158 S: serde::Serializer,
11159 {
11160 use serde::ser::SerializeStruct;
11161 let len = 0;
11162 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
11163 struct_ser.end()
11164 }
11165}
11166impl<'de> serde::Deserialize<'de> for PauseRequest {
11167 #[allow(deprecated)]
11168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11169 where
11170 D: serde::Deserializer<'de>,
11171 {
11172 const FIELDS: &[&str] = &[
11173 ];
11174
11175 #[allow(clippy::enum_variant_names)]
11176 enum GeneratedField {
11177 }
11178 impl<'de> serde::Deserialize<'de> for GeneratedField {
11179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11180 where
11181 D: serde::Deserializer<'de>,
11182 {
11183 struct GeneratedVisitor;
11184
11185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11186 type Value = GeneratedField;
11187
11188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11189 write!(formatter, "expected one of: {:?}", &FIELDS)
11190 }
11191
11192 #[allow(unused_variables)]
11193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11194 where
11195 E: serde::de::Error,
11196 {
11197 Err(serde::de::Error::unknown_field(value, FIELDS))
11198 }
11199 }
11200 deserializer.deserialize_identifier(GeneratedVisitor)
11201 }
11202 }
11203 struct GeneratedVisitor;
11204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11205 type Value = PauseRequest;
11206
11207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11208 formatter.write_str("struct meta.PauseRequest")
11209 }
11210
11211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
11212 where
11213 V: serde::de::MapAccess<'de>,
11214 {
11215 while map_.next_key::<GeneratedField>()?.is_some() {
11216 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11217 }
11218 Ok(PauseRequest {
11219 })
11220 }
11221 }
11222 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
11223 }
11224}
11225impl serde::Serialize for PauseResponse {
11226 #[allow(deprecated)]
11227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11228 where
11229 S: serde::Serializer,
11230 {
11231 use serde::ser::SerializeStruct;
11232 let len = 0;
11233 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
11234 struct_ser.end()
11235 }
11236}
11237impl<'de> serde::Deserialize<'de> for PauseResponse {
11238 #[allow(deprecated)]
11239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11240 where
11241 D: serde::Deserializer<'de>,
11242 {
11243 const FIELDS: &[&str] = &[
11244 ];
11245
11246 #[allow(clippy::enum_variant_names)]
11247 enum GeneratedField {
11248 }
11249 impl<'de> serde::Deserialize<'de> for GeneratedField {
11250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11251 where
11252 D: serde::Deserializer<'de>,
11253 {
11254 struct GeneratedVisitor;
11255
11256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11257 type Value = GeneratedField;
11258
11259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11260 write!(formatter, "expected one of: {:?}", &FIELDS)
11261 }
11262
11263 #[allow(unused_variables)]
11264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11265 where
11266 E: serde::de::Error,
11267 {
11268 Err(serde::de::Error::unknown_field(value, FIELDS))
11269 }
11270 }
11271 deserializer.deserialize_identifier(GeneratedVisitor)
11272 }
11273 }
11274 struct GeneratedVisitor;
11275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11276 type Value = PauseResponse;
11277
11278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11279 formatter.write_str("struct meta.PauseResponse")
11280 }
11281
11282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
11283 where
11284 V: serde::de::MapAccess<'de>,
11285 {
11286 while map_.next_key::<GeneratedField>()?.is_some() {
11287 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11288 }
11289 Ok(PauseResponse {
11290 })
11291 }
11292 }
11293 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
11294 }
11295}
11296impl serde::Serialize for RecoverRequest {
11297 #[allow(deprecated)]
11298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11299 where
11300 S: serde::Serializer,
11301 {
11302 use serde::ser::SerializeStruct;
11303 let len = 0;
11304 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
11305 struct_ser.end()
11306 }
11307}
11308impl<'de> serde::Deserialize<'de> for RecoverRequest {
11309 #[allow(deprecated)]
11310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11311 where
11312 D: serde::Deserializer<'de>,
11313 {
11314 const FIELDS: &[&str] = &[
11315 ];
11316
11317 #[allow(clippy::enum_variant_names)]
11318 enum GeneratedField {
11319 }
11320 impl<'de> serde::Deserialize<'de> for GeneratedField {
11321 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11322 where
11323 D: serde::Deserializer<'de>,
11324 {
11325 struct GeneratedVisitor;
11326
11327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11328 type Value = GeneratedField;
11329
11330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11331 write!(formatter, "expected one of: {:?}", &FIELDS)
11332 }
11333
11334 #[allow(unused_variables)]
11335 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11336 where
11337 E: serde::de::Error,
11338 {
11339 Err(serde::de::Error::unknown_field(value, FIELDS))
11340 }
11341 }
11342 deserializer.deserialize_identifier(GeneratedVisitor)
11343 }
11344 }
11345 struct GeneratedVisitor;
11346 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11347 type Value = RecoverRequest;
11348
11349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11350 formatter.write_str("struct meta.RecoverRequest")
11351 }
11352
11353 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
11354 where
11355 V: serde::de::MapAccess<'de>,
11356 {
11357 while map_.next_key::<GeneratedField>()?.is_some() {
11358 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11359 }
11360 Ok(RecoverRequest {
11361 })
11362 }
11363 }
11364 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
11365 }
11366}
11367impl serde::Serialize for RecoverResponse {
11368 #[allow(deprecated)]
11369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11370 where
11371 S: serde::Serializer,
11372 {
11373 use serde::ser::SerializeStruct;
11374 let len = 0;
11375 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
11376 struct_ser.end()
11377 }
11378}
11379impl<'de> serde::Deserialize<'de> for RecoverResponse {
11380 #[allow(deprecated)]
11381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11382 where
11383 D: serde::Deserializer<'de>,
11384 {
11385 const FIELDS: &[&str] = &[
11386 ];
11387
11388 #[allow(clippy::enum_variant_names)]
11389 enum GeneratedField {
11390 }
11391 impl<'de> serde::Deserialize<'de> for GeneratedField {
11392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11393 where
11394 D: serde::Deserializer<'de>,
11395 {
11396 struct GeneratedVisitor;
11397
11398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11399 type Value = GeneratedField;
11400
11401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11402 write!(formatter, "expected one of: {:?}", &FIELDS)
11403 }
11404
11405 #[allow(unused_variables)]
11406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11407 where
11408 E: serde::de::Error,
11409 {
11410 Err(serde::de::Error::unknown_field(value, FIELDS))
11411 }
11412 }
11413 deserializer.deserialize_identifier(GeneratedVisitor)
11414 }
11415 }
11416 struct GeneratedVisitor;
11417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11418 type Value = RecoverResponse;
11419
11420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11421 formatter.write_str("struct meta.RecoverResponse")
11422 }
11423
11424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
11425 where
11426 V: serde::de::MapAccess<'de>,
11427 {
11428 while map_.next_key::<GeneratedField>()?.is_some() {
11429 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11430 }
11431 Ok(RecoverResponse {
11432 })
11433 }
11434 }
11435 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
11436 }
11437}
11438impl serde::Serialize for Recovery {
11439 #[allow(deprecated)]
11440 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11441 where
11442 S: serde::Serializer,
11443 {
11444 use serde::ser::SerializeStruct;
11445 let len = 0;
11446 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
11447 struct_ser.end()
11448 }
11449}
11450impl<'de> serde::Deserialize<'de> for Recovery {
11451 #[allow(deprecated)]
11452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11453 where
11454 D: serde::Deserializer<'de>,
11455 {
11456 const FIELDS: &[&str] = &[
11457 ];
11458
11459 #[allow(clippy::enum_variant_names)]
11460 enum GeneratedField {
11461 }
11462 impl<'de> serde::Deserialize<'de> for GeneratedField {
11463 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11464 where
11465 D: serde::Deserializer<'de>,
11466 {
11467 struct GeneratedVisitor;
11468
11469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11470 type Value = GeneratedField;
11471
11472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11473 write!(formatter, "expected one of: {:?}", &FIELDS)
11474 }
11475
11476 #[allow(unused_variables)]
11477 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11478 where
11479 E: serde::de::Error,
11480 {
11481 Err(serde::de::Error::unknown_field(value, FIELDS))
11482 }
11483 }
11484 deserializer.deserialize_identifier(GeneratedVisitor)
11485 }
11486 }
11487 struct GeneratedVisitor;
11488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11489 type Value = Recovery;
11490
11491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11492 formatter.write_str("struct meta.Recovery")
11493 }
11494
11495 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
11496 where
11497 V: serde::de::MapAccess<'de>,
11498 {
11499 while map_.next_key::<GeneratedField>()?.is_some() {
11500 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11501 }
11502 Ok(Recovery {
11503 })
11504 }
11505 }
11506 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
11507 }
11508}
11509impl serde::Serialize for RecoveryStatus {
11510 #[allow(deprecated)]
11511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11512 where
11513 S: serde::Serializer,
11514 {
11515 let variant = match self {
11516 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
11517 Self::StatusStarting => "STATUS_STARTING",
11518 Self::StatusRecovering => "STATUS_RECOVERING",
11519 Self::StatusRunning => "STATUS_RUNNING",
11520 };
11521 serializer.serialize_str(variant)
11522 }
11523}
11524impl<'de> serde::Deserialize<'de> for RecoveryStatus {
11525 #[allow(deprecated)]
11526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11527 where
11528 D: serde::Deserializer<'de>,
11529 {
11530 const FIELDS: &[&str] = &[
11531 "STATUS_UNSPECIFIED",
11532 "STATUS_STARTING",
11533 "STATUS_RECOVERING",
11534 "STATUS_RUNNING",
11535 ];
11536
11537 struct GeneratedVisitor;
11538
11539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11540 type Value = RecoveryStatus;
11541
11542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11543 write!(formatter, "expected one of: {:?}", &FIELDS)
11544 }
11545
11546 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11547 where
11548 E: serde::de::Error,
11549 {
11550 i32::try_from(v)
11551 .ok()
11552 .and_then(|x| x.try_into().ok())
11553 .ok_or_else(|| {
11554 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11555 })
11556 }
11557
11558 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11559 where
11560 E: serde::de::Error,
11561 {
11562 i32::try_from(v)
11563 .ok()
11564 .and_then(|x| x.try_into().ok())
11565 .ok_or_else(|| {
11566 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11567 })
11568 }
11569
11570 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11571 where
11572 E: serde::de::Error,
11573 {
11574 match value {
11575 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
11576 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
11577 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
11578 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
11579 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11580 }
11581 }
11582 }
11583 deserializer.deserialize_any(GeneratedVisitor)
11584 }
11585}
11586impl serde::Serialize for RelationIdInfos {
11587 #[allow(deprecated)]
11588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11589 where
11590 S: serde::Serializer,
11591 {
11592 use serde::ser::SerializeStruct;
11593 let mut len = 0;
11594 if !self.map.is_empty() {
11595 len += 1;
11596 }
11597 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
11598 if !self.map.is_empty() {
11599 struct_ser.serialize_field("map", &self.map)?;
11600 }
11601 struct_ser.end()
11602 }
11603}
11604impl<'de> serde::Deserialize<'de> for RelationIdInfos {
11605 #[allow(deprecated)]
11606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11607 where
11608 D: serde::Deserializer<'de>,
11609 {
11610 const FIELDS: &[&str] = &[
11611 "map",
11612 ];
11613
11614 #[allow(clippy::enum_variant_names)]
11615 enum GeneratedField {
11616 Map,
11617 }
11618 impl<'de> serde::Deserialize<'de> for GeneratedField {
11619 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11620 where
11621 D: serde::Deserializer<'de>,
11622 {
11623 struct GeneratedVisitor;
11624
11625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11626 type Value = GeneratedField;
11627
11628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11629 write!(formatter, "expected one of: {:?}", &FIELDS)
11630 }
11631
11632 #[allow(unused_variables)]
11633 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11634 where
11635 E: serde::de::Error,
11636 {
11637 match value {
11638 "map" => Ok(GeneratedField::Map),
11639 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11640 }
11641 }
11642 }
11643 deserializer.deserialize_identifier(GeneratedVisitor)
11644 }
11645 }
11646 struct GeneratedVisitor;
11647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11648 type Value = RelationIdInfos;
11649
11650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11651 formatter.write_str("struct meta.RelationIdInfos")
11652 }
11653
11654 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
11655 where
11656 V: serde::de::MapAccess<'de>,
11657 {
11658 let mut map__ = None;
11659 while let Some(k) = map_.next_key()? {
11660 match k {
11661 GeneratedField::Map => {
11662 if map__.is_some() {
11663 return Err(serde::de::Error::duplicate_field("map"));
11664 }
11665 map__ = Some(
11666 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11667 .into_iter().map(|(k,v)| (k.0, v)).collect()
11668 );
11669 }
11670 }
11671 }
11672 Ok(RelationIdInfos {
11673 map: map__.unwrap_or_default(),
11674 })
11675 }
11676 }
11677 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
11678 }
11679}
11680impl serde::Serialize for RescheduleRequest {
11681 #[allow(deprecated)]
11682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11683 where
11684 S: serde::Serializer,
11685 {
11686 use serde::ser::SerializeStruct;
11687 let mut len = 0;
11688 if self.revision != 0 {
11689 len += 1;
11690 }
11691 if self.resolve_no_shuffle_upstream {
11692 len += 1;
11693 }
11694 if !self.worker_reschedules.is_empty() {
11695 len += 1;
11696 }
11697 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
11698 if self.revision != 0 {
11699 #[allow(clippy::needless_borrow)]
11700 #[allow(clippy::needless_borrows_for_generic_args)]
11701 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
11702 }
11703 if self.resolve_no_shuffle_upstream {
11704 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
11705 }
11706 if !self.worker_reschedules.is_empty() {
11707 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
11708 }
11709 struct_ser.end()
11710 }
11711}
11712impl<'de> serde::Deserialize<'de> for RescheduleRequest {
11713 #[allow(deprecated)]
11714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11715 where
11716 D: serde::Deserializer<'de>,
11717 {
11718 const FIELDS: &[&str] = &[
11719 "revision",
11720 "resolve_no_shuffle_upstream",
11721 "resolveNoShuffleUpstream",
11722 "worker_reschedules",
11723 "workerReschedules",
11724 ];
11725
11726 #[allow(clippy::enum_variant_names)]
11727 enum GeneratedField {
11728 Revision,
11729 ResolveNoShuffleUpstream,
11730 WorkerReschedules,
11731 }
11732 impl<'de> serde::Deserialize<'de> for GeneratedField {
11733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11734 where
11735 D: serde::Deserializer<'de>,
11736 {
11737 struct GeneratedVisitor;
11738
11739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11740 type Value = GeneratedField;
11741
11742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11743 write!(formatter, "expected one of: {:?}", &FIELDS)
11744 }
11745
11746 #[allow(unused_variables)]
11747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11748 where
11749 E: serde::de::Error,
11750 {
11751 match value {
11752 "revision" => Ok(GeneratedField::Revision),
11753 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
11754 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
11755 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11756 }
11757 }
11758 }
11759 deserializer.deserialize_identifier(GeneratedVisitor)
11760 }
11761 }
11762 struct GeneratedVisitor;
11763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11764 type Value = RescheduleRequest;
11765
11766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11767 formatter.write_str("struct meta.RescheduleRequest")
11768 }
11769
11770 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
11771 where
11772 V: serde::de::MapAccess<'de>,
11773 {
11774 let mut revision__ = None;
11775 let mut resolve_no_shuffle_upstream__ = None;
11776 let mut worker_reschedules__ = None;
11777 while let Some(k) = map_.next_key()? {
11778 match k {
11779 GeneratedField::Revision => {
11780 if revision__.is_some() {
11781 return Err(serde::de::Error::duplicate_field("revision"));
11782 }
11783 revision__ =
11784 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11785 ;
11786 }
11787 GeneratedField::ResolveNoShuffleUpstream => {
11788 if resolve_no_shuffle_upstream__.is_some() {
11789 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
11790 }
11791 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
11792 }
11793 GeneratedField::WorkerReschedules => {
11794 if worker_reschedules__.is_some() {
11795 return Err(serde::de::Error::duplicate_field("workerReschedules"));
11796 }
11797 worker_reschedules__ = Some(
11798 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11799 .into_iter().map(|(k,v)| (k.0, v)).collect()
11800 );
11801 }
11802 }
11803 }
11804 Ok(RescheduleRequest {
11805 revision: revision__.unwrap_or_default(),
11806 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
11807 worker_reschedules: worker_reschedules__.unwrap_or_default(),
11808 })
11809 }
11810 }
11811 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
11812 }
11813}
11814impl serde::Serialize for RescheduleResponse {
11815 #[allow(deprecated)]
11816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11817 where
11818 S: serde::Serializer,
11819 {
11820 use serde::ser::SerializeStruct;
11821 let mut len = 0;
11822 if self.success {
11823 len += 1;
11824 }
11825 if self.revision != 0 {
11826 len += 1;
11827 }
11828 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
11829 if self.success {
11830 struct_ser.serialize_field("success", &self.success)?;
11831 }
11832 if self.revision != 0 {
11833 #[allow(clippy::needless_borrow)]
11834 #[allow(clippy::needless_borrows_for_generic_args)]
11835 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
11836 }
11837 struct_ser.end()
11838 }
11839}
11840impl<'de> serde::Deserialize<'de> for RescheduleResponse {
11841 #[allow(deprecated)]
11842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11843 where
11844 D: serde::Deserializer<'de>,
11845 {
11846 const FIELDS: &[&str] = &[
11847 "success",
11848 "revision",
11849 ];
11850
11851 #[allow(clippy::enum_variant_names)]
11852 enum GeneratedField {
11853 Success,
11854 Revision,
11855 }
11856 impl<'de> serde::Deserialize<'de> for GeneratedField {
11857 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11858 where
11859 D: serde::Deserializer<'de>,
11860 {
11861 struct GeneratedVisitor;
11862
11863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11864 type Value = GeneratedField;
11865
11866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11867 write!(formatter, "expected one of: {:?}", &FIELDS)
11868 }
11869
11870 #[allow(unused_variables)]
11871 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11872 where
11873 E: serde::de::Error,
11874 {
11875 match value {
11876 "success" => Ok(GeneratedField::Success),
11877 "revision" => Ok(GeneratedField::Revision),
11878 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11879 }
11880 }
11881 }
11882 deserializer.deserialize_identifier(GeneratedVisitor)
11883 }
11884 }
11885 struct GeneratedVisitor;
11886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11887 type Value = RescheduleResponse;
11888
11889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11890 formatter.write_str("struct meta.RescheduleResponse")
11891 }
11892
11893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
11894 where
11895 V: serde::de::MapAccess<'de>,
11896 {
11897 let mut success__ = None;
11898 let mut revision__ = None;
11899 while let Some(k) = map_.next_key()? {
11900 match k {
11901 GeneratedField::Success => {
11902 if success__.is_some() {
11903 return Err(serde::de::Error::duplicate_field("success"));
11904 }
11905 success__ = Some(map_.next_value()?);
11906 }
11907 GeneratedField::Revision => {
11908 if revision__.is_some() {
11909 return Err(serde::de::Error::duplicate_field("revision"));
11910 }
11911 revision__ =
11912 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11913 ;
11914 }
11915 }
11916 }
11917 Ok(RescheduleResponse {
11918 success: success__.unwrap_or_default(),
11919 revision: revision__.unwrap_or_default(),
11920 })
11921 }
11922 }
11923 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
11924 }
11925}
11926impl serde::Serialize for ResumeRequest {
11927 #[allow(deprecated)]
11928 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11929 where
11930 S: serde::Serializer,
11931 {
11932 use serde::ser::SerializeStruct;
11933 let len = 0;
11934 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
11935 struct_ser.end()
11936 }
11937}
11938impl<'de> serde::Deserialize<'de> for ResumeRequest {
11939 #[allow(deprecated)]
11940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11941 where
11942 D: serde::Deserializer<'de>,
11943 {
11944 const FIELDS: &[&str] = &[
11945 ];
11946
11947 #[allow(clippy::enum_variant_names)]
11948 enum GeneratedField {
11949 }
11950 impl<'de> serde::Deserialize<'de> for GeneratedField {
11951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11952 where
11953 D: serde::Deserializer<'de>,
11954 {
11955 struct GeneratedVisitor;
11956
11957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11958 type Value = GeneratedField;
11959
11960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11961 write!(formatter, "expected one of: {:?}", &FIELDS)
11962 }
11963
11964 #[allow(unused_variables)]
11965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11966 where
11967 E: serde::de::Error,
11968 {
11969 Err(serde::de::Error::unknown_field(value, FIELDS))
11970 }
11971 }
11972 deserializer.deserialize_identifier(GeneratedVisitor)
11973 }
11974 }
11975 struct GeneratedVisitor;
11976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11977 type Value = ResumeRequest;
11978
11979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11980 formatter.write_str("struct meta.ResumeRequest")
11981 }
11982
11983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
11984 where
11985 V: serde::de::MapAccess<'de>,
11986 {
11987 while map_.next_key::<GeneratedField>()?.is_some() {
11988 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11989 }
11990 Ok(ResumeRequest {
11991 })
11992 }
11993 }
11994 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
11995 }
11996}
11997impl serde::Serialize for ResumeResponse {
11998 #[allow(deprecated)]
11999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12000 where
12001 S: serde::Serializer,
12002 {
12003 use serde::ser::SerializeStruct;
12004 let len = 0;
12005 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
12006 struct_ser.end()
12007 }
12008}
12009impl<'de> serde::Deserialize<'de> for ResumeResponse {
12010 #[allow(deprecated)]
12011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12012 where
12013 D: serde::Deserializer<'de>,
12014 {
12015 const FIELDS: &[&str] = &[
12016 ];
12017
12018 #[allow(clippy::enum_variant_names)]
12019 enum GeneratedField {
12020 }
12021 impl<'de> serde::Deserialize<'de> for GeneratedField {
12022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12023 where
12024 D: serde::Deserializer<'de>,
12025 {
12026 struct GeneratedVisitor;
12027
12028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12029 type Value = GeneratedField;
12030
12031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12032 write!(formatter, "expected one of: {:?}", &FIELDS)
12033 }
12034
12035 #[allow(unused_variables)]
12036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12037 where
12038 E: serde::de::Error,
12039 {
12040 Err(serde::de::Error::unknown_field(value, FIELDS))
12041 }
12042 }
12043 deserializer.deserialize_identifier(GeneratedVisitor)
12044 }
12045 }
12046 struct GeneratedVisitor;
12047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12048 type Value = ResumeResponse;
12049
12050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12051 formatter.write_str("struct meta.ResumeResponse")
12052 }
12053
12054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
12055 where
12056 V: serde::de::MapAccess<'de>,
12057 {
12058 while map_.next_key::<GeneratedField>()?.is_some() {
12059 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12060 }
12061 Ok(ResumeResponse {
12062 })
12063 }
12064 }
12065 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
12066 }
12067}
12068impl serde::Serialize for SetSessionParamRequest {
12069 #[allow(deprecated)]
12070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12071 where
12072 S: serde::Serializer,
12073 {
12074 use serde::ser::SerializeStruct;
12075 let mut len = 0;
12076 if !self.param.is_empty() {
12077 len += 1;
12078 }
12079 if self.value.is_some() {
12080 len += 1;
12081 }
12082 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
12083 if !self.param.is_empty() {
12084 struct_ser.serialize_field("param", &self.param)?;
12085 }
12086 if let Some(v) = self.value.as_ref() {
12087 struct_ser.serialize_field("value", v)?;
12088 }
12089 struct_ser.end()
12090 }
12091}
12092impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
12093 #[allow(deprecated)]
12094 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12095 where
12096 D: serde::Deserializer<'de>,
12097 {
12098 const FIELDS: &[&str] = &[
12099 "param",
12100 "value",
12101 ];
12102
12103 #[allow(clippy::enum_variant_names)]
12104 enum GeneratedField {
12105 Param,
12106 Value,
12107 }
12108 impl<'de> serde::Deserialize<'de> for GeneratedField {
12109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12110 where
12111 D: serde::Deserializer<'de>,
12112 {
12113 struct GeneratedVisitor;
12114
12115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12116 type Value = GeneratedField;
12117
12118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12119 write!(formatter, "expected one of: {:?}", &FIELDS)
12120 }
12121
12122 #[allow(unused_variables)]
12123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12124 where
12125 E: serde::de::Error,
12126 {
12127 match value {
12128 "param" => Ok(GeneratedField::Param),
12129 "value" => Ok(GeneratedField::Value),
12130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12131 }
12132 }
12133 }
12134 deserializer.deserialize_identifier(GeneratedVisitor)
12135 }
12136 }
12137 struct GeneratedVisitor;
12138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12139 type Value = SetSessionParamRequest;
12140
12141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12142 formatter.write_str("struct meta.SetSessionParamRequest")
12143 }
12144
12145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
12146 where
12147 V: serde::de::MapAccess<'de>,
12148 {
12149 let mut param__ = None;
12150 let mut value__ = None;
12151 while let Some(k) = map_.next_key()? {
12152 match k {
12153 GeneratedField::Param => {
12154 if param__.is_some() {
12155 return Err(serde::de::Error::duplicate_field("param"));
12156 }
12157 param__ = Some(map_.next_value()?);
12158 }
12159 GeneratedField::Value => {
12160 if value__.is_some() {
12161 return Err(serde::de::Error::duplicate_field("value"));
12162 }
12163 value__ = map_.next_value()?;
12164 }
12165 }
12166 }
12167 Ok(SetSessionParamRequest {
12168 param: param__.unwrap_or_default(),
12169 value: value__,
12170 })
12171 }
12172 }
12173 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
12174 }
12175}
12176impl serde::Serialize for SetSessionParamResponse {
12177 #[allow(deprecated)]
12178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12179 where
12180 S: serde::Serializer,
12181 {
12182 use serde::ser::SerializeStruct;
12183 let mut len = 0;
12184 if !self.param.is_empty() {
12185 len += 1;
12186 }
12187 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
12188 if !self.param.is_empty() {
12189 struct_ser.serialize_field("param", &self.param)?;
12190 }
12191 struct_ser.end()
12192 }
12193}
12194impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
12195 #[allow(deprecated)]
12196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12197 where
12198 D: serde::Deserializer<'de>,
12199 {
12200 const FIELDS: &[&str] = &[
12201 "param",
12202 ];
12203
12204 #[allow(clippy::enum_variant_names)]
12205 enum GeneratedField {
12206 Param,
12207 }
12208 impl<'de> serde::Deserialize<'de> for GeneratedField {
12209 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12210 where
12211 D: serde::Deserializer<'de>,
12212 {
12213 struct GeneratedVisitor;
12214
12215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12216 type Value = GeneratedField;
12217
12218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12219 write!(formatter, "expected one of: {:?}", &FIELDS)
12220 }
12221
12222 #[allow(unused_variables)]
12223 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12224 where
12225 E: serde::de::Error,
12226 {
12227 match value {
12228 "param" => Ok(GeneratedField::Param),
12229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12230 }
12231 }
12232 }
12233 deserializer.deserialize_identifier(GeneratedVisitor)
12234 }
12235 }
12236 struct GeneratedVisitor;
12237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12238 type Value = SetSessionParamResponse;
12239
12240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12241 formatter.write_str("struct meta.SetSessionParamResponse")
12242 }
12243
12244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
12245 where
12246 V: serde::de::MapAccess<'de>,
12247 {
12248 let mut param__ = None;
12249 while let Some(k) = map_.next_key()? {
12250 match k {
12251 GeneratedField::Param => {
12252 if param__.is_some() {
12253 return Err(serde::de::Error::duplicate_field("param"));
12254 }
12255 param__ = Some(map_.next_value()?);
12256 }
12257 }
12258 }
12259 Ok(SetSessionParamResponse {
12260 param: param__.unwrap_or_default(),
12261 })
12262 }
12263 }
12264 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
12265 }
12266}
12267impl serde::Serialize for SetSystemParamRequest {
12268 #[allow(deprecated)]
12269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12270 where
12271 S: serde::Serializer,
12272 {
12273 use serde::ser::SerializeStruct;
12274 let mut len = 0;
12275 if !self.param.is_empty() {
12276 len += 1;
12277 }
12278 if self.value.is_some() {
12279 len += 1;
12280 }
12281 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
12282 if !self.param.is_empty() {
12283 struct_ser.serialize_field("param", &self.param)?;
12284 }
12285 if let Some(v) = self.value.as_ref() {
12286 struct_ser.serialize_field("value", v)?;
12287 }
12288 struct_ser.end()
12289 }
12290}
12291impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
12292 #[allow(deprecated)]
12293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12294 where
12295 D: serde::Deserializer<'de>,
12296 {
12297 const FIELDS: &[&str] = &[
12298 "param",
12299 "value",
12300 ];
12301
12302 #[allow(clippy::enum_variant_names)]
12303 enum GeneratedField {
12304 Param,
12305 Value,
12306 }
12307 impl<'de> serde::Deserialize<'de> for GeneratedField {
12308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12309 where
12310 D: serde::Deserializer<'de>,
12311 {
12312 struct GeneratedVisitor;
12313
12314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12315 type Value = GeneratedField;
12316
12317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12318 write!(formatter, "expected one of: {:?}", &FIELDS)
12319 }
12320
12321 #[allow(unused_variables)]
12322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12323 where
12324 E: serde::de::Error,
12325 {
12326 match value {
12327 "param" => Ok(GeneratedField::Param),
12328 "value" => Ok(GeneratedField::Value),
12329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12330 }
12331 }
12332 }
12333 deserializer.deserialize_identifier(GeneratedVisitor)
12334 }
12335 }
12336 struct GeneratedVisitor;
12337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12338 type Value = SetSystemParamRequest;
12339
12340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12341 formatter.write_str("struct meta.SetSystemParamRequest")
12342 }
12343
12344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
12345 where
12346 V: serde::de::MapAccess<'de>,
12347 {
12348 let mut param__ = None;
12349 let mut value__ = None;
12350 while let Some(k) = map_.next_key()? {
12351 match k {
12352 GeneratedField::Param => {
12353 if param__.is_some() {
12354 return Err(serde::de::Error::duplicate_field("param"));
12355 }
12356 param__ = Some(map_.next_value()?);
12357 }
12358 GeneratedField::Value => {
12359 if value__.is_some() {
12360 return Err(serde::de::Error::duplicate_field("value"));
12361 }
12362 value__ = map_.next_value()?;
12363 }
12364 }
12365 }
12366 Ok(SetSystemParamRequest {
12367 param: param__.unwrap_or_default(),
12368 value: value__,
12369 })
12370 }
12371 }
12372 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
12373 }
12374}
12375impl serde::Serialize for SetSystemParamResponse {
12376 #[allow(deprecated)]
12377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12378 where
12379 S: serde::Serializer,
12380 {
12381 use serde::ser::SerializeStruct;
12382 let mut len = 0;
12383 if self.params.is_some() {
12384 len += 1;
12385 }
12386 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
12387 if let Some(v) = self.params.as_ref() {
12388 struct_ser.serialize_field("params", v)?;
12389 }
12390 struct_ser.end()
12391 }
12392}
12393impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
12394 #[allow(deprecated)]
12395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12396 where
12397 D: serde::Deserializer<'de>,
12398 {
12399 const FIELDS: &[&str] = &[
12400 "params",
12401 ];
12402
12403 #[allow(clippy::enum_variant_names)]
12404 enum GeneratedField {
12405 Params,
12406 }
12407 impl<'de> serde::Deserialize<'de> for GeneratedField {
12408 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12409 where
12410 D: serde::Deserializer<'de>,
12411 {
12412 struct GeneratedVisitor;
12413
12414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12415 type Value = GeneratedField;
12416
12417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12418 write!(formatter, "expected one of: {:?}", &FIELDS)
12419 }
12420
12421 #[allow(unused_variables)]
12422 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12423 where
12424 E: serde::de::Error,
12425 {
12426 match value {
12427 "params" => Ok(GeneratedField::Params),
12428 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12429 }
12430 }
12431 }
12432 deserializer.deserialize_identifier(GeneratedVisitor)
12433 }
12434 }
12435 struct GeneratedVisitor;
12436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12437 type Value = SetSystemParamResponse;
12438
12439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12440 formatter.write_str("struct meta.SetSystemParamResponse")
12441 }
12442
12443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
12444 where
12445 V: serde::de::MapAccess<'de>,
12446 {
12447 let mut params__ = None;
12448 while let Some(k) = map_.next_key()? {
12449 match k {
12450 GeneratedField::Params => {
12451 if params__.is_some() {
12452 return Err(serde::de::Error::duplicate_field("params"));
12453 }
12454 params__ = map_.next_value()?;
12455 }
12456 }
12457 }
12458 Ok(SetSystemParamResponse {
12459 params: params__,
12460 })
12461 }
12462 }
12463 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
12464 }
12465}
12466impl serde::Serialize for SubscribeRequest {
12467 #[allow(deprecated)]
12468 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12469 where
12470 S: serde::Serializer,
12471 {
12472 use serde::ser::SerializeStruct;
12473 let mut len = 0;
12474 if self.subscribe_type != 0 {
12475 len += 1;
12476 }
12477 if self.host.is_some() {
12478 len += 1;
12479 }
12480 if self.worker_id != 0 {
12481 len += 1;
12482 }
12483 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
12484 if self.subscribe_type != 0 {
12485 let v = SubscribeType::try_from(self.subscribe_type)
12486 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
12487 struct_ser.serialize_field("subscribeType", &v)?;
12488 }
12489 if let Some(v) = self.host.as_ref() {
12490 struct_ser.serialize_field("host", v)?;
12491 }
12492 if self.worker_id != 0 {
12493 struct_ser.serialize_field("workerId", &self.worker_id)?;
12494 }
12495 struct_ser.end()
12496 }
12497}
12498impl<'de> serde::Deserialize<'de> for SubscribeRequest {
12499 #[allow(deprecated)]
12500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12501 where
12502 D: serde::Deserializer<'de>,
12503 {
12504 const FIELDS: &[&str] = &[
12505 "subscribe_type",
12506 "subscribeType",
12507 "host",
12508 "worker_id",
12509 "workerId",
12510 ];
12511
12512 #[allow(clippy::enum_variant_names)]
12513 enum GeneratedField {
12514 SubscribeType,
12515 Host,
12516 WorkerId,
12517 }
12518 impl<'de> serde::Deserialize<'de> for GeneratedField {
12519 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12520 where
12521 D: serde::Deserializer<'de>,
12522 {
12523 struct GeneratedVisitor;
12524
12525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12526 type Value = GeneratedField;
12527
12528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12529 write!(formatter, "expected one of: {:?}", &FIELDS)
12530 }
12531
12532 #[allow(unused_variables)]
12533 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12534 where
12535 E: serde::de::Error,
12536 {
12537 match value {
12538 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
12539 "host" => Ok(GeneratedField::Host),
12540 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
12541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12542 }
12543 }
12544 }
12545 deserializer.deserialize_identifier(GeneratedVisitor)
12546 }
12547 }
12548 struct GeneratedVisitor;
12549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12550 type Value = SubscribeRequest;
12551
12552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12553 formatter.write_str("struct meta.SubscribeRequest")
12554 }
12555
12556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
12557 where
12558 V: serde::de::MapAccess<'de>,
12559 {
12560 let mut subscribe_type__ = None;
12561 let mut host__ = None;
12562 let mut worker_id__ = None;
12563 while let Some(k) = map_.next_key()? {
12564 match k {
12565 GeneratedField::SubscribeType => {
12566 if subscribe_type__.is_some() {
12567 return Err(serde::de::Error::duplicate_field("subscribeType"));
12568 }
12569 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
12570 }
12571 GeneratedField::Host => {
12572 if host__.is_some() {
12573 return Err(serde::de::Error::duplicate_field("host"));
12574 }
12575 host__ = map_.next_value()?;
12576 }
12577 GeneratedField::WorkerId => {
12578 if worker_id__.is_some() {
12579 return Err(serde::de::Error::duplicate_field("workerId"));
12580 }
12581 worker_id__ =
12582 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12583 ;
12584 }
12585 }
12586 }
12587 Ok(SubscribeRequest {
12588 subscribe_type: subscribe_type__.unwrap_or_default(),
12589 host: host__,
12590 worker_id: worker_id__.unwrap_or_default(),
12591 })
12592 }
12593 }
12594 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
12595 }
12596}
12597impl serde::Serialize for SubscribeResponse {
12598 #[allow(deprecated)]
12599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12600 where
12601 S: serde::Serializer,
12602 {
12603 use serde::ser::SerializeStruct;
12604 let mut len = 0;
12605 if self.status.is_some() {
12606 len += 1;
12607 }
12608 if self.operation != 0 {
12609 len += 1;
12610 }
12611 if self.version != 0 {
12612 len += 1;
12613 }
12614 if self.info.is_some() {
12615 len += 1;
12616 }
12617 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
12618 if let Some(v) = self.status.as_ref() {
12619 struct_ser.serialize_field("status", v)?;
12620 }
12621 if self.operation != 0 {
12622 let v = subscribe_response::Operation::try_from(self.operation)
12623 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
12624 struct_ser.serialize_field("operation", &v)?;
12625 }
12626 if self.version != 0 {
12627 #[allow(clippy::needless_borrow)]
12628 #[allow(clippy::needless_borrows_for_generic_args)]
12629 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
12630 }
12631 if let Some(v) = self.info.as_ref() {
12632 match v {
12633 subscribe_response::Info::Database(v) => {
12634 struct_ser.serialize_field("database", v)?;
12635 }
12636 subscribe_response::Info::Schema(v) => {
12637 struct_ser.serialize_field("schema", v)?;
12638 }
12639 subscribe_response::Info::Function(v) => {
12640 struct_ser.serialize_field("function", v)?;
12641 }
12642 subscribe_response::Info::User(v) => {
12643 struct_ser.serialize_field("user", v)?;
12644 }
12645 subscribe_response::Info::SessionParam(v) => {
12646 struct_ser.serialize_field("sessionParam", v)?;
12647 }
12648 subscribe_response::Info::Node(v) => {
12649 struct_ser.serialize_field("node", v)?;
12650 }
12651 subscribe_response::Info::HummockVersionDeltas(v) => {
12652 struct_ser.serialize_field("hummockVersionDeltas", v)?;
12653 }
12654 subscribe_response::Info::Snapshot(v) => {
12655 struct_ser.serialize_field("snapshot", v)?;
12656 }
12657 subscribe_response::Info::MetaBackupManifestId(v) => {
12658 struct_ser.serialize_field("metaBackupManifestId", v)?;
12659 }
12660 subscribe_response::Info::SystemParams(v) => {
12661 struct_ser.serialize_field("systemParams", v)?;
12662 }
12663 subscribe_response::Info::HummockWriteLimits(v) => {
12664 struct_ser.serialize_field("hummockWriteLimits", v)?;
12665 }
12666 subscribe_response::Info::ObjectGroup(v) => {
12667 struct_ser.serialize_field("objectGroup", v)?;
12668 }
12669 subscribe_response::Info::Connection(v) => {
12670 struct_ser.serialize_field("connection", v)?;
12671 }
12672 subscribe_response::Info::HummockStats(v) => {
12673 struct_ser.serialize_field("hummockStats", v)?;
12674 }
12675 subscribe_response::Info::Recovery(v) => {
12676 struct_ser.serialize_field("recovery", v)?;
12677 }
12678 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
12679 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
12680 }
12681 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
12682 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
12683 }
12684 subscribe_response::Info::Secret(v) => {
12685 struct_ser.serialize_field("secret", v)?;
12686 }
12687 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
12688 #[allow(clippy::needless_borrow)]
12689 #[allow(clippy::needless_borrows_for_generic_args)]
12690 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
12691 }
12692 }
12693 }
12694 struct_ser.end()
12695 }
12696}
12697impl<'de> serde::Deserialize<'de> for SubscribeResponse {
12698 #[allow(deprecated)]
12699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12700 where
12701 D: serde::Deserializer<'de>,
12702 {
12703 const FIELDS: &[&str] = &[
12704 "status",
12705 "operation",
12706 "version",
12707 "database",
12708 "schema",
12709 "function",
12710 "user",
12711 "session_param",
12712 "sessionParam",
12713 "node",
12714 "hummock_version_deltas",
12715 "hummockVersionDeltas",
12716 "snapshot",
12717 "meta_backup_manifest_id",
12718 "metaBackupManifestId",
12719 "system_params",
12720 "systemParams",
12721 "hummock_write_limits",
12722 "hummockWriteLimits",
12723 "object_group",
12724 "objectGroup",
12725 "connection",
12726 "hummock_stats",
12727 "hummockStats",
12728 "recovery",
12729 "streaming_worker_slot_mapping",
12730 "streamingWorkerSlotMapping",
12731 "serving_worker_slot_mappings",
12732 "servingWorkerSlotMappings",
12733 "secret",
12734 "compute_node_total_cpu_count",
12735 "computeNodeTotalCpuCount",
12736 ];
12737
12738 #[allow(clippy::enum_variant_names)]
12739 enum GeneratedField {
12740 Status,
12741 Operation,
12742 Version,
12743 Database,
12744 Schema,
12745 Function,
12746 User,
12747 SessionParam,
12748 Node,
12749 HummockVersionDeltas,
12750 Snapshot,
12751 MetaBackupManifestId,
12752 SystemParams,
12753 HummockWriteLimits,
12754 ObjectGroup,
12755 Connection,
12756 HummockStats,
12757 Recovery,
12758 StreamingWorkerSlotMapping,
12759 ServingWorkerSlotMappings,
12760 Secret,
12761 ComputeNodeTotalCpuCount,
12762 }
12763 impl<'de> serde::Deserialize<'de> for GeneratedField {
12764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12765 where
12766 D: serde::Deserializer<'de>,
12767 {
12768 struct GeneratedVisitor;
12769
12770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12771 type Value = GeneratedField;
12772
12773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12774 write!(formatter, "expected one of: {:?}", &FIELDS)
12775 }
12776
12777 #[allow(unused_variables)]
12778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12779 where
12780 E: serde::de::Error,
12781 {
12782 match value {
12783 "status" => Ok(GeneratedField::Status),
12784 "operation" => Ok(GeneratedField::Operation),
12785 "version" => Ok(GeneratedField::Version),
12786 "database" => Ok(GeneratedField::Database),
12787 "schema" => Ok(GeneratedField::Schema),
12788 "function" => Ok(GeneratedField::Function),
12789 "user" => Ok(GeneratedField::User),
12790 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
12791 "node" => Ok(GeneratedField::Node),
12792 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
12793 "snapshot" => Ok(GeneratedField::Snapshot),
12794 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
12795 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
12796 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
12797 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
12798 "connection" => Ok(GeneratedField::Connection),
12799 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
12800 "recovery" => Ok(GeneratedField::Recovery),
12801 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
12802 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
12803 "secret" => Ok(GeneratedField::Secret),
12804 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
12805 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12806 }
12807 }
12808 }
12809 deserializer.deserialize_identifier(GeneratedVisitor)
12810 }
12811 }
12812 struct GeneratedVisitor;
12813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12814 type Value = SubscribeResponse;
12815
12816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12817 formatter.write_str("struct meta.SubscribeResponse")
12818 }
12819
12820 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
12821 where
12822 V: serde::de::MapAccess<'de>,
12823 {
12824 let mut status__ = None;
12825 let mut operation__ = None;
12826 let mut version__ = None;
12827 let mut info__ = None;
12828 while let Some(k) = map_.next_key()? {
12829 match k {
12830 GeneratedField::Status => {
12831 if status__.is_some() {
12832 return Err(serde::de::Error::duplicate_field("status"));
12833 }
12834 status__ = map_.next_value()?;
12835 }
12836 GeneratedField::Operation => {
12837 if operation__.is_some() {
12838 return Err(serde::de::Error::duplicate_field("operation"));
12839 }
12840 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
12841 }
12842 GeneratedField::Version => {
12843 if version__.is_some() {
12844 return Err(serde::de::Error::duplicate_field("version"));
12845 }
12846 version__ =
12847 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12848 ;
12849 }
12850 GeneratedField::Database => {
12851 if info__.is_some() {
12852 return Err(serde::de::Error::duplicate_field("database"));
12853 }
12854 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
12855;
12856 }
12857 GeneratedField::Schema => {
12858 if info__.is_some() {
12859 return Err(serde::de::Error::duplicate_field("schema"));
12860 }
12861 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
12862;
12863 }
12864 GeneratedField::Function => {
12865 if info__.is_some() {
12866 return Err(serde::de::Error::duplicate_field("function"));
12867 }
12868 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
12869;
12870 }
12871 GeneratedField::User => {
12872 if info__.is_some() {
12873 return Err(serde::de::Error::duplicate_field("user"));
12874 }
12875 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
12876;
12877 }
12878 GeneratedField::SessionParam => {
12879 if info__.is_some() {
12880 return Err(serde::de::Error::duplicate_field("sessionParam"));
12881 }
12882 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
12883;
12884 }
12885 GeneratedField::Node => {
12886 if info__.is_some() {
12887 return Err(serde::de::Error::duplicate_field("node"));
12888 }
12889 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
12890;
12891 }
12892 GeneratedField::HummockVersionDeltas => {
12893 if info__.is_some() {
12894 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
12895 }
12896 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
12897;
12898 }
12899 GeneratedField::Snapshot => {
12900 if info__.is_some() {
12901 return Err(serde::de::Error::duplicate_field("snapshot"));
12902 }
12903 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
12904;
12905 }
12906 GeneratedField::MetaBackupManifestId => {
12907 if info__.is_some() {
12908 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
12909 }
12910 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
12911;
12912 }
12913 GeneratedField::SystemParams => {
12914 if info__.is_some() {
12915 return Err(serde::de::Error::duplicate_field("systemParams"));
12916 }
12917 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
12918;
12919 }
12920 GeneratedField::HummockWriteLimits => {
12921 if info__.is_some() {
12922 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
12923 }
12924 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
12925;
12926 }
12927 GeneratedField::ObjectGroup => {
12928 if info__.is_some() {
12929 return Err(serde::de::Error::duplicate_field("objectGroup"));
12930 }
12931 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
12932;
12933 }
12934 GeneratedField::Connection => {
12935 if info__.is_some() {
12936 return Err(serde::de::Error::duplicate_field("connection"));
12937 }
12938 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
12939;
12940 }
12941 GeneratedField::HummockStats => {
12942 if info__.is_some() {
12943 return Err(serde::de::Error::duplicate_field("hummockStats"));
12944 }
12945 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
12946;
12947 }
12948 GeneratedField::Recovery => {
12949 if info__.is_some() {
12950 return Err(serde::de::Error::duplicate_field("recovery"));
12951 }
12952 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
12953;
12954 }
12955 GeneratedField::StreamingWorkerSlotMapping => {
12956 if info__.is_some() {
12957 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
12958 }
12959 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
12960;
12961 }
12962 GeneratedField::ServingWorkerSlotMappings => {
12963 if info__.is_some() {
12964 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
12965 }
12966 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
12967;
12968 }
12969 GeneratedField::Secret => {
12970 if info__.is_some() {
12971 return Err(serde::de::Error::duplicate_field("secret"));
12972 }
12973 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
12974;
12975 }
12976 GeneratedField::ComputeNodeTotalCpuCount => {
12977 if info__.is_some() {
12978 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
12979 }
12980 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
12981 }
12982 }
12983 }
12984 Ok(SubscribeResponse {
12985 status: status__,
12986 operation: operation__.unwrap_or_default(),
12987 version: version__.unwrap_or_default(),
12988 info: info__,
12989 })
12990 }
12991 }
12992 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
12993 }
12994}
12995impl serde::Serialize for subscribe_response::Operation {
12996 #[allow(deprecated)]
12997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12998 where
12999 S: serde::Serializer,
13000 {
13001 let variant = match self {
13002 Self::Unspecified => "UNSPECIFIED",
13003 Self::Add => "ADD",
13004 Self::Delete => "DELETE",
13005 Self::Update => "UPDATE",
13006 Self::Snapshot => "SNAPSHOT",
13007 };
13008 serializer.serialize_str(variant)
13009 }
13010}
13011impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
13012 #[allow(deprecated)]
13013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13014 where
13015 D: serde::Deserializer<'de>,
13016 {
13017 const FIELDS: &[&str] = &[
13018 "UNSPECIFIED",
13019 "ADD",
13020 "DELETE",
13021 "UPDATE",
13022 "SNAPSHOT",
13023 ];
13024
13025 struct GeneratedVisitor;
13026
13027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13028 type Value = subscribe_response::Operation;
13029
13030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13031 write!(formatter, "expected one of: {:?}", &FIELDS)
13032 }
13033
13034 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13035 where
13036 E: serde::de::Error,
13037 {
13038 i32::try_from(v)
13039 .ok()
13040 .and_then(|x| x.try_into().ok())
13041 .ok_or_else(|| {
13042 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13043 })
13044 }
13045
13046 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13047 where
13048 E: serde::de::Error,
13049 {
13050 i32::try_from(v)
13051 .ok()
13052 .and_then(|x| x.try_into().ok())
13053 .ok_or_else(|| {
13054 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13055 })
13056 }
13057
13058 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13059 where
13060 E: serde::de::Error,
13061 {
13062 match value {
13063 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
13064 "ADD" => Ok(subscribe_response::Operation::Add),
13065 "DELETE" => Ok(subscribe_response::Operation::Delete),
13066 "UPDATE" => Ok(subscribe_response::Operation::Update),
13067 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
13068 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13069 }
13070 }
13071 }
13072 deserializer.deserialize_any(GeneratedVisitor)
13073 }
13074}
13075impl serde::Serialize for SubscribeType {
13076 #[allow(deprecated)]
13077 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13078 where
13079 S: serde::Serializer,
13080 {
13081 let variant = match self {
13082 Self::Unspecified => "UNSPECIFIED",
13083 Self::Frontend => "FRONTEND",
13084 Self::Hummock => "HUMMOCK",
13085 Self::Compactor => "COMPACTOR",
13086 Self::Compute => "COMPUTE",
13087 };
13088 serializer.serialize_str(variant)
13089 }
13090}
13091impl<'de> serde::Deserialize<'de> for SubscribeType {
13092 #[allow(deprecated)]
13093 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13094 where
13095 D: serde::Deserializer<'de>,
13096 {
13097 const FIELDS: &[&str] = &[
13098 "UNSPECIFIED",
13099 "FRONTEND",
13100 "HUMMOCK",
13101 "COMPACTOR",
13102 "COMPUTE",
13103 ];
13104
13105 struct GeneratedVisitor;
13106
13107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13108 type Value = SubscribeType;
13109
13110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13111 write!(formatter, "expected one of: {:?}", &FIELDS)
13112 }
13113
13114 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13115 where
13116 E: serde::de::Error,
13117 {
13118 i32::try_from(v)
13119 .ok()
13120 .and_then(|x| x.try_into().ok())
13121 .ok_or_else(|| {
13122 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13123 })
13124 }
13125
13126 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13127 where
13128 E: serde::de::Error,
13129 {
13130 i32::try_from(v)
13131 .ok()
13132 .and_then(|x| x.try_into().ok())
13133 .ok_or_else(|| {
13134 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13135 })
13136 }
13137
13138 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13139 where
13140 E: serde::de::Error,
13141 {
13142 match value {
13143 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
13144 "FRONTEND" => Ok(SubscribeType::Frontend),
13145 "HUMMOCK" => Ok(SubscribeType::Hummock),
13146 "COMPACTOR" => Ok(SubscribeType::Compactor),
13147 "COMPUTE" => Ok(SubscribeType::Compute),
13148 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13149 }
13150 }
13151 }
13152 deserializer.deserialize_any(GeneratedVisitor)
13153 }
13154}
13155impl serde::Serialize for SystemParams {
13156 #[allow(deprecated)]
13157 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13158 where
13159 S: serde::Serializer,
13160 {
13161 use serde::ser::SerializeStruct;
13162 let mut len = 0;
13163 if self.barrier_interval_ms.is_some() {
13164 len += 1;
13165 }
13166 if self.checkpoint_frequency.is_some() {
13167 len += 1;
13168 }
13169 if self.sstable_size_mb.is_some() {
13170 len += 1;
13171 }
13172 if self.block_size_kb.is_some() {
13173 len += 1;
13174 }
13175 if self.bloom_false_positive.is_some() {
13176 len += 1;
13177 }
13178 if self.state_store.is_some() {
13179 len += 1;
13180 }
13181 if self.data_directory.is_some() {
13182 len += 1;
13183 }
13184 if self.backup_storage_url.is_some() {
13185 len += 1;
13186 }
13187 if self.backup_storage_directory.is_some() {
13188 len += 1;
13189 }
13190 if self.telemetry_enabled.is_some() {
13191 len += 1;
13192 }
13193 if self.parallel_compact_size_mb.is_some() {
13194 len += 1;
13195 }
13196 if self.max_concurrent_creating_streaming_jobs.is_some() {
13197 len += 1;
13198 }
13199 if self.pause_on_next_bootstrap.is_some() {
13200 len += 1;
13201 }
13202 if self.wasm_storage_url.is_some() {
13203 len += 1;
13204 }
13205 if self.enable_tracing.is_some() {
13206 len += 1;
13207 }
13208 if self.use_new_object_prefix_strategy.is_some() {
13209 len += 1;
13210 }
13211 if self.license_key.is_some() {
13212 len += 1;
13213 }
13214 if self.time_travel_retention_ms.is_some() {
13215 len += 1;
13216 }
13217 if self.adaptive_parallelism_strategy.is_some() {
13218 len += 1;
13219 }
13220 if self.per_database_isolation.is_some() {
13221 len += 1;
13222 }
13223 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
13224 if let Some(v) = self.barrier_interval_ms.as_ref() {
13225 struct_ser.serialize_field("barrierIntervalMs", v)?;
13226 }
13227 if let Some(v) = self.checkpoint_frequency.as_ref() {
13228 #[allow(clippy::needless_borrow)]
13229 #[allow(clippy::needless_borrows_for_generic_args)]
13230 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
13231 }
13232 if let Some(v) = self.sstable_size_mb.as_ref() {
13233 struct_ser.serialize_field("sstableSizeMb", v)?;
13234 }
13235 if let Some(v) = self.block_size_kb.as_ref() {
13236 struct_ser.serialize_field("blockSizeKb", v)?;
13237 }
13238 if let Some(v) = self.bloom_false_positive.as_ref() {
13239 struct_ser.serialize_field("bloomFalsePositive", v)?;
13240 }
13241 if let Some(v) = self.state_store.as_ref() {
13242 struct_ser.serialize_field("stateStore", v)?;
13243 }
13244 if let Some(v) = self.data_directory.as_ref() {
13245 struct_ser.serialize_field("dataDirectory", v)?;
13246 }
13247 if let Some(v) = self.backup_storage_url.as_ref() {
13248 struct_ser.serialize_field("backupStorageUrl", v)?;
13249 }
13250 if let Some(v) = self.backup_storage_directory.as_ref() {
13251 struct_ser.serialize_field("backupStorageDirectory", v)?;
13252 }
13253 if let Some(v) = self.telemetry_enabled.as_ref() {
13254 struct_ser.serialize_field("telemetryEnabled", v)?;
13255 }
13256 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
13257 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
13258 }
13259 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
13260 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
13261 }
13262 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
13263 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
13264 }
13265 if let Some(v) = self.wasm_storage_url.as_ref() {
13266 struct_ser.serialize_field("wasmStorageUrl", v)?;
13267 }
13268 if let Some(v) = self.enable_tracing.as_ref() {
13269 struct_ser.serialize_field("enableTracing", v)?;
13270 }
13271 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
13272 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
13273 }
13274 if let Some(v) = self.license_key.as_ref() {
13275 struct_ser.serialize_field("licenseKey", v)?;
13276 }
13277 if let Some(v) = self.time_travel_retention_ms.as_ref() {
13278 #[allow(clippy::needless_borrow)]
13279 #[allow(clippy::needless_borrows_for_generic_args)]
13280 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
13281 }
13282 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
13283 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
13284 }
13285 if let Some(v) = self.per_database_isolation.as_ref() {
13286 struct_ser.serialize_field("perDatabaseIsolation", v)?;
13287 }
13288 struct_ser.end()
13289 }
13290}
13291impl<'de> serde::Deserialize<'de> for SystemParams {
13292 #[allow(deprecated)]
13293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13294 where
13295 D: serde::Deserializer<'de>,
13296 {
13297 const FIELDS: &[&str] = &[
13298 "barrier_interval_ms",
13299 "barrierIntervalMs",
13300 "checkpoint_frequency",
13301 "checkpointFrequency",
13302 "sstable_size_mb",
13303 "sstableSizeMb",
13304 "block_size_kb",
13305 "blockSizeKb",
13306 "bloom_false_positive",
13307 "bloomFalsePositive",
13308 "state_store",
13309 "stateStore",
13310 "data_directory",
13311 "dataDirectory",
13312 "backup_storage_url",
13313 "backupStorageUrl",
13314 "backup_storage_directory",
13315 "backupStorageDirectory",
13316 "telemetry_enabled",
13317 "telemetryEnabled",
13318 "parallel_compact_size_mb",
13319 "parallelCompactSizeMb",
13320 "max_concurrent_creating_streaming_jobs",
13321 "maxConcurrentCreatingStreamingJobs",
13322 "pause_on_next_bootstrap",
13323 "pauseOnNextBootstrap",
13324 "wasm_storage_url",
13325 "wasmStorageUrl",
13326 "enable_tracing",
13327 "enableTracing",
13328 "use_new_object_prefix_strategy",
13329 "useNewObjectPrefixStrategy",
13330 "license_key",
13331 "licenseKey",
13332 "time_travel_retention_ms",
13333 "timeTravelRetentionMs",
13334 "adaptive_parallelism_strategy",
13335 "adaptiveParallelismStrategy",
13336 "per_database_isolation",
13337 "perDatabaseIsolation",
13338 ];
13339
13340 #[allow(clippy::enum_variant_names)]
13341 enum GeneratedField {
13342 BarrierIntervalMs,
13343 CheckpointFrequency,
13344 SstableSizeMb,
13345 BlockSizeKb,
13346 BloomFalsePositive,
13347 StateStore,
13348 DataDirectory,
13349 BackupStorageUrl,
13350 BackupStorageDirectory,
13351 TelemetryEnabled,
13352 ParallelCompactSizeMb,
13353 MaxConcurrentCreatingStreamingJobs,
13354 PauseOnNextBootstrap,
13355 WasmStorageUrl,
13356 EnableTracing,
13357 UseNewObjectPrefixStrategy,
13358 LicenseKey,
13359 TimeTravelRetentionMs,
13360 AdaptiveParallelismStrategy,
13361 PerDatabaseIsolation,
13362 }
13363 impl<'de> serde::Deserialize<'de> for GeneratedField {
13364 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13365 where
13366 D: serde::Deserializer<'de>,
13367 {
13368 struct GeneratedVisitor;
13369
13370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13371 type Value = GeneratedField;
13372
13373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13374 write!(formatter, "expected one of: {:?}", &FIELDS)
13375 }
13376
13377 #[allow(unused_variables)]
13378 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13379 where
13380 E: serde::de::Error,
13381 {
13382 match value {
13383 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
13384 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
13385 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
13386 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
13387 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
13388 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
13389 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
13390 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
13391 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
13392 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
13393 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
13394 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
13395 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
13396 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
13397 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
13398 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
13399 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
13400 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
13401 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
13402 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
13403 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13404 }
13405 }
13406 }
13407 deserializer.deserialize_identifier(GeneratedVisitor)
13408 }
13409 }
13410 struct GeneratedVisitor;
13411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13412 type Value = SystemParams;
13413
13414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13415 formatter.write_str("struct meta.SystemParams")
13416 }
13417
13418 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
13419 where
13420 V: serde::de::MapAccess<'de>,
13421 {
13422 let mut barrier_interval_ms__ = None;
13423 let mut checkpoint_frequency__ = None;
13424 let mut sstable_size_mb__ = None;
13425 let mut block_size_kb__ = None;
13426 let mut bloom_false_positive__ = None;
13427 let mut state_store__ = None;
13428 let mut data_directory__ = None;
13429 let mut backup_storage_url__ = None;
13430 let mut backup_storage_directory__ = None;
13431 let mut telemetry_enabled__ = None;
13432 let mut parallel_compact_size_mb__ = None;
13433 let mut max_concurrent_creating_streaming_jobs__ = None;
13434 let mut pause_on_next_bootstrap__ = None;
13435 let mut wasm_storage_url__ = None;
13436 let mut enable_tracing__ = None;
13437 let mut use_new_object_prefix_strategy__ = None;
13438 let mut license_key__ = None;
13439 let mut time_travel_retention_ms__ = None;
13440 let mut adaptive_parallelism_strategy__ = None;
13441 let mut per_database_isolation__ = None;
13442 while let Some(k) = map_.next_key()? {
13443 match k {
13444 GeneratedField::BarrierIntervalMs => {
13445 if barrier_interval_ms__.is_some() {
13446 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
13447 }
13448 barrier_interval_ms__ =
13449 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13450 ;
13451 }
13452 GeneratedField::CheckpointFrequency => {
13453 if checkpoint_frequency__.is_some() {
13454 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
13455 }
13456 checkpoint_frequency__ =
13457 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13458 ;
13459 }
13460 GeneratedField::SstableSizeMb => {
13461 if sstable_size_mb__.is_some() {
13462 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
13463 }
13464 sstable_size_mb__ =
13465 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13466 ;
13467 }
13468 GeneratedField::BlockSizeKb => {
13469 if block_size_kb__.is_some() {
13470 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
13471 }
13472 block_size_kb__ =
13473 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13474 ;
13475 }
13476 GeneratedField::BloomFalsePositive => {
13477 if bloom_false_positive__.is_some() {
13478 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
13479 }
13480 bloom_false_positive__ =
13481 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13482 ;
13483 }
13484 GeneratedField::StateStore => {
13485 if state_store__.is_some() {
13486 return Err(serde::de::Error::duplicate_field("stateStore"));
13487 }
13488 state_store__ = map_.next_value()?;
13489 }
13490 GeneratedField::DataDirectory => {
13491 if data_directory__.is_some() {
13492 return Err(serde::de::Error::duplicate_field("dataDirectory"));
13493 }
13494 data_directory__ = map_.next_value()?;
13495 }
13496 GeneratedField::BackupStorageUrl => {
13497 if backup_storage_url__.is_some() {
13498 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
13499 }
13500 backup_storage_url__ = map_.next_value()?;
13501 }
13502 GeneratedField::BackupStorageDirectory => {
13503 if backup_storage_directory__.is_some() {
13504 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
13505 }
13506 backup_storage_directory__ = map_.next_value()?;
13507 }
13508 GeneratedField::TelemetryEnabled => {
13509 if telemetry_enabled__.is_some() {
13510 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
13511 }
13512 telemetry_enabled__ = map_.next_value()?;
13513 }
13514 GeneratedField::ParallelCompactSizeMb => {
13515 if parallel_compact_size_mb__.is_some() {
13516 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
13517 }
13518 parallel_compact_size_mb__ =
13519 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13520 ;
13521 }
13522 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
13523 if max_concurrent_creating_streaming_jobs__.is_some() {
13524 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
13525 }
13526 max_concurrent_creating_streaming_jobs__ =
13527 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13528 ;
13529 }
13530 GeneratedField::PauseOnNextBootstrap => {
13531 if pause_on_next_bootstrap__.is_some() {
13532 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
13533 }
13534 pause_on_next_bootstrap__ = map_.next_value()?;
13535 }
13536 GeneratedField::WasmStorageUrl => {
13537 if wasm_storage_url__.is_some() {
13538 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
13539 }
13540 wasm_storage_url__ = map_.next_value()?;
13541 }
13542 GeneratedField::EnableTracing => {
13543 if enable_tracing__.is_some() {
13544 return Err(serde::de::Error::duplicate_field("enableTracing"));
13545 }
13546 enable_tracing__ = map_.next_value()?;
13547 }
13548 GeneratedField::UseNewObjectPrefixStrategy => {
13549 if use_new_object_prefix_strategy__.is_some() {
13550 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
13551 }
13552 use_new_object_prefix_strategy__ = map_.next_value()?;
13553 }
13554 GeneratedField::LicenseKey => {
13555 if license_key__.is_some() {
13556 return Err(serde::de::Error::duplicate_field("licenseKey"));
13557 }
13558 license_key__ = map_.next_value()?;
13559 }
13560 GeneratedField::TimeTravelRetentionMs => {
13561 if time_travel_retention_ms__.is_some() {
13562 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
13563 }
13564 time_travel_retention_ms__ =
13565 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13566 ;
13567 }
13568 GeneratedField::AdaptiveParallelismStrategy => {
13569 if adaptive_parallelism_strategy__.is_some() {
13570 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
13571 }
13572 adaptive_parallelism_strategy__ = map_.next_value()?;
13573 }
13574 GeneratedField::PerDatabaseIsolation => {
13575 if per_database_isolation__.is_some() {
13576 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
13577 }
13578 per_database_isolation__ = map_.next_value()?;
13579 }
13580 }
13581 }
13582 Ok(SystemParams {
13583 barrier_interval_ms: barrier_interval_ms__,
13584 checkpoint_frequency: checkpoint_frequency__,
13585 sstable_size_mb: sstable_size_mb__,
13586 block_size_kb: block_size_kb__,
13587 bloom_false_positive: bloom_false_positive__,
13588 state_store: state_store__,
13589 data_directory: data_directory__,
13590 backup_storage_url: backup_storage_url__,
13591 backup_storage_directory: backup_storage_directory__,
13592 telemetry_enabled: telemetry_enabled__,
13593 parallel_compact_size_mb: parallel_compact_size_mb__,
13594 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
13595 pause_on_next_bootstrap: pause_on_next_bootstrap__,
13596 wasm_storage_url: wasm_storage_url__,
13597 enable_tracing: enable_tracing__,
13598 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
13599 license_key: license_key__,
13600 time_travel_retention_ms: time_travel_retention_ms__,
13601 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
13602 per_database_isolation: per_database_isolation__,
13603 })
13604 }
13605 }
13606 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
13607 }
13608}
13609impl serde::Serialize for TableFragments {
13610 #[allow(deprecated)]
13611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13612 where
13613 S: serde::Serializer,
13614 {
13615 use serde::ser::SerializeStruct;
13616 let mut len = 0;
13617 if self.table_id != 0 {
13618 len += 1;
13619 }
13620 if self.state != 0 {
13621 len += 1;
13622 }
13623 if !self.fragments.is_empty() {
13624 len += 1;
13625 }
13626 if !self.actor_status.is_empty() {
13627 len += 1;
13628 }
13629 if !self.actor_splits.is_empty() {
13630 len += 1;
13631 }
13632 if self.ctx.is_some() {
13633 len += 1;
13634 }
13635 if self.parallelism.is_some() {
13636 len += 1;
13637 }
13638 if self.max_parallelism.is_some() {
13639 len += 1;
13640 }
13641 if !self.node_label.is_empty() {
13642 len += 1;
13643 }
13644 if self.backfill_done {
13645 len += 1;
13646 }
13647 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
13648 if self.table_id != 0 {
13649 struct_ser.serialize_field("tableId", &self.table_id)?;
13650 }
13651 if self.state != 0 {
13652 let v = table_fragments::State::try_from(self.state)
13653 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
13654 struct_ser.serialize_field("state", &v)?;
13655 }
13656 if !self.fragments.is_empty() {
13657 struct_ser.serialize_field("fragments", &self.fragments)?;
13658 }
13659 if !self.actor_status.is_empty() {
13660 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
13661 }
13662 if !self.actor_splits.is_empty() {
13663 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
13664 }
13665 if let Some(v) = self.ctx.as_ref() {
13666 struct_ser.serialize_field("ctx", v)?;
13667 }
13668 if let Some(v) = self.parallelism.as_ref() {
13669 struct_ser.serialize_field("parallelism", v)?;
13670 }
13671 if let Some(v) = self.max_parallelism.as_ref() {
13672 struct_ser.serialize_field("maxParallelism", v)?;
13673 }
13674 if !self.node_label.is_empty() {
13675 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
13676 }
13677 if self.backfill_done {
13678 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
13679 }
13680 struct_ser.end()
13681 }
13682}
13683impl<'de> serde::Deserialize<'de> for TableFragments {
13684 #[allow(deprecated)]
13685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13686 where
13687 D: serde::Deserializer<'de>,
13688 {
13689 const FIELDS: &[&str] = &[
13690 "table_id",
13691 "tableId",
13692 "state",
13693 "fragments",
13694 "actor_status",
13695 "actorStatus",
13696 "actor_splits",
13697 "actorSplits",
13698 "ctx",
13699 "parallelism",
13700 "max_parallelism",
13701 "maxParallelism",
13702 "node_label",
13703 "nodeLabel",
13704 "backfill_done",
13705 "backfillDone",
13706 ];
13707
13708 #[allow(clippy::enum_variant_names)]
13709 enum GeneratedField {
13710 TableId,
13711 State,
13712 Fragments,
13713 ActorStatus,
13714 ActorSplits,
13715 Ctx,
13716 Parallelism,
13717 MaxParallelism,
13718 NodeLabel,
13719 BackfillDone,
13720 }
13721 impl<'de> serde::Deserialize<'de> for GeneratedField {
13722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13723 where
13724 D: serde::Deserializer<'de>,
13725 {
13726 struct GeneratedVisitor;
13727
13728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13729 type Value = GeneratedField;
13730
13731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13732 write!(formatter, "expected one of: {:?}", &FIELDS)
13733 }
13734
13735 #[allow(unused_variables)]
13736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13737 where
13738 E: serde::de::Error,
13739 {
13740 match value {
13741 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13742 "state" => Ok(GeneratedField::State),
13743 "fragments" => Ok(GeneratedField::Fragments),
13744 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
13745 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
13746 "ctx" => Ok(GeneratedField::Ctx),
13747 "parallelism" => Ok(GeneratedField::Parallelism),
13748 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
13749 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
13750 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
13751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13752 }
13753 }
13754 }
13755 deserializer.deserialize_identifier(GeneratedVisitor)
13756 }
13757 }
13758 struct GeneratedVisitor;
13759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13760 type Value = TableFragments;
13761
13762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13763 formatter.write_str("struct meta.TableFragments")
13764 }
13765
13766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
13767 where
13768 V: serde::de::MapAccess<'de>,
13769 {
13770 let mut table_id__ = None;
13771 let mut state__ = None;
13772 let mut fragments__ = None;
13773 let mut actor_status__ = None;
13774 let mut actor_splits__ = None;
13775 let mut ctx__ = None;
13776 let mut parallelism__ = None;
13777 let mut max_parallelism__ = None;
13778 let mut node_label__ = None;
13779 let mut backfill_done__ = None;
13780 while let Some(k) = map_.next_key()? {
13781 match k {
13782 GeneratedField::TableId => {
13783 if table_id__.is_some() {
13784 return Err(serde::de::Error::duplicate_field("tableId"));
13785 }
13786 table_id__ =
13787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13788 ;
13789 }
13790 GeneratedField::State => {
13791 if state__.is_some() {
13792 return Err(serde::de::Error::duplicate_field("state"));
13793 }
13794 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
13795 }
13796 GeneratedField::Fragments => {
13797 if fragments__.is_some() {
13798 return Err(serde::de::Error::duplicate_field("fragments"));
13799 }
13800 fragments__ = Some(
13801 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13802 .into_iter().map(|(k,v)| (k.0, v)).collect()
13803 );
13804 }
13805 GeneratedField::ActorStatus => {
13806 if actor_status__.is_some() {
13807 return Err(serde::de::Error::duplicate_field("actorStatus"));
13808 }
13809 actor_status__ = Some(
13810 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13811 .into_iter().map(|(k,v)| (k.0, v)).collect()
13812 );
13813 }
13814 GeneratedField::ActorSplits => {
13815 if actor_splits__.is_some() {
13816 return Err(serde::de::Error::duplicate_field("actorSplits"));
13817 }
13818 actor_splits__ = Some(
13819 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13820 .into_iter().map(|(k,v)| (k.0, v)).collect()
13821 );
13822 }
13823 GeneratedField::Ctx => {
13824 if ctx__.is_some() {
13825 return Err(serde::de::Error::duplicate_field("ctx"));
13826 }
13827 ctx__ = map_.next_value()?;
13828 }
13829 GeneratedField::Parallelism => {
13830 if parallelism__.is_some() {
13831 return Err(serde::de::Error::duplicate_field("parallelism"));
13832 }
13833 parallelism__ = map_.next_value()?;
13834 }
13835 GeneratedField::MaxParallelism => {
13836 if max_parallelism__.is_some() {
13837 return Err(serde::de::Error::duplicate_field("maxParallelism"));
13838 }
13839 max_parallelism__ =
13840 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13841 ;
13842 }
13843 GeneratedField::NodeLabel => {
13844 if node_label__.is_some() {
13845 return Err(serde::de::Error::duplicate_field("nodeLabel"));
13846 }
13847 node_label__ = Some(map_.next_value()?);
13848 }
13849 GeneratedField::BackfillDone => {
13850 if backfill_done__.is_some() {
13851 return Err(serde::de::Error::duplicate_field("backfillDone"));
13852 }
13853 backfill_done__ = Some(map_.next_value()?);
13854 }
13855 }
13856 }
13857 Ok(TableFragments {
13858 table_id: table_id__.unwrap_or_default(),
13859 state: state__.unwrap_or_default(),
13860 fragments: fragments__.unwrap_or_default(),
13861 actor_status: actor_status__.unwrap_or_default(),
13862 actor_splits: actor_splits__.unwrap_or_default(),
13863 ctx: ctx__,
13864 parallelism: parallelism__,
13865 max_parallelism: max_parallelism__,
13866 node_label: node_label__.unwrap_or_default(),
13867 backfill_done: backfill_done__.unwrap_or_default(),
13868 })
13869 }
13870 }
13871 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
13872 }
13873}
13874impl serde::Serialize for table_fragments::ActorStatus {
13875 #[allow(deprecated)]
13876 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13877 where
13878 S: serde::Serializer,
13879 {
13880 use serde::ser::SerializeStruct;
13881 let mut len = 0;
13882 if self.location.is_some() {
13883 len += 1;
13884 }
13885 if self.state != 0 {
13886 len += 1;
13887 }
13888 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
13889 if let Some(v) = self.location.as_ref() {
13890 struct_ser.serialize_field("location", v)?;
13891 }
13892 if self.state != 0 {
13893 let v = table_fragments::actor_status::ActorState::try_from(self.state)
13894 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
13895 struct_ser.serialize_field("state", &v)?;
13896 }
13897 struct_ser.end()
13898 }
13899}
13900impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
13901 #[allow(deprecated)]
13902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13903 where
13904 D: serde::Deserializer<'de>,
13905 {
13906 const FIELDS: &[&str] = &[
13907 "location",
13908 "state",
13909 ];
13910
13911 #[allow(clippy::enum_variant_names)]
13912 enum GeneratedField {
13913 Location,
13914 State,
13915 }
13916 impl<'de> serde::Deserialize<'de> for GeneratedField {
13917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13918 where
13919 D: serde::Deserializer<'de>,
13920 {
13921 struct GeneratedVisitor;
13922
13923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13924 type Value = GeneratedField;
13925
13926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13927 write!(formatter, "expected one of: {:?}", &FIELDS)
13928 }
13929
13930 #[allow(unused_variables)]
13931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13932 where
13933 E: serde::de::Error,
13934 {
13935 match value {
13936 "location" => Ok(GeneratedField::Location),
13937 "state" => Ok(GeneratedField::State),
13938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13939 }
13940 }
13941 }
13942 deserializer.deserialize_identifier(GeneratedVisitor)
13943 }
13944 }
13945 struct GeneratedVisitor;
13946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13947 type Value = table_fragments::ActorStatus;
13948
13949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13950 formatter.write_str("struct meta.TableFragments.ActorStatus")
13951 }
13952
13953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
13954 where
13955 V: serde::de::MapAccess<'de>,
13956 {
13957 let mut location__ = None;
13958 let mut state__ = None;
13959 while let Some(k) = map_.next_key()? {
13960 match k {
13961 GeneratedField::Location => {
13962 if location__.is_some() {
13963 return Err(serde::de::Error::duplicate_field("location"));
13964 }
13965 location__ = map_.next_value()?;
13966 }
13967 GeneratedField::State => {
13968 if state__.is_some() {
13969 return Err(serde::de::Error::duplicate_field("state"));
13970 }
13971 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
13972 }
13973 }
13974 }
13975 Ok(table_fragments::ActorStatus {
13976 location: location__,
13977 state: state__.unwrap_or_default(),
13978 })
13979 }
13980 }
13981 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
13982 }
13983}
13984impl serde::Serialize for table_fragments::actor_status::ActorState {
13985 #[allow(deprecated)]
13986 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13987 where
13988 S: serde::Serializer,
13989 {
13990 let variant = match self {
13991 Self::Unspecified => "UNSPECIFIED",
13992 Self::Inactive => "INACTIVE",
13993 Self::Running => "RUNNING",
13994 };
13995 serializer.serialize_str(variant)
13996 }
13997}
13998impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
13999 #[allow(deprecated)]
14000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14001 where
14002 D: serde::Deserializer<'de>,
14003 {
14004 const FIELDS: &[&str] = &[
14005 "UNSPECIFIED",
14006 "INACTIVE",
14007 "RUNNING",
14008 ];
14009
14010 struct GeneratedVisitor;
14011
14012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14013 type Value = table_fragments::actor_status::ActorState;
14014
14015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14016 write!(formatter, "expected one of: {:?}", &FIELDS)
14017 }
14018
14019 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14020 where
14021 E: serde::de::Error,
14022 {
14023 i32::try_from(v)
14024 .ok()
14025 .and_then(|x| x.try_into().ok())
14026 .ok_or_else(|| {
14027 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14028 })
14029 }
14030
14031 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14032 where
14033 E: serde::de::Error,
14034 {
14035 i32::try_from(v)
14036 .ok()
14037 .and_then(|x| x.try_into().ok())
14038 .ok_or_else(|| {
14039 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14040 })
14041 }
14042
14043 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14044 where
14045 E: serde::de::Error,
14046 {
14047 match value {
14048 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
14049 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
14050 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
14051 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14052 }
14053 }
14054 }
14055 deserializer.deserialize_any(GeneratedVisitor)
14056 }
14057}
14058impl serde::Serialize for table_fragments::Fragment {
14059 #[allow(deprecated)]
14060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14061 where
14062 S: serde::Serializer,
14063 {
14064 use serde::ser::SerializeStruct;
14065 let mut len = 0;
14066 if self.fragment_id != 0 {
14067 len += 1;
14068 }
14069 if self.fragment_type_mask != 0 {
14070 len += 1;
14071 }
14072 if self.distribution_type != 0 {
14073 len += 1;
14074 }
14075 if !self.actors.is_empty() {
14076 len += 1;
14077 }
14078 if !self.state_table_ids.is_empty() {
14079 len += 1;
14080 }
14081 if !self.upstream_fragment_ids.is_empty() {
14082 len += 1;
14083 }
14084 if self.maybe_vnode_count.is_some() {
14085 len += 1;
14086 }
14087 if self.nodes.is_some() {
14088 len += 1;
14089 }
14090 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
14091 if self.fragment_id != 0 {
14092 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
14093 }
14094 if self.fragment_type_mask != 0 {
14095 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
14096 }
14097 if self.distribution_type != 0 {
14098 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
14099 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
14100 struct_ser.serialize_field("distributionType", &v)?;
14101 }
14102 if !self.actors.is_empty() {
14103 struct_ser.serialize_field("actors", &self.actors)?;
14104 }
14105 if !self.state_table_ids.is_empty() {
14106 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
14107 }
14108 if !self.upstream_fragment_ids.is_empty() {
14109 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
14110 }
14111 if let Some(v) = self.maybe_vnode_count.as_ref() {
14112 struct_ser.serialize_field("maybeVnodeCount", v)?;
14113 }
14114 if let Some(v) = self.nodes.as_ref() {
14115 struct_ser.serialize_field("nodes", v)?;
14116 }
14117 struct_ser.end()
14118 }
14119}
14120impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
14121 #[allow(deprecated)]
14122 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14123 where
14124 D: serde::Deserializer<'de>,
14125 {
14126 const FIELDS: &[&str] = &[
14127 "fragment_id",
14128 "fragmentId",
14129 "fragment_type_mask",
14130 "fragmentTypeMask",
14131 "distribution_type",
14132 "distributionType",
14133 "actors",
14134 "state_table_ids",
14135 "stateTableIds",
14136 "upstream_fragment_ids",
14137 "upstreamFragmentIds",
14138 "maybe_vnode_count",
14139 "maybeVnodeCount",
14140 "nodes",
14141 ];
14142
14143 #[allow(clippy::enum_variant_names)]
14144 enum GeneratedField {
14145 FragmentId,
14146 FragmentTypeMask,
14147 DistributionType,
14148 Actors,
14149 StateTableIds,
14150 UpstreamFragmentIds,
14151 MaybeVnodeCount,
14152 Nodes,
14153 }
14154 impl<'de> serde::Deserialize<'de> for GeneratedField {
14155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14156 where
14157 D: serde::Deserializer<'de>,
14158 {
14159 struct GeneratedVisitor;
14160
14161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14162 type Value = GeneratedField;
14163
14164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14165 write!(formatter, "expected one of: {:?}", &FIELDS)
14166 }
14167
14168 #[allow(unused_variables)]
14169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14170 where
14171 E: serde::de::Error,
14172 {
14173 match value {
14174 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
14175 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
14176 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
14177 "actors" => Ok(GeneratedField::Actors),
14178 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
14179 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
14180 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
14181 "nodes" => Ok(GeneratedField::Nodes),
14182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14183 }
14184 }
14185 }
14186 deserializer.deserialize_identifier(GeneratedVisitor)
14187 }
14188 }
14189 struct GeneratedVisitor;
14190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14191 type Value = table_fragments::Fragment;
14192
14193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14194 formatter.write_str("struct meta.TableFragments.Fragment")
14195 }
14196
14197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
14198 where
14199 V: serde::de::MapAccess<'de>,
14200 {
14201 let mut fragment_id__ = None;
14202 let mut fragment_type_mask__ = None;
14203 let mut distribution_type__ = None;
14204 let mut actors__ = None;
14205 let mut state_table_ids__ = None;
14206 let mut upstream_fragment_ids__ = None;
14207 let mut maybe_vnode_count__ = None;
14208 let mut nodes__ = None;
14209 while let Some(k) = map_.next_key()? {
14210 match k {
14211 GeneratedField::FragmentId => {
14212 if fragment_id__.is_some() {
14213 return Err(serde::de::Error::duplicate_field("fragmentId"));
14214 }
14215 fragment_id__ =
14216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14217 ;
14218 }
14219 GeneratedField::FragmentTypeMask => {
14220 if fragment_type_mask__.is_some() {
14221 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
14222 }
14223 fragment_type_mask__ =
14224 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14225 ;
14226 }
14227 GeneratedField::DistributionType => {
14228 if distribution_type__.is_some() {
14229 return Err(serde::de::Error::duplicate_field("distributionType"));
14230 }
14231 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
14232 }
14233 GeneratedField::Actors => {
14234 if actors__.is_some() {
14235 return Err(serde::de::Error::duplicate_field("actors"));
14236 }
14237 actors__ = Some(map_.next_value()?);
14238 }
14239 GeneratedField::StateTableIds => {
14240 if state_table_ids__.is_some() {
14241 return Err(serde::de::Error::duplicate_field("stateTableIds"));
14242 }
14243 state_table_ids__ =
14244 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14245 .into_iter().map(|x| x.0).collect())
14246 ;
14247 }
14248 GeneratedField::UpstreamFragmentIds => {
14249 if upstream_fragment_ids__.is_some() {
14250 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
14251 }
14252 upstream_fragment_ids__ =
14253 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14254 .into_iter().map(|x| x.0).collect())
14255 ;
14256 }
14257 GeneratedField::MaybeVnodeCount => {
14258 if maybe_vnode_count__.is_some() {
14259 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
14260 }
14261 maybe_vnode_count__ =
14262 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14263 ;
14264 }
14265 GeneratedField::Nodes => {
14266 if nodes__.is_some() {
14267 return Err(serde::de::Error::duplicate_field("nodes"));
14268 }
14269 nodes__ = map_.next_value()?;
14270 }
14271 }
14272 }
14273 Ok(table_fragments::Fragment {
14274 fragment_id: fragment_id__.unwrap_or_default(),
14275 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
14276 distribution_type: distribution_type__.unwrap_or_default(),
14277 actors: actors__.unwrap_or_default(),
14278 state_table_ids: state_table_ids__.unwrap_or_default(),
14279 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
14280 maybe_vnode_count: maybe_vnode_count__,
14281 nodes: nodes__,
14282 })
14283 }
14284 }
14285 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
14286 }
14287}
14288impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
14289 #[allow(deprecated)]
14290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14291 where
14292 S: serde::Serializer,
14293 {
14294 let variant = match self {
14295 Self::Unspecified => "UNSPECIFIED",
14296 Self::Single => "SINGLE",
14297 Self::Hash => "HASH",
14298 };
14299 serializer.serialize_str(variant)
14300 }
14301}
14302impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
14303 #[allow(deprecated)]
14304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14305 where
14306 D: serde::Deserializer<'de>,
14307 {
14308 const FIELDS: &[&str] = &[
14309 "UNSPECIFIED",
14310 "SINGLE",
14311 "HASH",
14312 ];
14313
14314 struct GeneratedVisitor;
14315
14316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14317 type Value = table_fragments::fragment::FragmentDistributionType;
14318
14319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14320 write!(formatter, "expected one of: {:?}", &FIELDS)
14321 }
14322
14323 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14324 where
14325 E: serde::de::Error,
14326 {
14327 i32::try_from(v)
14328 .ok()
14329 .and_then(|x| x.try_into().ok())
14330 .ok_or_else(|| {
14331 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14332 })
14333 }
14334
14335 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14336 where
14337 E: serde::de::Error,
14338 {
14339 i32::try_from(v)
14340 .ok()
14341 .and_then(|x| x.try_into().ok())
14342 .ok_or_else(|| {
14343 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14344 })
14345 }
14346
14347 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14348 where
14349 E: serde::de::Error,
14350 {
14351 match value {
14352 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
14353 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
14354 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
14355 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14356 }
14357 }
14358 }
14359 deserializer.deserialize_any(GeneratedVisitor)
14360 }
14361}
14362impl serde::Serialize for table_fragments::State {
14363 #[allow(deprecated)]
14364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14365 where
14366 S: serde::Serializer,
14367 {
14368 let variant = match self {
14369 Self::Unspecified => "UNSPECIFIED",
14370 Self::Initial => "INITIAL",
14371 Self::Creating => "CREATING",
14372 Self::Created => "CREATED",
14373 };
14374 serializer.serialize_str(variant)
14375 }
14376}
14377impl<'de> serde::Deserialize<'de> for table_fragments::State {
14378 #[allow(deprecated)]
14379 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14380 where
14381 D: serde::Deserializer<'de>,
14382 {
14383 const FIELDS: &[&str] = &[
14384 "UNSPECIFIED",
14385 "INITIAL",
14386 "CREATING",
14387 "CREATED",
14388 ];
14389
14390 struct GeneratedVisitor;
14391
14392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14393 type Value = table_fragments::State;
14394
14395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14396 write!(formatter, "expected one of: {:?}", &FIELDS)
14397 }
14398
14399 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14400 where
14401 E: serde::de::Error,
14402 {
14403 i32::try_from(v)
14404 .ok()
14405 .and_then(|x| x.try_into().ok())
14406 .ok_or_else(|| {
14407 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14408 })
14409 }
14410
14411 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14412 where
14413 E: serde::de::Error,
14414 {
14415 i32::try_from(v)
14416 .ok()
14417 .and_then(|x| x.try_into().ok())
14418 .ok_or_else(|| {
14419 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14420 })
14421 }
14422
14423 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14424 where
14425 E: serde::de::Error,
14426 {
14427 match value {
14428 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
14429 "INITIAL" => Ok(table_fragments::State::Initial),
14430 "CREATING" => Ok(table_fragments::State::Creating),
14431 "CREATED" => Ok(table_fragments::State::Created),
14432 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14433 }
14434 }
14435 }
14436 deserializer.deserialize_any(GeneratedVisitor)
14437 }
14438}
14439impl serde::Serialize for TableParallelism {
14440 #[allow(deprecated)]
14441 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14442 where
14443 S: serde::Serializer,
14444 {
14445 use serde::ser::SerializeStruct;
14446 let mut len = 0;
14447 if self.parallelism.is_some() {
14448 len += 1;
14449 }
14450 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
14451 if let Some(v) = self.parallelism.as_ref() {
14452 match v {
14453 table_parallelism::Parallelism::Fixed(v) => {
14454 struct_ser.serialize_field("fixed", v)?;
14455 }
14456 table_parallelism::Parallelism::Auto(v) => {
14457 struct_ser.serialize_field("auto", v)?;
14458 }
14459 table_parallelism::Parallelism::Custom(v) => {
14460 struct_ser.serialize_field("custom", v)?;
14461 }
14462 table_parallelism::Parallelism::Adaptive(v) => {
14463 struct_ser.serialize_field("adaptive", v)?;
14464 }
14465 }
14466 }
14467 struct_ser.end()
14468 }
14469}
14470impl<'de> serde::Deserialize<'de> for TableParallelism {
14471 #[allow(deprecated)]
14472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14473 where
14474 D: serde::Deserializer<'de>,
14475 {
14476 const FIELDS: &[&str] = &[
14477 "fixed",
14478 "auto",
14479 "custom",
14480 "adaptive",
14481 ];
14482
14483 #[allow(clippy::enum_variant_names)]
14484 enum GeneratedField {
14485 Fixed,
14486 Auto,
14487 Custom,
14488 Adaptive,
14489 }
14490 impl<'de> serde::Deserialize<'de> for GeneratedField {
14491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14492 where
14493 D: serde::Deserializer<'de>,
14494 {
14495 struct GeneratedVisitor;
14496
14497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14498 type Value = GeneratedField;
14499
14500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14501 write!(formatter, "expected one of: {:?}", &FIELDS)
14502 }
14503
14504 #[allow(unused_variables)]
14505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14506 where
14507 E: serde::de::Error,
14508 {
14509 match value {
14510 "fixed" => Ok(GeneratedField::Fixed),
14511 "auto" => Ok(GeneratedField::Auto),
14512 "custom" => Ok(GeneratedField::Custom),
14513 "adaptive" => Ok(GeneratedField::Adaptive),
14514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14515 }
14516 }
14517 }
14518 deserializer.deserialize_identifier(GeneratedVisitor)
14519 }
14520 }
14521 struct GeneratedVisitor;
14522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14523 type Value = TableParallelism;
14524
14525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14526 formatter.write_str("struct meta.TableParallelism")
14527 }
14528
14529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
14530 where
14531 V: serde::de::MapAccess<'de>,
14532 {
14533 let mut parallelism__ = None;
14534 while let Some(k) = map_.next_key()? {
14535 match k {
14536 GeneratedField::Fixed => {
14537 if parallelism__.is_some() {
14538 return Err(serde::de::Error::duplicate_field("fixed"));
14539 }
14540 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
14541;
14542 }
14543 GeneratedField::Auto => {
14544 if parallelism__.is_some() {
14545 return Err(serde::de::Error::duplicate_field("auto"));
14546 }
14547 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
14548;
14549 }
14550 GeneratedField::Custom => {
14551 if parallelism__.is_some() {
14552 return Err(serde::de::Error::duplicate_field("custom"));
14553 }
14554 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
14555;
14556 }
14557 GeneratedField::Adaptive => {
14558 if parallelism__.is_some() {
14559 return Err(serde::de::Error::duplicate_field("adaptive"));
14560 }
14561 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
14562;
14563 }
14564 }
14565 }
14566 Ok(TableParallelism {
14567 parallelism: parallelism__,
14568 })
14569 }
14570 }
14571 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
14572 }
14573}
14574impl serde::Serialize for table_parallelism::AdaptiveParallelism {
14575 #[allow(deprecated)]
14576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14577 where
14578 S: serde::Serializer,
14579 {
14580 use serde::ser::SerializeStruct;
14581 let len = 0;
14582 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
14583 struct_ser.end()
14584 }
14585}
14586impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
14587 #[allow(deprecated)]
14588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14589 where
14590 D: serde::Deserializer<'de>,
14591 {
14592 const FIELDS: &[&str] = &[
14593 ];
14594
14595 #[allow(clippy::enum_variant_names)]
14596 enum GeneratedField {
14597 }
14598 impl<'de> serde::Deserialize<'de> for GeneratedField {
14599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14600 where
14601 D: serde::Deserializer<'de>,
14602 {
14603 struct GeneratedVisitor;
14604
14605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14606 type Value = GeneratedField;
14607
14608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14609 write!(formatter, "expected one of: {:?}", &FIELDS)
14610 }
14611
14612 #[allow(unused_variables)]
14613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14614 where
14615 E: serde::de::Error,
14616 {
14617 Err(serde::de::Error::unknown_field(value, FIELDS))
14618 }
14619 }
14620 deserializer.deserialize_identifier(GeneratedVisitor)
14621 }
14622 }
14623 struct GeneratedVisitor;
14624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14625 type Value = table_parallelism::AdaptiveParallelism;
14626
14627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14628 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
14629 }
14630
14631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
14632 where
14633 V: serde::de::MapAccess<'de>,
14634 {
14635 while map_.next_key::<GeneratedField>()?.is_some() {
14636 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14637 }
14638 Ok(table_parallelism::AdaptiveParallelism {
14639 })
14640 }
14641 }
14642 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
14643 }
14644}
14645impl serde::Serialize for table_parallelism::AutoParallelism {
14646 #[allow(deprecated)]
14647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14648 where
14649 S: serde::Serializer,
14650 {
14651 use serde::ser::SerializeStruct;
14652 let len = 0;
14653 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
14654 struct_ser.end()
14655 }
14656}
14657impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
14658 #[allow(deprecated)]
14659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14660 where
14661 D: serde::Deserializer<'de>,
14662 {
14663 const FIELDS: &[&str] = &[
14664 ];
14665
14666 #[allow(clippy::enum_variant_names)]
14667 enum GeneratedField {
14668 }
14669 impl<'de> serde::Deserialize<'de> for GeneratedField {
14670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14671 where
14672 D: serde::Deserializer<'de>,
14673 {
14674 struct GeneratedVisitor;
14675
14676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14677 type Value = GeneratedField;
14678
14679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14680 write!(formatter, "expected one of: {:?}", &FIELDS)
14681 }
14682
14683 #[allow(unused_variables)]
14684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14685 where
14686 E: serde::de::Error,
14687 {
14688 Err(serde::de::Error::unknown_field(value, FIELDS))
14689 }
14690 }
14691 deserializer.deserialize_identifier(GeneratedVisitor)
14692 }
14693 }
14694 struct GeneratedVisitor;
14695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14696 type Value = table_parallelism::AutoParallelism;
14697
14698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14699 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
14700 }
14701
14702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
14703 where
14704 V: serde::de::MapAccess<'de>,
14705 {
14706 while map_.next_key::<GeneratedField>()?.is_some() {
14707 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14708 }
14709 Ok(table_parallelism::AutoParallelism {
14710 })
14711 }
14712 }
14713 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
14714 }
14715}
14716impl serde::Serialize for table_parallelism::CustomParallelism {
14717 #[allow(deprecated)]
14718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14719 where
14720 S: serde::Serializer,
14721 {
14722 use serde::ser::SerializeStruct;
14723 let len = 0;
14724 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
14725 struct_ser.end()
14726 }
14727}
14728impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
14729 #[allow(deprecated)]
14730 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14731 where
14732 D: serde::Deserializer<'de>,
14733 {
14734 const FIELDS: &[&str] = &[
14735 ];
14736
14737 #[allow(clippy::enum_variant_names)]
14738 enum GeneratedField {
14739 }
14740 impl<'de> serde::Deserialize<'de> for GeneratedField {
14741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14742 where
14743 D: serde::Deserializer<'de>,
14744 {
14745 struct GeneratedVisitor;
14746
14747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14748 type Value = GeneratedField;
14749
14750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14751 write!(formatter, "expected one of: {:?}", &FIELDS)
14752 }
14753
14754 #[allow(unused_variables)]
14755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14756 where
14757 E: serde::de::Error,
14758 {
14759 Err(serde::de::Error::unknown_field(value, FIELDS))
14760 }
14761 }
14762 deserializer.deserialize_identifier(GeneratedVisitor)
14763 }
14764 }
14765 struct GeneratedVisitor;
14766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14767 type Value = table_parallelism::CustomParallelism;
14768
14769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14770 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
14771 }
14772
14773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
14774 where
14775 V: serde::de::MapAccess<'de>,
14776 {
14777 while map_.next_key::<GeneratedField>()?.is_some() {
14778 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14779 }
14780 Ok(table_parallelism::CustomParallelism {
14781 })
14782 }
14783 }
14784 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
14785 }
14786}
14787impl serde::Serialize for table_parallelism::FixedParallelism {
14788 #[allow(deprecated)]
14789 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14790 where
14791 S: serde::Serializer,
14792 {
14793 use serde::ser::SerializeStruct;
14794 let mut len = 0;
14795 if self.parallelism != 0 {
14796 len += 1;
14797 }
14798 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
14799 if self.parallelism != 0 {
14800 struct_ser.serialize_field("parallelism", &self.parallelism)?;
14801 }
14802 struct_ser.end()
14803 }
14804}
14805impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
14806 #[allow(deprecated)]
14807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14808 where
14809 D: serde::Deserializer<'de>,
14810 {
14811 const FIELDS: &[&str] = &[
14812 "parallelism",
14813 ];
14814
14815 #[allow(clippy::enum_variant_names)]
14816 enum GeneratedField {
14817 Parallelism,
14818 }
14819 impl<'de> serde::Deserialize<'de> for GeneratedField {
14820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14821 where
14822 D: serde::Deserializer<'de>,
14823 {
14824 struct GeneratedVisitor;
14825
14826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14827 type Value = GeneratedField;
14828
14829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14830 write!(formatter, "expected one of: {:?}", &FIELDS)
14831 }
14832
14833 #[allow(unused_variables)]
14834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14835 where
14836 E: serde::de::Error,
14837 {
14838 match value {
14839 "parallelism" => Ok(GeneratedField::Parallelism),
14840 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14841 }
14842 }
14843 }
14844 deserializer.deserialize_identifier(GeneratedVisitor)
14845 }
14846 }
14847 struct GeneratedVisitor;
14848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14849 type Value = table_parallelism::FixedParallelism;
14850
14851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14852 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
14853 }
14854
14855 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
14856 where
14857 V: serde::de::MapAccess<'de>,
14858 {
14859 let mut parallelism__ = None;
14860 while let Some(k) = map_.next_key()? {
14861 match k {
14862 GeneratedField::Parallelism => {
14863 if parallelism__.is_some() {
14864 return Err(serde::de::Error::duplicate_field("parallelism"));
14865 }
14866 parallelism__ =
14867 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14868 ;
14869 }
14870 }
14871 }
14872 Ok(table_parallelism::FixedParallelism {
14873 parallelism: parallelism__.unwrap_or_default(),
14874 })
14875 }
14876 }
14877 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
14878 }
14879}
14880impl serde::Serialize for TelemetryInfoResponse {
14881 #[allow(deprecated)]
14882 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14883 where
14884 S: serde::Serializer,
14885 {
14886 use serde::ser::SerializeStruct;
14887 let mut len = 0;
14888 if self.tracking_id.is_some() {
14889 len += 1;
14890 }
14891 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
14892 if let Some(v) = self.tracking_id.as_ref() {
14893 struct_ser.serialize_field("trackingId", v)?;
14894 }
14895 struct_ser.end()
14896 }
14897}
14898impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
14899 #[allow(deprecated)]
14900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14901 where
14902 D: serde::Deserializer<'de>,
14903 {
14904 const FIELDS: &[&str] = &[
14905 "tracking_id",
14906 "trackingId",
14907 ];
14908
14909 #[allow(clippy::enum_variant_names)]
14910 enum GeneratedField {
14911 TrackingId,
14912 }
14913 impl<'de> serde::Deserialize<'de> for GeneratedField {
14914 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14915 where
14916 D: serde::Deserializer<'de>,
14917 {
14918 struct GeneratedVisitor;
14919
14920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14921 type Value = GeneratedField;
14922
14923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14924 write!(formatter, "expected one of: {:?}", &FIELDS)
14925 }
14926
14927 #[allow(unused_variables)]
14928 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14929 where
14930 E: serde::de::Error,
14931 {
14932 match value {
14933 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
14934 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14935 }
14936 }
14937 }
14938 deserializer.deserialize_identifier(GeneratedVisitor)
14939 }
14940 }
14941 struct GeneratedVisitor;
14942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14943 type Value = TelemetryInfoResponse;
14944
14945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14946 formatter.write_str("struct meta.TelemetryInfoResponse")
14947 }
14948
14949 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
14950 where
14951 V: serde::de::MapAccess<'de>,
14952 {
14953 let mut tracking_id__ = None;
14954 while let Some(k) = map_.next_key()? {
14955 match k {
14956 GeneratedField::TrackingId => {
14957 if tracking_id__.is_some() {
14958 return Err(serde::de::Error::duplicate_field("trackingId"));
14959 }
14960 tracking_id__ = map_.next_value()?;
14961 }
14962 }
14963 }
14964 Ok(TelemetryInfoResponse {
14965 tracking_id: tracking_id__,
14966 })
14967 }
14968 }
14969 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
14970 }
14971}
14972impl serde::Serialize for ThrottleTarget {
14973 #[allow(deprecated)]
14974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14975 where
14976 S: serde::Serializer,
14977 {
14978 let variant = match self {
14979 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
14980 Self::Source => "SOURCE",
14981 Self::Mv => "MV",
14982 Self::TableWithSource => "TABLE_WITH_SOURCE",
14983 Self::CdcTable => "CDC_TABLE",
14984 Self::TableDml => "TABLE_DML",
14985 Self::Sink => "SINK",
14986 Self::Fragment => "FRAGMENT",
14987 };
14988 serializer.serialize_str(variant)
14989 }
14990}
14991impl<'de> serde::Deserialize<'de> for ThrottleTarget {
14992 #[allow(deprecated)]
14993 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14994 where
14995 D: serde::Deserializer<'de>,
14996 {
14997 const FIELDS: &[&str] = &[
14998 "THROTTLE_TARGET_UNSPECIFIED",
14999 "SOURCE",
15000 "MV",
15001 "TABLE_WITH_SOURCE",
15002 "CDC_TABLE",
15003 "TABLE_DML",
15004 "SINK",
15005 "FRAGMENT",
15006 ];
15007
15008 struct GeneratedVisitor;
15009
15010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15011 type Value = ThrottleTarget;
15012
15013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15014 write!(formatter, "expected one of: {:?}", &FIELDS)
15015 }
15016
15017 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15018 where
15019 E: serde::de::Error,
15020 {
15021 i32::try_from(v)
15022 .ok()
15023 .and_then(|x| x.try_into().ok())
15024 .ok_or_else(|| {
15025 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15026 })
15027 }
15028
15029 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15030 where
15031 E: serde::de::Error,
15032 {
15033 i32::try_from(v)
15034 .ok()
15035 .and_then(|x| x.try_into().ok())
15036 .ok_or_else(|| {
15037 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15038 })
15039 }
15040
15041 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15042 where
15043 E: serde::de::Error,
15044 {
15045 match value {
15046 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
15047 "SOURCE" => Ok(ThrottleTarget::Source),
15048 "MV" => Ok(ThrottleTarget::Mv),
15049 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
15050 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
15051 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
15052 "SINK" => Ok(ThrottleTarget::Sink),
15053 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
15054 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15055 }
15056 }
15057 }
15058 deserializer.deserialize_any(GeneratedVisitor)
15059 }
15060}
15061impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
15062 #[allow(deprecated)]
15063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15064 where
15065 S: serde::Serializer,
15066 {
15067 use serde::ser::SerializeStruct;
15068 let mut len = 0;
15069 if self.id != 0 {
15070 len += 1;
15071 }
15072 if !self.node_label.is_empty() {
15073 len += 1;
15074 }
15075 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
15076 if self.id != 0 {
15077 struct_ser.serialize_field("id", &self.id)?;
15078 }
15079 if !self.node_label.is_empty() {
15080 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15081 }
15082 struct_ser.end()
15083 }
15084}
15085impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
15086 #[allow(deprecated)]
15087 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15088 where
15089 D: serde::Deserializer<'de>,
15090 {
15091 const FIELDS: &[&str] = &[
15092 "id",
15093 "node_label",
15094 "nodeLabel",
15095 ];
15096
15097 #[allow(clippy::enum_variant_names)]
15098 enum GeneratedField {
15099 Id,
15100 NodeLabel,
15101 }
15102 impl<'de> serde::Deserialize<'de> for GeneratedField {
15103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15104 where
15105 D: serde::Deserializer<'de>,
15106 {
15107 struct GeneratedVisitor;
15108
15109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15110 type Value = GeneratedField;
15111
15112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15113 write!(formatter, "expected one of: {:?}", &FIELDS)
15114 }
15115
15116 #[allow(unused_variables)]
15117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15118 where
15119 E: serde::de::Error,
15120 {
15121 match value {
15122 "id" => Ok(GeneratedField::Id),
15123 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15125 }
15126 }
15127 }
15128 deserializer.deserialize_identifier(GeneratedVisitor)
15129 }
15130 }
15131 struct GeneratedVisitor;
15132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15133 type Value = UpdateStreamingJobNodeLabelsRequest;
15134
15135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15136 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
15137 }
15138
15139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
15140 where
15141 V: serde::de::MapAccess<'de>,
15142 {
15143 let mut id__ = None;
15144 let mut node_label__ = None;
15145 while let Some(k) = map_.next_key()? {
15146 match k {
15147 GeneratedField::Id => {
15148 if id__.is_some() {
15149 return Err(serde::de::Error::duplicate_field("id"));
15150 }
15151 id__ =
15152 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15153 ;
15154 }
15155 GeneratedField::NodeLabel => {
15156 if node_label__.is_some() {
15157 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15158 }
15159 node_label__ = Some(map_.next_value()?);
15160 }
15161 }
15162 }
15163 Ok(UpdateStreamingJobNodeLabelsRequest {
15164 id: id__.unwrap_or_default(),
15165 node_label: node_label__.unwrap_or_default(),
15166 })
15167 }
15168 }
15169 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
15170 }
15171}
15172impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
15173 #[allow(deprecated)]
15174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15175 where
15176 S: serde::Serializer,
15177 {
15178 use serde::ser::SerializeStruct;
15179 let len = 0;
15180 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
15181 struct_ser.end()
15182 }
15183}
15184impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
15185 #[allow(deprecated)]
15186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15187 where
15188 D: serde::Deserializer<'de>,
15189 {
15190 const FIELDS: &[&str] = &[
15191 ];
15192
15193 #[allow(clippy::enum_variant_names)]
15194 enum GeneratedField {
15195 }
15196 impl<'de> serde::Deserialize<'de> for GeneratedField {
15197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15198 where
15199 D: serde::Deserializer<'de>,
15200 {
15201 struct GeneratedVisitor;
15202
15203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15204 type Value = GeneratedField;
15205
15206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15207 write!(formatter, "expected one of: {:?}", &FIELDS)
15208 }
15209
15210 #[allow(unused_variables)]
15211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15212 where
15213 E: serde::de::Error,
15214 {
15215 Err(serde::de::Error::unknown_field(value, FIELDS))
15216 }
15217 }
15218 deserializer.deserialize_identifier(GeneratedVisitor)
15219 }
15220 }
15221 struct GeneratedVisitor;
15222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15223 type Value = UpdateStreamingJobNodeLabelsResponse;
15224
15225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15226 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
15227 }
15228
15229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
15230 where
15231 V: serde::de::MapAccess<'de>,
15232 {
15233 while map_.next_key::<GeneratedField>()?.is_some() {
15234 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15235 }
15236 Ok(UpdateStreamingJobNodeLabelsResponse {
15237 })
15238 }
15239 }
15240 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
15241 }
15242}
15243impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
15244 #[allow(deprecated)]
15245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15246 where
15247 S: serde::Serializer,
15248 {
15249 use serde::ser::SerializeStruct;
15250 let mut len = 0;
15251 if !self.worker_ids.is_empty() {
15252 len += 1;
15253 }
15254 if self.schedulability != 0 {
15255 len += 1;
15256 }
15257 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
15258 if !self.worker_ids.is_empty() {
15259 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
15260 }
15261 if self.schedulability != 0 {
15262 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
15263 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
15264 struct_ser.serialize_field("schedulability", &v)?;
15265 }
15266 struct_ser.end()
15267 }
15268}
15269impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
15270 #[allow(deprecated)]
15271 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15272 where
15273 D: serde::Deserializer<'de>,
15274 {
15275 const FIELDS: &[&str] = &[
15276 "worker_ids",
15277 "workerIds",
15278 "schedulability",
15279 ];
15280
15281 #[allow(clippy::enum_variant_names)]
15282 enum GeneratedField {
15283 WorkerIds,
15284 Schedulability,
15285 }
15286 impl<'de> serde::Deserialize<'de> for GeneratedField {
15287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15288 where
15289 D: serde::Deserializer<'de>,
15290 {
15291 struct GeneratedVisitor;
15292
15293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15294 type Value = GeneratedField;
15295
15296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15297 write!(formatter, "expected one of: {:?}", &FIELDS)
15298 }
15299
15300 #[allow(unused_variables)]
15301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15302 where
15303 E: serde::de::Error,
15304 {
15305 match value {
15306 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
15307 "schedulability" => Ok(GeneratedField::Schedulability),
15308 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15309 }
15310 }
15311 }
15312 deserializer.deserialize_identifier(GeneratedVisitor)
15313 }
15314 }
15315 struct GeneratedVisitor;
15316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15317 type Value = UpdateWorkerNodeSchedulabilityRequest;
15318
15319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15320 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
15321 }
15322
15323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
15324 where
15325 V: serde::de::MapAccess<'de>,
15326 {
15327 let mut worker_ids__ = None;
15328 let mut schedulability__ = None;
15329 while let Some(k) = map_.next_key()? {
15330 match k {
15331 GeneratedField::WorkerIds => {
15332 if worker_ids__.is_some() {
15333 return Err(serde::de::Error::duplicate_field("workerIds"));
15334 }
15335 worker_ids__ =
15336 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15337 .into_iter().map(|x| x.0).collect())
15338 ;
15339 }
15340 GeneratedField::Schedulability => {
15341 if schedulability__.is_some() {
15342 return Err(serde::de::Error::duplicate_field("schedulability"));
15343 }
15344 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
15345 }
15346 }
15347 }
15348 Ok(UpdateWorkerNodeSchedulabilityRequest {
15349 worker_ids: worker_ids__.unwrap_or_default(),
15350 schedulability: schedulability__.unwrap_or_default(),
15351 })
15352 }
15353 }
15354 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
15355 }
15356}
15357impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
15358 #[allow(deprecated)]
15359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15360 where
15361 S: serde::Serializer,
15362 {
15363 let variant = match self {
15364 Self::Unspecified => "UNSPECIFIED",
15365 Self::Schedulable => "SCHEDULABLE",
15366 Self::Unschedulable => "UNSCHEDULABLE",
15367 };
15368 serializer.serialize_str(variant)
15369 }
15370}
15371impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
15372 #[allow(deprecated)]
15373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15374 where
15375 D: serde::Deserializer<'de>,
15376 {
15377 const FIELDS: &[&str] = &[
15378 "UNSPECIFIED",
15379 "SCHEDULABLE",
15380 "UNSCHEDULABLE",
15381 ];
15382
15383 struct GeneratedVisitor;
15384
15385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15386 type Value = update_worker_node_schedulability_request::Schedulability;
15387
15388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15389 write!(formatter, "expected one of: {:?}", &FIELDS)
15390 }
15391
15392 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15393 where
15394 E: serde::de::Error,
15395 {
15396 i32::try_from(v)
15397 .ok()
15398 .and_then(|x| x.try_into().ok())
15399 .ok_or_else(|| {
15400 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15401 })
15402 }
15403
15404 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15405 where
15406 E: serde::de::Error,
15407 {
15408 i32::try_from(v)
15409 .ok()
15410 .and_then(|x| x.try_into().ok())
15411 .ok_or_else(|| {
15412 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15413 })
15414 }
15415
15416 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15417 where
15418 E: serde::de::Error,
15419 {
15420 match value {
15421 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
15422 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
15423 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
15424 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15425 }
15426 }
15427 }
15428 deserializer.deserialize_any(GeneratedVisitor)
15429 }
15430}
15431impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
15432 #[allow(deprecated)]
15433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15434 where
15435 S: serde::Serializer,
15436 {
15437 use serde::ser::SerializeStruct;
15438 let mut len = 0;
15439 if self.status.is_some() {
15440 len += 1;
15441 }
15442 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
15443 if let Some(v) = self.status.as_ref() {
15444 struct_ser.serialize_field("status", v)?;
15445 }
15446 struct_ser.end()
15447 }
15448}
15449impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
15450 #[allow(deprecated)]
15451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15452 where
15453 D: serde::Deserializer<'de>,
15454 {
15455 const FIELDS: &[&str] = &[
15456 "status",
15457 ];
15458
15459 #[allow(clippy::enum_variant_names)]
15460 enum GeneratedField {
15461 Status,
15462 }
15463 impl<'de> serde::Deserialize<'de> for GeneratedField {
15464 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15465 where
15466 D: serde::Deserializer<'de>,
15467 {
15468 struct GeneratedVisitor;
15469
15470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15471 type Value = GeneratedField;
15472
15473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15474 write!(formatter, "expected one of: {:?}", &FIELDS)
15475 }
15476
15477 #[allow(unused_variables)]
15478 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15479 where
15480 E: serde::de::Error,
15481 {
15482 match value {
15483 "status" => Ok(GeneratedField::Status),
15484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15485 }
15486 }
15487 }
15488 deserializer.deserialize_identifier(GeneratedVisitor)
15489 }
15490 }
15491 struct GeneratedVisitor;
15492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15493 type Value = UpdateWorkerNodeSchedulabilityResponse;
15494
15495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15496 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
15497 }
15498
15499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
15500 where
15501 V: serde::de::MapAccess<'de>,
15502 {
15503 let mut status__ = None;
15504 while let Some(k) = map_.next_key()? {
15505 match k {
15506 GeneratedField::Status => {
15507 if status__.is_some() {
15508 return Err(serde::de::Error::duplicate_field("status"));
15509 }
15510 status__ = map_.next_value()?;
15511 }
15512 }
15513 }
15514 Ok(UpdateWorkerNodeSchedulabilityResponse {
15515 status: status__,
15516 })
15517 }
15518 }
15519 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
15520 }
15521}
15522impl serde::Serialize for WorkerReschedule {
15523 #[allow(deprecated)]
15524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15525 where
15526 S: serde::Serializer,
15527 {
15528 use serde::ser::SerializeStruct;
15529 let mut len = 0;
15530 if !self.worker_actor_diff.is_empty() {
15531 len += 1;
15532 }
15533 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
15534 if !self.worker_actor_diff.is_empty() {
15535 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
15536 }
15537 struct_ser.end()
15538 }
15539}
15540impl<'de> serde::Deserialize<'de> for WorkerReschedule {
15541 #[allow(deprecated)]
15542 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15543 where
15544 D: serde::Deserializer<'de>,
15545 {
15546 const FIELDS: &[&str] = &[
15547 "worker_actor_diff",
15548 "workerActorDiff",
15549 ];
15550
15551 #[allow(clippy::enum_variant_names)]
15552 enum GeneratedField {
15553 WorkerActorDiff,
15554 }
15555 impl<'de> serde::Deserialize<'de> for GeneratedField {
15556 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15557 where
15558 D: serde::Deserializer<'de>,
15559 {
15560 struct GeneratedVisitor;
15561
15562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15563 type Value = GeneratedField;
15564
15565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15566 write!(formatter, "expected one of: {:?}", &FIELDS)
15567 }
15568
15569 #[allow(unused_variables)]
15570 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15571 where
15572 E: serde::de::Error,
15573 {
15574 match value {
15575 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
15576 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15577 }
15578 }
15579 }
15580 deserializer.deserialize_identifier(GeneratedVisitor)
15581 }
15582 }
15583 struct GeneratedVisitor;
15584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15585 type Value = WorkerReschedule;
15586
15587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15588 formatter.write_str("struct meta.WorkerReschedule")
15589 }
15590
15591 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
15592 where
15593 V: serde::de::MapAccess<'de>,
15594 {
15595 let mut worker_actor_diff__ = None;
15596 while let Some(k) = map_.next_key()? {
15597 match k {
15598 GeneratedField::WorkerActorDiff => {
15599 if worker_actor_diff__.is_some() {
15600 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
15601 }
15602 worker_actor_diff__ = Some(
15603 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
15604 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
15605 );
15606 }
15607 }
15608 }
15609 Ok(WorkerReschedule {
15610 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
15611 })
15612 }
15613 }
15614 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
15615 }
15616}