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 AlterConnectorPropsRequest {
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.object_id != 0 {
1110 len += 1;
1111 }
1112 if !self.changed_props.is_empty() {
1113 len += 1;
1114 }
1115 if !self.changed_secret_refs.is_empty() {
1116 len += 1;
1117 }
1118 if self.connector_conn_ref.is_some() {
1119 len += 1;
1120 }
1121 if self.object_type != 0 {
1122 len += 1;
1123 }
1124 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1125 if self.object_id != 0 {
1126 struct_ser.serialize_field("objectId", &self.object_id)?;
1127 }
1128 if !self.changed_props.is_empty() {
1129 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1130 }
1131 if !self.changed_secret_refs.is_empty() {
1132 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1133 }
1134 if let Some(v) = self.connector_conn_ref.as_ref() {
1135 struct_ser.serialize_field("connectorConnRef", v)?;
1136 }
1137 if self.object_type != 0 {
1138 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1139 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1140 struct_ser.serialize_field("objectType", &v)?;
1141 }
1142 struct_ser.end()
1143 }
1144}
1145impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1146 #[allow(deprecated)]
1147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1148 where
1149 D: serde::Deserializer<'de>,
1150 {
1151 const FIELDS: &[&str] = &[
1152 "object_id",
1153 "objectId",
1154 "changed_props",
1155 "changedProps",
1156 "changed_secret_refs",
1157 "changedSecretRefs",
1158 "connector_conn_ref",
1159 "connectorConnRef",
1160 "object_type",
1161 "objectType",
1162 ];
1163
1164 #[allow(clippy::enum_variant_names)]
1165 enum GeneratedField {
1166 ObjectId,
1167 ChangedProps,
1168 ChangedSecretRefs,
1169 ConnectorConnRef,
1170 ObjectType,
1171 }
1172 impl<'de> serde::Deserialize<'de> for GeneratedField {
1173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1174 where
1175 D: serde::Deserializer<'de>,
1176 {
1177 struct GeneratedVisitor;
1178
1179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1180 type Value = GeneratedField;
1181
1182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1183 write!(formatter, "expected one of: {:?}", &FIELDS)
1184 }
1185
1186 #[allow(unused_variables)]
1187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1188 where
1189 E: serde::de::Error,
1190 {
1191 match value {
1192 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1193 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1194 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1195 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1196 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1198 }
1199 }
1200 }
1201 deserializer.deserialize_identifier(GeneratedVisitor)
1202 }
1203 }
1204 struct GeneratedVisitor;
1205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1206 type Value = AlterConnectorPropsRequest;
1207
1208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1209 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1210 }
1211
1212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1213 where
1214 V: serde::de::MapAccess<'de>,
1215 {
1216 let mut object_id__ = None;
1217 let mut changed_props__ = None;
1218 let mut changed_secret_refs__ = None;
1219 let mut connector_conn_ref__ = None;
1220 let mut object_type__ = None;
1221 while let Some(k) = map_.next_key()? {
1222 match k {
1223 GeneratedField::ObjectId => {
1224 if object_id__.is_some() {
1225 return Err(serde::de::Error::duplicate_field("objectId"));
1226 }
1227 object_id__ =
1228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1229 ;
1230 }
1231 GeneratedField::ChangedProps => {
1232 if changed_props__.is_some() {
1233 return Err(serde::de::Error::duplicate_field("changedProps"));
1234 }
1235 changed_props__ = Some(
1236 map_.next_value::<std::collections::HashMap<_, _>>()?
1237 );
1238 }
1239 GeneratedField::ChangedSecretRefs => {
1240 if changed_secret_refs__.is_some() {
1241 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1242 }
1243 changed_secret_refs__ = Some(
1244 map_.next_value::<std::collections::HashMap<_, _>>()?
1245 );
1246 }
1247 GeneratedField::ConnectorConnRef => {
1248 if connector_conn_ref__.is_some() {
1249 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1250 }
1251 connector_conn_ref__ =
1252 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1253 ;
1254 }
1255 GeneratedField::ObjectType => {
1256 if object_type__.is_some() {
1257 return Err(serde::de::Error::duplicate_field("objectType"));
1258 }
1259 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1260 }
1261 }
1262 }
1263 Ok(AlterConnectorPropsRequest {
1264 object_id: object_id__.unwrap_or_default(),
1265 changed_props: changed_props__.unwrap_or_default(),
1266 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1267 connector_conn_ref: connector_conn_ref__,
1268 object_type: object_type__.unwrap_or_default(),
1269 })
1270 }
1271 }
1272 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1273 }
1274}
1275impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1276 #[allow(deprecated)]
1277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1278 where
1279 S: serde::Serializer,
1280 {
1281 let variant = match self {
1282 Self::Unspecified => "UNSPECIFIED",
1283 Self::Source => "SOURCE",
1284 Self::Sink => "SINK",
1285 Self::Connection => "CONNECTION",
1286 };
1287 serializer.serialize_str(variant)
1288 }
1289}
1290impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1291 #[allow(deprecated)]
1292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1293 where
1294 D: serde::Deserializer<'de>,
1295 {
1296 const FIELDS: &[&str] = &[
1297 "UNSPECIFIED",
1298 "SOURCE",
1299 "SINK",
1300 "CONNECTION",
1301 ];
1302
1303 struct GeneratedVisitor;
1304
1305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1306 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1307
1308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1309 write!(formatter, "expected one of: {:?}", &FIELDS)
1310 }
1311
1312 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1313 where
1314 E: serde::de::Error,
1315 {
1316 i32::try_from(v)
1317 .ok()
1318 .and_then(|x| x.try_into().ok())
1319 .ok_or_else(|| {
1320 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1321 })
1322 }
1323
1324 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1325 where
1326 E: serde::de::Error,
1327 {
1328 i32::try_from(v)
1329 .ok()
1330 .and_then(|x| x.try_into().ok())
1331 .ok_or_else(|| {
1332 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1333 })
1334 }
1335
1336 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1337 where
1338 E: serde::de::Error,
1339 {
1340 match value {
1341 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1342 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1343 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1344 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1345 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1346 }
1347 }
1348 }
1349 deserializer.deserialize_any(GeneratedVisitor)
1350 }
1351}
1352impl serde::Serialize for AlterConnectorPropsResponse {
1353 #[allow(deprecated)]
1354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1355 where
1356 S: serde::Serializer,
1357 {
1358 use serde::ser::SerializeStruct;
1359 let len = 0;
1360 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1361 struct_ser.end()
1362 }
1363}
1364impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1365 #[allow(deprecated)]
1366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1367 where
1368 D: serde::Deserializer<'de>,
1369 {
1370 const FIELDS: &[&str] = &[
1371 ];
1372
1373 #[allow(clippy::enum_variant_names)]
1374 enum GeneratedField {
1375 }
1376 impl<'de> serde::Deserialize<'de> for GeneratedField {
1377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1378 where
1379 D: serde::Deserializer<'de>,
1380 {
1381 struct GeneratedVisitor;
1382
1383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1384 type Value = GeneratedField;
1385
1386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1387 write!(formatter, "expected one of: {:?}", &FIELDS)
1388 }
1389
1390 #[allow(unused_variables)]
1391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1392 where
1393 E: serde::de::Error,
1394 {
1395 Err(serde::de::Error::unknown_field(value, FIELDS))
1396 }
1397 }
1398 deserializer.deserialize_identifier(GeneratedVisitor)
1399 }
1400 }
1401 struct GeneratedVisitor;
1402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1403 type Value = AlterConnectorPropsResponse;
1404
1405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1406 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1407 }
1408
1409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1410 where
1411 V: serde::de::MapAccess<'de>,
1412 {
1413 while map_.next_key::<GeneratedField>()?.is_some() {
1414 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1415 }
1416 Ok(AlterConnectorPropsResponse {
1417 })
1418 }
1419 }
1420 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for ApplyThrottleRequest {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.kind != 0 {
1432 len += 1;
1433 }
1434 if self.id != 0 {
1435 len += 1;
1436 }
1437 if self.rate.is_some() {
1438 len += 1;
1439 }
1440 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1441 if self.kind != 0 {
1442 let v = ThrottleTarget::try_from(self.kind)
1443 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1444 struct_ser.serialize_field("kind", &v)?;
1445 }
1446 if self.id != 0 {
1447 struct_ser.serialize_field("id", &self.id)?;
1448 }
1449 if let Some(v) = self.rate.as_ref() {
1450 struct_ser.serialize_field("rate", v)?;
1451 }
1452 struct_ser.end()
1453 }
1454}
1455impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1456 #[allow(deprecated)]
1457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1458 where
1459 D: serde::Deserializer<'de>,
1460 {
1461 const FIELDS: &[&str] = &[
1462 "kind",
1463 "id",
1464 "rate",
1465 ];
1466
1467 #[allow(clippy::enum_variant_names)]
1468 enum GeneratedField {
1469 Kind,
1470 Id,
1471 Rate,
1472 }
1473 impl<'de> serde::Deserialize<'de> for GeneratedField {
1474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1475 where
1476 D: serde::Deserializer<'de>,
1477 {
1478 struct GeneratedVisitor;
1479
1480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1481 type Value = GeneratedField;
1482
1483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1484 write!(formatter, "expected one of: {:?}", &FIELDS)
1485 }
1486
1487 #[allow(unused_variables)]
1488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1489 where
1490 E: serde::de::Error,
1491 {
1492 match value {
1493 "kind" => Ok(GeneratedField::Kind),
1494 "id" => Ok(GeneratedField::Id),
1495 "rate" => Ok(GeneratedField::Rate),
1496 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1497 }
1498 }
1499 }
1500 deserializer.deserialize_identifier(GeneratedVisitor)
1501 }
1502 }
1503 struct GeneratedVisitor;
1504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1505 type Value = ApplyThrottleRequest;
1506
1507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1508 formatter.write_str("struct meta.ApplyThrottleRequest")
1509 }
1510
1511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1512 where
1513 V: serde::de::MapAccess<'de>,
1514 {
1515 let mut kind__ = None;
1516 let mut id__ = None;
1517 let mut rate__ = None;
1518 while let Some(k) = map_.next_key()? {
1519 match k {
1520 GeneratedField::Kind => {
1521 if kind__.is_some() {
1522 return Err(serde::de::Error::duplicate_field("kind"));
1523 }
1524 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1525 }
1526 GeneratedField::Id => {
1527 if id__.is_some() {
1528 return Err(serde::de::Error::duplicate_field("id"));
1529 }
1530 id__ =
1531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1532 ;
1533 }
1534 GeneratedField::Rate => {
1535 if rate__.is_some() {
1536 return Err(serde::de::Error::duplicate_field("rate"));
1537 }
1538 rate__ =
1539 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1540 ;
1541 }
1542 }
1543 }
1544 Ok(ApplyThrottleRequest {
1545 kind: kind__.unwrap_or_default(),
1546 id: id__.unwrap_or_default(),
1547 rate: rate__,
1548 })
1549 }
1550 }
1551 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1552 }
1553}
1554impl serde::Serialize for ApplyThrottleResponse {
1555 #[allow(deprecated)]
1556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1557 where
1558 S: serde::Serializer,
1559 {
1560 use serde::ser::SerializeStruct;
1561 let mut len = 0;
1562 if self.status.is_some() {
1563 len += 1;
1564 }
1565 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1566 if let Some(v) = self.status.as_ref() {
1567 struct_ser.serialize_field("status", v)?;
1568 }
1569 struct_ser.end()
1570 }
1571}
1572impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1573 #[allow(deprecated)]
1574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1575 where
1576 D: serde::Deserializer<'de>,
1577 {
1578 const FIELDS: &[&str] = &[
1579 "status",
1580 ];
1581
1582 #[allow(clippy::enum_variant_names)]
1583 enum GeneratedField {
1584 Status,
1585 }
1586 impl<'de> serde::Deserialize<'de> for GeneratedField {
1587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1588 where
1589 D: serde::Deserializer<'de>,
1590 {
1591 struct GeneratedVisitor;
1592
1593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1594 type Value = GeneratedField;
1595
1596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1597 write!(formatter, "expected one of: {:?}", &FIELDS)
1598 }
1599
1600 #[allow(unused_variables)]
1601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1602 where
1603 E: serde::de::Error,
1604 {
1605 match value {
1606 "status" => Ok(GeneratedField::Status),
1607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1608 }
1609 }
1610 }
1611 deserializer.deserialize_identifier(GeneratedVisitor)
1612 }
1613 }
1614 struct GeneratedVisitor;
1615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1616 type Value = ApplyThrottleResponse;
1617
1618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1619 formatter.write_str("struct meta.ApplyThrottleResponse")
1620 }
1621
1622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1623 where
1624 V: serde::de::MapAccess<'de>,
1625 {
1626 let mut status__ = None;
1627 while let Some(k) = map_.next_key()? {
1628 match k {
1629 GeneratedField::Status => {
1630 if status__.is_some() {
1631 return Err(serde::de::Error::duplicate_field("status"));
1632 }
1633 status__ = map_.next_value()?;
1634 }
1635 }
1636 }
1637 Ok(ApplyThrottleResponse {
1638 status: status__,
1639 })
1640 }
1641 }
1642 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1643 }
1644}
1645impl serde::Serialize for CancelCreatingJobsRequest {
1646 #[allow(deprecated)]
1647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1648 where
1649 S: serde::Serializer,
1650 {
1651 use serde::ser::SerializeStruct;
1652 let mut len = 0;
1653 if self.jobs.is_some() {
1654 len += 1;
1655 }
1656 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1657 if let Some(v) = self.jobs.as_ref() {
1658 match v {
1659 cancel_creating_jobs_request::Jobs::Infos(v) => {
1660 struct_ser.serialize_field("infos", v)?;
1661 }
1662 cancel_creating_jobs_request::Jobs::Ids(v) => {
1663 struct_ser.serialize_field("ids", v)?;
1664 }
1665 }
1666 }
1667 struct_ser.end()
1668 }
1669}
1670impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1671 #[allow(deprecated)]
1672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1673 where
1674 D: serde::Deserializer<'de>,
1675 {
1676 const FIELDS: &[&str] = &[
1677 "infos",
1678 "ids",
1679 ];
1680
1681 #[allow(clippy::enum_variant_names)]
1682 enum GeneratedField {
1683 Infos,
1684 Ids,
1685 }
1686 impl<'de> serde::Deserialize<'de> for GeneratedField {
1687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1688 where
1689 D: serde::Deserializer<'de>,
1690 {
1691 struct GeneratedVisitor;
1692
1693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1694 type Value = GeneratedField;
1695
1696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1697 write!(formatter, "expected one of: {:?}", &FIELDS)
1698 }
1699
1700 #[allow(unused_variables)]
1701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1702 where
1703 E: serde::de::Error,
1704 {
1705 match value {
1706 "infos" => Ok(GeneratedField::Infos),
1707 "ids" => Ok(GeneratedField::Ids),
1708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1709 }
1710 }
1711 }
1712 deserializer.deserialize_identifier(GeneratedVisitor)
1713 }
1714 }
1715 struct GeneratedVisitor;
1716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1717 type Value = CancelCreatingJobsRequest;
1718
1719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1720 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1721 }
1722
1723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1724 where
1725 V: serde::de::MapAccess<'de>,
1726 {
1727 let mut jobs__ = None;
1728 while let Some(k) = map_.next_key()? {
1729 match k {
1730 GeneratedField::Infos => {
1731 if jobs__.is_some() {
1732 return Err(serde::de::Error::duplicate_field("infos"));
1733 }
1734 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1735;
1736 }
1737 GeneratedField::Ids => {
1738 if jobs__.is_some() {
1739 return Err(serde::de::Error::duplicate_field("ids"));
1740 }
1741 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1742;
1743 }
1744 }
1745 }
1746 Ok(CancelCreatingJobsRequest {
1747 jobs: jobs__,
1748 })
1749 }
1750 }
1751 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1752 }
1753}
1754impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1755 #[allow(deprecated)]
1756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1757 where
1758 S: serde::Serializer,
1759 {
1760 use serde::ser::SerializeStruct;
1761 let mut len = 0;
1762 if !self.job_ids.is_empty() {
1763 len += 1;
1764 }
1765 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1766 if !self.job_ids.is_empty() {
1767 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1768 }
1769 struct_ser.end()
1770 }
1771}
1772impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1773 #[allow(deprecated)]
1774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1775 where
1776 D: serde::Deserializer<'de>,
1777 {
1778 const FIELDS: &[&str] = &[
1779 "job_ids",
1780 "jobIds",
1781 ];
1782
1783 #[allow(clippy::enum_variant_names)]
1784 enum GeneratedField {
1785 JobIds,
1786 }
1787 impl<'de> serde::Deserialize<'de> for GeneratedField {
1788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1789 where
1790 D: serde::Deserializer<'de>,
1791 {
1792 struct GeneratedVisitor;
1793
1794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1795 type Value = GeneratedField;
1796
1797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1798 write!(formatter, "expected one of: {:?}", &FIELDS)
1799 }
1800
1801 #[allow(unused_variables)]
1802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1803 where
1804 E: serde::de::Error,
1805 {
1806 match value {
1807 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_identifier(GeneratedVisitor)
1813 }
1814 }
1815 struct GeneratedVisitor;
1816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1817 type Value = cancel_creating_jobs_request::CreatingJobIds;
1818
1819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1820 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1821 }
1822
1823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1824 where
1825 V: serde::de::MapAccess<'de>,
1826 {
1827 let mut job_ids__ = None;
1828 while let Some(k) = map_.next_key()? {
1829 match k {
1830 GeneratedField::JobIds => {
1831 if job_ids__.is_some() {
1832 return Err(serde::de::Error::duplicate_field("jobIds"));
1833 }
1834 job_ids__ =
1835 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1836 .into_iter().map(|x| x.0).collect())
1837 ;
1838 }
1839 }
1840 }
1841 Ok(cancel_creating_jobs_request::CreatingJobIds {
1842 job_ids: job_ids__.unwrap_or_default(),
1843 })
1844 }
1845 }
1846 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
1847 }
1848}
1849impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
1850 #[allow(deprecated)]
1851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1852 where
1853 S: serde::Serializer,
1854 {
1855 use serde::ser::SerializeStruct;
1856 let mut len = 0;
1857 if self.database_id != 0 {
1858 len += 1;
1859 }
1860 if self.schema_id != 0 {
1861 len += 1;
1862 }
1863 if !self.name.is_empty() {
1864 len += 1;
1865 }
1866 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
1867 if self.database_id != 0 {
1868 struct_ser.serialize_field("databaseId", &self.database_id)?;
1869 }
1870 if self.schema_id != 0 {
1871 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1872 }
1873 if !self.name.is_empty() {
1874 struct_ser.serialize_field("name", &self.name)?;
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "database_id",
1887 "databaseId",
1888 "schema_id",
1889 "schemaId",
1890 "name",
1891 ];
1892
1893 #[allow(clippy::enum_variant_names)]
1894 enum GeneratedField {
1895 DatabaseId,
1896 SchemaId,
1897 Name,
1898 }
1899 impl<'de> serde::Deserialize<'de> for GeneratedField {
1900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1901 where
1902 D: serde::Deserializer<'de>,
1903 {
1904 struct GeneratedVisitor;
1905
1906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1907 type Value = GeneratedField;
1908
1909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1910 write!(formatter, "expected one of: {:?}", &FIELDS)
1911 }
1912
1913 #[allow(unused_variables)]
1914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1915 where
1916 E: serde::de::Error,
1917 {
1918 match value {
1919 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1920 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1921 "name" => Ok(GeneratedField::Name),
1922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1923 }
1924 }
1925 }
1926 deserializer.deserialize_identifier(GeneratedVisitor)
1927 }
1928 }
1929 struct GeneratedVisitor;
1930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1931 type Value = cancel_creating_jobs_request::CreatingJobInfo;
1932
1933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1934 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
1935 }
1936
1937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
1938 where
1939 V: serde::de::MapAccess<'de>,
1940 {
1941 let mut database_id__ = None;
1942 let mut schema_id__ = None;
1943 let mut name__ = None;
1944 while let Some(k) = map_.next_key()? {
1945 match k {
1946 GeneratedField::DatabaseId => {
1947 if database_id__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("databaseId"));
1949 }
1950 database_id__ =
1951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1952 ;
1953 }
1954 GeneratedField::SchemaId => {
1955 if schema_id__.is_some() {
1956 return Err(serde::de::Error::duplicate_field("schemaId"));
1957 }
1958 schema_id__ =
1959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1960 ;
1961 }
1962 GeneratedField::Name => {
1963 if name__.is_some() {
1964 return Err(serde::de::Error::duplicate_field("name"));
1965 }
1966 name__ = Some(map_.next_value()?);
1967 }
1968 }
1969 }
1970 Ok(cancel_creating_jobs_request::CreatingJobInfo {
1971 database_id: database_id__.unwrap_or_default(),
1972 schema_id: schema_id__.unwrap_or_default(),
1973 name: name__.unwrap_or_default(),
1974 })
1975 }
1976 }
1977 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
1978 }
1979}
1980impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
1981 #[allow(deprecated)]
1982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1983 where
1984 S: serde::Serializer,
1985 {
1986 use serde::ser::SerializeStruct;
1987 let mut len = 0;
1988 if !self.infos.is_empty() {
1989 len += 1;
1990 }
1991 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
1992 if !self.infos.is_empty() {
1993 struct_ser.serialize_field("infos", &self.infos)?;
1994 }
1995 struct_ser.end()
1996 }
1997}
1998impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
1999 #[allow(deprecated)]
2000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2001 where
2002 D: serde::Deserializer<'de>,
2003 {
2004 const FIELDS: &[&str] = &[
2005 "infos",
2006 ];
2007
2008 #[allow(clippy::enum_variant_names)]
2009 enum GeneratedField {
2010 Infos,
2011 }
2012 impl<'de> serde::Deserialize<'de> for GeneratedField {
2013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2014 where
2015 D: serde::Deserializer<'de>,
2016 {
2017 struct GeneratedVisitor;
2018
2019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2020 type Value = GeneratedField;
2021
2022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2023 write!(formatter, "expected one of: {:?}", &FIELDS)
2024 }
2025
2026 #[allow(unused_variables)]
2027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2028 where
2029 E: serde::de::Error,
2030 {
2031 match value {
2032 "infos" => Ok(GeneratedField::Infos),
2033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2034 }
2035 }
2036 }
2037 deserializer.deserialize_identifier(GeneratedVisitor)
2038 }
2039 }
2040 struct GeneratedVisitor;
2041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2042 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2043
2044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2045 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2046 }
2047
2048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2049 where
2050 V: serde::de::MapAccess<'de>,
2051 {
2052 let mut infos__ = None;
2053 while let Some(k) = map_.next_key()? {
2054 match k {
2055 GeneratedField::Infos => {
2056 if infos__.is_some() {
2057 return Err(serde::de::Error::duplicate_field("infos"));
2058 }
2059 infos__ = Some(map_.next_value()?);
2060 }
2061 }
2062 }
2063 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2064 infos: infos__.unwrap_or_default(),
2065 })
2066 }
2067 }
2068 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2069 }
2070}
2071impl serde::Serialize for CancelCreatingJobsResponse {
2072 #[allow(deprecated)]
2073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2074 where
2075 S: serde::Serializer,
2076 {
2077 use serde::ser::SerializeStruct;
2078 let mut len = 0;
2079 if self.status.is_some() {
2080 len += 1;
2081 }
2082 if !self.canceled_jobs.is_empty() {
2083 len += 1;
2084 }
2085 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2086 if let Some(v) = self.status.as_ref() {
2087 struct_ser.serialize_field("status", v)?;
2088 }
2089 if !self.canceled_jobs.is_empty() {
2090 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2091 }
2092 struct_ser.end()
2093 }
2094}
2095impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2096 #[allow(deprecated)]
2097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2098 where
2099 D: serde::Deserializer<'de>,
2100 {
2101 const FIELDS: &[&str] = &[
2102 "status",
2103 "canceled_jobs",
2104 "canceledJobs",
2105 ];
2106
2107 #[allow(clippy::enum_variant_names)]
2108 enum GeneratedField {
2109 Status,
2110 CanceledJobs,
2111 }
2112 impl<'de> serde::Deserialize<'de> for GeneratedField {
2113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2114 where
2115 D: serde::Deserializer<'de>,
2116 {
2117 struct GeneratedVisitor;
2118
2119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2120 type Value = GeneratedField;
2121
2122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2123 write!(formatter, "expected one of: {:?}", &FIELDS)
2124 }
2125
2126 #[allow(unused_variables)]
2127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2128 where
2129 E: serde::de::Error,
2130 {
2131 match value {
2132 "status" => Ok(GeneratedField::Status),
2133 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2135 }
2136 }
2137 }
2138 deserializer.deserialize_identifier(GeneratedVisitor)
2139 }
2140 }
2141 struct GeneratedVisitor;
2142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2143 type Value = CancelCreatingJobsResponse;
2144
2145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2146 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2147 }
2148
2149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2150 where
2151 V: serde::de::MapAccess<'de>,
2152 {
2153 let mut status__ = None;
2154 let mut canceled_jobs__ = None;
2155 while let Some(k) = map_.next_key()? {
2156 match k {
2157 GeneratedField::Status => {
2158 if status__.is_some() {
2159 return Err(serde::de::Error::duplicate_field("status"));
2160 }
2161 status__ = map_.next_value()?;
2162 }
2163 GeneratedField::CanceledJobs => {
2164 if canceled_jobs__.is_some() {
2165 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2166 }
2167 canceled_jobs__ =
2168 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2169 .into_iter().map(|x| x.0).collect())
2170 ;
2171 }
2172 }
2173 }
2174 Ok(CancelCreatingJobsResponse {
2175 status: status__,
2176 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2177 })
2178 }
2179 }
2180 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2181 }
2182}
2183impl serde::Serialize for ClusterLimit {
2184 #[allow(deprecated)]
2185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2186 where
2187 S: serde::Serializer,
2188 {
2189 use serde::ser::SerializeStruct;
2190 let mut len = 0;
2191 if self.limit.is_some() {
2192 len += 1;
2193 }
2194 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2195 if let Some(v) = self.limit.as_ref() {
2196 match v {
2197 cluster_limit::Limit::ActorCount(v) => {
2198 struct_ser.serialize_field("actorCount", v)?;
2199 }
2200 }
2201 }
2202 struct_ser.end()
2203 }
2204}
2205impl<'de> serde::Deserialize<'de> for ClusterLimit {
2206 #[allow(deprecated)]
2207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2208 where
2209 D: serde::Deserializer<'de>,
2210 {
2211 const FIELDS: &[&str] = &[
2212 "actor_count",
2213 "actorCount",
2214 ];
2215
2216 #[allow(clippy::enum_variant_names)]
2217 enum GeneratedField {
2218 ActorCount,
2219 }
2220 impl<'de> serde::Deserialize<'de> for GeneratedField {
2221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2222 where
2223 D: serde::Deserializer<'de>,
2224 {
2225 struct GeneratedVisitor;
2226
2227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2228 type Value = GeneratedField;
2229
2230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2231 write!(formatter, "expected one of: {:?}", &FIELDS)
2232 }
2233
2234 #[allow(unused_variables)]
2235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2236 where
2237 E: serde::de::Error,
2238 {
2239 match value {
2240 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2242 }
2243 }
2244 }
2245 deserializer.deserialize_identifier(GeneratedVisitor)
2246 }
2247 }
2248 struct GeneratedVisitor;
2249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2250 type Value = ClusterLimit;
2251
2252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2253 formatter.write_str("struct meta.ClusterLimit")
2254 }
2255
2256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2257 where
2258 V: serde::de::MapAccess<'de>,
2259 {
2260 let mut limit__ = None;
2261 while let Some(k) = map_.next_key()? {
2262 match k {
2263 GeneratedField::ActorCount => {
2264 if limit__.is_some() {
2265 return Err(serde::de::Error::duplicate_field("actorCount"));
2266 }
2267 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2268;
2269 }
2270 }
2271 }
2272 Ok(ClusterLimit {
2273 limit: limit__,
2274 })
2275 }
2276 }
2277 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2278 }
2279}
2280impl serde::Serialize for DeleteWorkerNodeRequest {
2281 #[allow(deprecated)]
2282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2283 where
2284 S: serde::Serializer,
2285 {
2286 use serde::ser::SerializeStruct;
2287 let mut len = 0;
2288 if self.host.is_some() {
2289 len += 1;
2290 }
2291 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2292 if let Some(v) = self.host.as_ref() {
2293 struct_ser.serialize_field("host", v)?;
2294 }
2295 struct_ser.end()
2296 }
2297}
2298impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2299 #[allow(deprecated)]
2300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2301 where
2302 D: serde::Deserializer<'de>,
2303 {
2304 const FIELDS: &[&str] = &[
2305 "host",
2306 ];
2307
2308 #[allow(clippy::enum_variant_names)]
2309 enum GeneratedField {
2310 Host,
2311 }
2312 impl<'de> serde::Deserialize<'de> for GeneratedField {
2313 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2314 where
2315 D: serde::Deserializer<'de>,
2316 {
2317 struct GeneratedVisitor;
2318
2319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2320 type Value = GeneratedField;
2321
2322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2323 write!(formatter, "expected one of: {:?}", &FIELDS)
2324 }
2325
2326 #[allow(unused_variables)]
2327 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2328 where
2329 E: serde::de::Error,
2330 {
2331 match value {
2332 "host" => Ok(GeneratedField::Host),
2333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2334 }
2335 }
2336 }
2337 deserializer.deserialize_identifier(GeneratedVisitor)
2338 }
2339 }
2340 struct GeneratedVisitor;
2341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2342 type Value = DeleteWorkerNodeRequest;
2343
2344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2345 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2346 }
2347
2348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2349 where
2350 V: serde::de::MapAccess<'de>,
2351 {
2352 let mut host__ = None;
2353 while let Some(k) = map_.next_key()? {
2354 match k {
2355 GeneratedField::Host => {
2356 if host__.is_some() {
2357 return Err(serde::de::Error::duplicate_field("host"));
2358 }
2359 host__ = map_.next_value()?;
2360 }
2361 }
2362 }
2363 Ok(DeleteWorkerNodeRequest {
2364 host: host__,
2365 })
2366 }
2367 }
2368 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2369 }
2370}
2371impl serde::Serialize for DeleteWorkerNodeResponse {
2372 #[allow(deprecated)]
2373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2374 where
2375 S: serde::Serializer,
2376 {
2377 use serde::ser::SerializeStruct;
2378 let mut len = 0;
2379 if self.status.is_some() {
2380 len += 1;
2381 }
2382 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2383 if let Some(v) = self.status.as_ref() {
2384 struct_ser.serialize_field("status", v)?;
2385 }
2386 struct_ser.end()
2387 }
2388}
2389impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2390 #[allow(deprecated)]
2391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2392 where
2393 D: serde::Deserializer<'de>,
2394 {
2395 const FIELDS: &[&str] = &[
2396 "status",
2397 ];
2398
2399 #[allow(clippy::enum_variant_names)]
2400 enum GeneratedField {
2401 Status,
2402 }
2403 impl<'de> serde::Deserialize<'de> for GeneratedField {
2404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2405 where
2406 D: serde::Deserializer<'de>,
2407 {
2408 struct GeneratedVisitor;
2409
2410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2411 type Value = GeneratedField;
2412
2413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2414 write!(formatter, "expected one of: {:?}", &FIELDS)
2415 }
2416
2417 #[allow(unused_variables)]
2418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2419 where
2420 E: serde::de::Error,
2421 {
2422 match value {
2423 "status" => Ok(GeneratedField::Status),
2424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2425 }
2426 }
2427 }
2428 deserializer.deserialize_identifier(GeneratedVisitor)
2429 }
2430 }
2431 struct GeneratedVisitor;
2432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2433 type Value = DeleteWorkerNodeResponse;
2434
2435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2436 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2437 }
2438
2439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2440 where
2441 V: serde::de::MapAccess<'de>,
2442 {
2443 let mut status__ = None;
2444 while let Some(k) = map_.next_key()? {
2445 match k {
2446 GeneratedField::Status => {
2447 if status__.is_some() {
2448 return Err(serde::de::Error::duplicate_field("status"));
2449 }
2450 status__ = map_.next_value()?;
2451 }
2452 }
2453 }
2454 Ok(DeleteWorkerNodeResponse {
2455 status: status__,
2456 })
2457 }
2458 }
2459 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2460 }
2461}
2462impl serde::Serialize for EventLog {
2463 #[allow(deprecated)]
2464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2465 where
2466 S: serde::Serializer,
2467 {
2468 use serde::ser::SerializeStruct;
2469 let mut len = 0;
2470 if self.unique_id.is_some() {
2471 len += 1;
2472 }
2473 if self.timestamp.is_some() {
2474 len += 1;
2475 }
2476 if self.event.is_some() {
2477 len += 1;
2478 }
2479 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2480 if let Some(v) = self.unique_id.as_ref() {
2481 struct_ser.serialize_field("uniqueId", v)?;
2482 }
2483 if let Some(v) = self.timestamp.as_ref() {
2484 #[allow(clippy::needless_borrow)]
2485 #[allow(clippy::needless_borrows_for_generic_args)]
2486 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2487 }
2488 if let Some(v) = self.event.as_ref() {
2489 match v {
2490 event_log::Event::CreateStreamJobFail(v) => {
2491 struct_ser.serialize_field("createStreamJobFail", v)?;
2492 }
2493 event_log::Event::DirtyStreamJobClear(v) => {
2494 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2495 }
2496 event_log::Event::MetaNodeStart(v) => {
2497 struct_ser.serialize_field("metaNodeStart", v)?;
2498 }
2499 event_log::Event::BarrierComplete(v) => {
2500 struct_ser.serialize_field("barrierComplete", v)?;
2501 }
2502 event_log::Event::InjectBarrierFail(v) => {
2503 struct_ser.serialize_field("injectBarrierFail", v)?;
2504 }
2505 event_log::Event::CollectBarrierFail(v) => {
2506 struct_ser.serialize_field("collectBarrierFail", v)?;
2507 }
2508 event_log::Event::WorkerNodePanic(v) => {
2509 struct_ser.serialize_field("workerNodePanic", v)?;
2510 }
2511 event_log::Event::AutoSchemaChangeFail(v) => {
2512 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2513 }
2514 event_log::Event::SinkFail(v) => {
2515 struct_ser.serialize_field("sinkFail", v)?;
2516 }
2517 event_log::Event::Recovery(v) => {
2518 struct_ser.serialize_field("recovery", v)?;
2519 }
2520 }
2521 }
2522 struct_ser.end()
2523 }
2524}
2525impl<'de> serde::Deserialize<'de> for EventLog {
2526 #[allow(deprecated)]
2527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2528 where
2529 D: serde::Deserializer<'de>,
2530 {
2531 const FIELDS: &[&str] = &[
2532 "unique_id",
2533 "uniqueId",
2534 "timestamp",
2535 "create_stream_job_fail",
2536 "createStreamJobFail",
2537 "dirty_stream_job_clear",
2538 "dirtyStreamJobClear",
2539 "meta_node_start",
2540 "metaNodeStart",
2541 "barrier_complete",
2542 "barrierComplete",
2543 "inject_barrier_fail",
2544 "injectBarrierFail",
2545 "collect_barrier_fail",
2546 "collectBarrierFail",
2547 "worker_node_panic",
2548 "workerNodePanic",
2549 "auto_schema_change_fail",
2550 "autoSchemaChangeFail",
2551 "sink_fail",
2552 "sinkFail",
2553 "recovery",
2554 ];
2555
2556 #[allow(clippy::enum_variant_names)]
2557 enum GeneratedField {
2558 UniqueId,
2559 Timestamp,
2560 CreateStreamJobFail,
2561 DirtyStreamJobClear,
2562 MetaNodeStart,
2563 BarrierComplete,
2564 InjectBarrierFail,
2565 CollectBarrierFail,
2566 WorkerNodePanic,
2567 AutoSchemaChangeFail,
2568 SinkFail,
2569 Recovery,
2570 }
2571 impl<'de> serde::Deserialize<'de> for GeneratedField {
2572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2573 where
2574 D: serde::Deserializer<'de>,
2575 {
2576 struct GeneratedVisitor;
2577
2578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2579 type Value = GeneratedField;
2580
2581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2582 write!(formatter, "expected one of: {:?}", &FIELDS)
2583 }
2584
2585 #[allow(unused_variables)]
2586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2587 where
2588 E: serde::de::Error,
2589 {
2590 match value {
2591 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2592 "timestamp" => Ok(GeneratedField::Timestamp),
2593 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2594 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2595 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2596 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2597 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2598 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2599 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2600 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2601 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2602 "recovery" => Ok(GeneratedField::Recovery),
2603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2604 }
2605 }
2606 }
2607 deserializer.deserialize_identifier(GeneratedVisitor)
2608 }
2609 }
2610 struct GeneratedVisitor;
2611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2612 type Value = EventLog;
2613
2614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2615 formatter.write_str("struct meta.EventLog")
2616 }
2617
2618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2619 where
2620 V: serde::de::MapAccess<'de>,
2621 {
2622 let mut unique_id__ = None;
2623 let mut timestamp__ = None;
2624 let mut event__ = None;
2625 while let Some(k) = map_.next_key()? {
2626 match k {
2627 GeneratedField::UniqueId => {
2628 if unique_id__.is_some() {
2629 return Err(serde::de::Error::duplicate_field("uniqueId"));
2630 }
2631 unique_id__ = map_.next_value()?;
2632 }
2633 GeneratedField::Timestamp => {
2634 if timestamp__.is_some() {
2635 return Err(serde::de::Error::duplicate_field("timestamp"));
2636 }
2637 timestamp__ =
2638 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2639 ;
2640 }
2641 GeneratedField::CreateStreamJobFail => {
2642 if event__.is_some() {
2643 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2644 }
2645 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2646;
2647 }
2648 GeneratedField::DirtyStreamJobClear => {
2649 if event__.is_some() {
2650 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2651 }
2652 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2653;
2654 }
2655 GeneratedField::MetaNodeStart => {
2656 if event__.is_some() {
2657 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2658 }
2659 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2660;
2661 }
2662 GeneratedField::BarrierComplete => {
2663 if event__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2665 }
2666 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2667;
2668 }
2669 GeneratedField::InjectBarrierFail => {
2670 if event__.is_some() {
2671 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2672 }
2673 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2674;
2675 }
2676 GeneratedField::CollectBarrierFail => {
2677 if event__.is_some() {
2678 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2679 }
2680 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2681;
2682 }
2683 GeneratedField::WorkerNodePanic => {
2684 if event__.is_some() {
2685 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2686 }
2687 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2688;
2689 }
2690 GeneratedField::AutoSchemaChangeFail => {
2691 if event__.is_some() {
2692 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2693 }
2694 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2695;
2696 }
2697 GeneratedField::SinkFail => {
2698 if event__.is_some() {
2699 return Err(serde::de::Error::duplicate_field("sinkFail"));
2700 }
2701 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2702;
2703 }
2704 GeneratedField::Recovery => {
2705 if event__.is_some() {
2706 return Err(serde::de::Error::duplicate_field("recovery"));
2707 }
2708 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2709;
2710 }
2711 }
2712 }
2713 Ok(EventLog {
2714 unique_id: unique_id__,
2715 timestamp: timestamp__,
2716 event: event__,
2717 })
2718 }
2719 }
2720 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2721 }
2722}
2723impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2724 #[allow(deprecated)]
2725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2726 where
2727 S: serde::Serializer,
2728 {
2729 use serde::ser::SerializeStruct;
2730 let mut len = 0;
2731 if self.table_id != 0 {
2732 len += 1;
2733 }
2734 if !self.table_name.is_empty() {
2735 len += 1;
2736 }
2737 if !self.cdc_table_id.is_empty() {
2738 len += 1;
2739 }
2740 if !self.upstream_ddl.is_empty() {
2741 len += 1;
2742 }
2743 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2744 if self.table_id != 0 {
2745 struct_ser.serialize_field("tableId", &self.table_id)?;
2746 }
2747 if !self.table_name.is_empty() {
2748 struct_ser.serialize_field("tableName", &self.table_name)?;
2749 }
2750 if !self.cdc_table_id.is_empty() {
2751 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2752 }
2753 if !self.upstream_ddl.is_empty() {
2754 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2755 }
2756 struct_ser.end()
2757 }
2758}
2759impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2760 #[allow(deprecated)]
2761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2762 where
2763 D: serde::Deserializer<'de>,
2764 {
2765 const FIELDS: &[&str] = &[
2766 "table_id",
2767 "tableId",
2768 "table_name",
2769 "tableName",
2770 "cdc_table_id",
2771 "cdcTableId",
2772 "upstream_ddl",
2773 "upstreamDdl",
2774 ];
2775
2776 #[allow(clippy::enum_variant_names)]
2777 enum GeneratedField {
2778 TableId,
2779 TableName,
2780 CdcTableId,
2781 UpstreamDdl,
2782 }
2783 impl<'de> serde::Deserialize<'de> for GeneratedField {
2784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2785 where
2786 D: serde::Deserializer<'de>,
2787 {
2788 struct GeneratedVisitor;
2789
2790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2791 type Value = GeneratedField;
2792
2793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2794 write!(formatter, "expected one of: {:?}", &FIELDS)
2795 }
2796
2797 #[allow(unused_variables)]
2798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2799 where
2800 E: serde::de::Error,
2801 {
2802 match value {
2803 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2804 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2805 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2806 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2808 }
2809 }
2810 }
2811 deserializer.deserialize_identifier(GeneratedVisitor)
2812 }
2813 }
2814 struct GeneratedVisitor;
2815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2816 type Value = event_log::EventAutoSchemaChangeFail;
2817
2818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2819 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2820 }
2821
2822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2823 where
2824 V: serde::de::MapAccess<'de>,
2825 {
2826 let mut table_id__ = None;
2827 let mut table_name__ = None;
2828 let mut cdc_table_id__ = None;
2829 let mut upstream_ddl__ = None;
2830 while let Some(k) = map_.next_key()? {
2831 match k {
2832 GeneratedField::TableId => {
2833 if table_id__.is_some() {
2834 return Err(serde::de::Error::duplicate_field("tableId"));
2835 }
2836 table_id__ =
2837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2838 ;
2839 }
2840 GeneratedField::TableName => {
2841 if table_name__.is_some() {
2842 return Err(serde::de::Error::duplicate_field("tableName"));
2843 }
2844 table_name__ = Some(map_.next_value()?);
2845 }
2846 GeneratedField::CdcTableId => {
2847 if cdc_table_id__.is_some() {
2848 return Err(serde::de::Error::duplicate_field("cdcTableId"));
2849 }
2850 cdc_table_id__ = Some(map_.next_value()?);
2851 }
2852 GeneratedField::UpstreamDdl => {
2853 if upstream_ddl__.is_some() {
2854 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
2855 }
2856 upstream_ddl__ = Some(map_.next_value()?);
2857 }
2858 }
2859 }
2860 Ok(event_log::EventAutoSchemaChangeFail {
2861 table_id: table_id__.unwrap_or_default(),
2862 table_name: table_name__.unwrap_or_default(),
2863 cdc_table_id: cdc_table_id__.unwrap_or_default(),
2864 upstream_ddl: upstream_ddl__.unwrap_or_default(),
2865 })
2866 }
2867 }
2868 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
2869 }
2870}
2871impl serde::Serialize for event_log::EventBarrierComplete {
2872 #[allow(deprecated)]
2873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2874 where
2875 S: serde::Serializer,
2876 {
2877 use serde::ser::SerializeStruct;
2878 let mut len = 0;
2879 if self.prev_epoch != 0 {
2880 len += 1;
2881 }
2882 if self.cur_epoch != 0 {
2883 len += 1;
2884 }
2885 if self.duration_sec != 0. {
2886 len += 1;
2887 }
2888 if !self.command.is_empty() {
2889 len += 1;
2890 }
2891 if !self.barrier_kind.is_empty() {
2892 len += 1;
2893 }
2894 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
2895 if self.prev_epoch != 0 {
2896 #[allow(clippy::needless_borrow)]
2897 #[allow(clippy::needless_borrows_for_generic_args)]
2898 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
2899 }
2900 if self.cur_epoch != 0 {
2901 #[allow(clippy::needless_borrow)]
2902 #[allow(clippy::needless_borrows_for_generic_args)]
2903 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
2904 }
2905 if self.duration_sec != 0. {
2906 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
2907 }
2908 if !self.command.is_empty() {
2909 struct_ser.serialize_field("command", &self.command)?;
2910 }
2911 if !self.barrier_kind.is_empty() {
2912 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
2913 }
2914 struct_ser.end()
2915 }
2916}
2917impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
2918 #[allow(deprecated)]
2919 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2920 where
2921 D: serde::Deserializer<'de>,
2922 {
2923 const FIELDS: &[&str] = &[
2924 "prev_epoch",
2925 "prevEpoch",
2926 "cur_epoch",
2927 "curEpoch",
2928 "duration_sec",
2929 "durationSec",
2930 "command",
2931 "barrier_kind",
2932 "barrierKind",
2933 ];
2934
2935 #[allow(clippy::enum_variant_names)]
2936 enum GeneratedField {
2937 PrevEpoch,
2938 CurEpoch,
2939 DurationSec,
2940 Command,
2941 BarrierKind,
2942 }
2943 impl<'de> serde::Deserialize<'de> for GeneratedField {
2944 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2945 where
2946 D: serde::Deserializer<'de>,
2947 {
2948 struct GeneratedVisitor;
2949
2950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2951 type Value = GeneratedField;
2952
2953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2954 write!(formatter, "expected one of: {:?}", &FIELDS)
2955 }
2956
2957 #[allow(unused_variables)]
2958 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2959 where
2960 E: serde::de::Error,
2961 {
2962 match value {
2963 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
2964 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
2965 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
2966 "command" => Ok(GeneratedField::Command),
2967 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
2968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2969 }
2970 }
2971 }
2972 deserializer.deserialize_identifier(GeneratedVisitor)
2973 }
2974 }
2975 struct GeneratedVisitor;
2976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2977 type Value = event_log::EventBarrierComplete;
2978
2979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2980 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
2981 }
2982
2983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
2984 where
2985 V: serde::de::MapAccess<'de>,
2986 {
2987 let mut prev_epoch__ = None;
2988 let mut cur_epoch__ = None;
2989 let mut duration_sec__ = None;
2990 let mut command__ = None;
2991 let mut barrier_kind__ = None;
2992 while let Some(k) = map_.next_key()? {
2993 match k {
2994 GeneratedField::PrevEpoch => {
2995 if prev_epoch__.is_some() {
2996 return Err(serde::de::Error::duplicate_field("prevEpoch"));
2997 }
2998 prev_epoch__ =
2999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3000 ;
3001 }
3002 GeneratedField::CurEpoch => {
3003 if cur_epoch__.is_some() {
3004 return Err(serde::de::Error::duplicate_field("curEpoch"));
3005 }
3006 cur_epoch__ =
3007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3008 ;
3009 }
3010 GeneratedField::DurationSec => {
3011 if duration_sec__.is_some() {
3012 return Err(serde::de::Error::duplicate_field("durationSec"));
3013 }
3014 duration_sec__ =
3015 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3016 ;
3017 }
3018 GeneratedField::Command => {
3019 if command__.is_some() {
3020 return Err(serde::de::Error::duplicate_field("command"));
3021 }
3022 command__ = Some(map_.next_value()?);
3023 }
3024 GeneratedField::BarrierKind => {
3025 if barrier_kind__.is_some() {
3026 return Err(serde::de::Error::duplicate_field("barrierKind"));
3027 }
3028 barrier_kind__ = Some(map_.next_value()?);
3029 }
3030 }
3031 }
3032 Ok(event_log::EventBarrierComplete {
3033 prev_epoch: prev_epoch__.unwrap_or_default(),
3034 cur_epoch: cur_epoch__.unwrap_or_default(),
3035 duration_sec: duration_sec__.unwrap_or_default(),
3036 command: command__.unwrap_or_default(),
3037 barrier_kind: barrier_kind__.unwrap_or_default(),
3038 })
3039 }
3040 }
3041 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3042 }
3043}
3044impl serde::Serialize for event_log::EventCollectBarrierFail {
3045 #[allow(deprecated)]
3046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3047 where
3048 S: serde::Serializer,
3049 {
3050 use serde::ser::SerializeStruct;
3051 let mut len = 0;
3052 if !self.error.is_empty() {
3053 len += 1;
3054 }
3055 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3056 if !self.error.is_empty() {
3057 struct_ser.serialize_field("error", &self.error)?;
3058 }
3059 struct_ser.end()
3060 }
3061}
3062impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3063 #[allow(deprecated)]
3064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3065 where
3066 D: serde::Deserializer<'de>,
3067 {
3068 const FIELDS: &[&str] = &[
3069 "error",
3070 ];
3071
3072 #[allow(clippy::enum_variant_names)]
3073 enum GeneratedField {
3074 Error,
3075 }
3076 impl<'de> serde::Deserialize<'de> for GeneratedField {
3077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3078 where
3079 D: serde::Deserializer<'de>,
3080 {
3081 struct GeneratedVisitor;
3082
3083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3084 type Value = GeneratedField;
3085
3086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3087 write!(formatter, "expected one of: {:?}", &FIELDS)
3088 }
3089
3090 #[allow(unused_variables)]
3091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3092 where
3093 E: serde::de::Error,
3094 {
3095 match value {
3096 "error" => Ok(GeneratedField::Error),
3097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3098 }
3099 }
3100 }
3101 deserializer.deserialize_identifier(GeneratedVisitor)
3102 }
3103 }
3104 struct GeneratedVisitor;
3105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3106 type Value = event_log::EventCollectBarrierFail;
3107
3108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3109 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3110 }
3111
3112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3113 where
3114 V: serde::de::MapAccess<'de>,
3115 {
3116 let mut error__ = None;
3117 while let Some(k) = map_.next_key()? {
3118 match k {
3119 GeneratedField::Error => {
3120 if error__.is_some() {
3121 return Err(serde::de::Error::duplicate_field("error"));
3122 }
3123 error__ = Some(map_.next_value()?);
3124 }
3125 }
3126 }
3127 Ok(event_log::EventCollectBarrierFail {
3128 error: error__.unwrap_or_default(),
3129 })
3130 }
3131 }
3132 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3133 }
3134}
3135impl serde::Serialize for event_log::EventCreateStreamJobFail {
3136 #[allow(deprecated)]
3137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3138 where
3139 S: serde::Serializer,
3140 {
3141 use serde::ser::SerializeStruct;
3142 let mut len = 0;
3143 if self.id != 0 {
3144 len += 1;
3145 }
3146 if !self.name.is_empty() {
3147 len += 1;
3148 }
3149 if !self.definition.is_empty() {
3150 len += 1;
3151 }
3152 if !self.error.is_empty() {
3153 len += 1;
3154 }
3155 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3156 if self.id != 0 {
3157 struct_ser.serialize_field("id", &self.id)?;
3158 }
3159 if !self.name.is_empty() {
3160 struct_ser.serialize_field("name", &self.name)?;
3161 }
3162 if !self.definition.is_empty() {
3163 struct_ser.serialize_field("definition", &self.definition)?;
3164 }
3165 if !self.error.is_empty() {
3166 struct_ser.serialize_field("error", &self.error)?;
3167 }
3168 struct_ser.end()
3169 }
3170}
3171impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3172 #[allow(deprecated)]
3173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3174 where
3175 D: serde::Deserializer<'de>,
3176 {
3177 const FIELDS: &[&str] = &[
3178 "id",
3179 "name",
3180 "definition",
3181 "error",
3182 ];
3183
3184 #[allow(clippy::enum_variant_names)]
3185 enum GeneratedField {
3186 Id,
3187 Name,
3188 Definition,
3189 Error,
3190 }
3191 impl<'de> serde::Deserialize<'de> for GeneratedField {
3192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3193 where
3194 D: serde::Deserializer<'de>,
3195 {
3196 struct GeneratedVisitor;
3197
3198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3199 type Value = GeneratedField;
3200
3201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3202 write!(formatter, "expected one of: {:?}", &FIELDS)
3203 }
3204
3205 #[allow(unused_variables)]
3206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3207 where
3208 E: serde::de::Error,
3209 {
3210 match value {
3211 "id" => Ok(GeneratedField::Id),
3212 "name" => Ok(GeneratedField::Name),
3213 "definition" => Ok(GeneratedField::Definition),
3214 "error" => Ok(GeneratedField::Error),
3215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3216 }
3217 }
3218 }
3219 deserializer.deserialize_identifier(GeneratedVisitor)
3220 }
3221 }
3222 struct GeneratedVisitor;
3223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3224 type Value = event_log::EventCreateStreamJobFail;
3225
3226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3227 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3228 }
3229
3230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3231 where
3232 V: serde::de::MapAccess<'de>,
3233 {
3234 let mut id__ = None;
3235 let mut name__ = None;
3236 let mut definition__ = None;
3237 let mut error__ = None;
3238 while let Some(k) = map_.next_key()? {
3239 match k {
3240 GeneratedField::Id => {
3241 if id__.is_some() {
3242 return Err(serde::de::Error::duplicate_field("id"));
3243 }
3244 id__ =
3245 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3246 ;
3247 }
3248 GeneratedField::Name => {
3249 if name__.is_some() {
3250 return Err(serde::de::Error::duplicate_field("name"));
3251 }
3252 name__ = Some(map_.next_value()?);
3253 }
3254 GeneratedField::Definition => {
3255 if definition__.is_some() {
3256 return Err(serde::de::Error::duplicate_field("definition"));
3257 }
3258 definition__ = Some(map_.next_value()?);
3259 }
3260 GeneratedField::Error => {
3261 if error__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("error"));
3263 }
3264 error__ = Some(map_.next_value()?);
3265 }
3266 }
3267 }
3268 Ok(event_log::EventCreateStreamJobFail {
3269 id: id__.unwrap_or_default(),
3270 name: name__.unwrap_or_default(),
3271 definition: definition__.unwrap_or_default(),
3272 error: error__.unwrap_or_default(),
3273 })
3274 }
3275 }
3276 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3277 }
3278}
3279impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3280 #[allow(deprecated)]
3281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3282 where
3283 S: serde::Serializer,
3284 {
3285 use serde::ser::SerializeStruct;
3286 let mut len = 0;
3287 if self.id != 0 {
3288 len += 1;
3289 }
3290 if !self.name.is_empty() {
3291 len += 1;
3292 }
3293 if !self.definition.is_empty() {
3294 len += 1;
3295 }
3296 if !self.error.is_empty() {
3297 len += 1;
3298 }
3299 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3300 if self.id != 0 {
3301 struct_ser.serialize_field("id", &self.id)?;
3302 }
3303 if !self.name.is_empty() {
3304 struct_ser.serialize_field("name", &self.name)?;
3305 }
3306 if !self.definition.is_empty() {
3307 struct_ser.serialize_field("definition", &self.definition)?;
3308 }
3309 if !self.error.is_empty() {
3310 struct_ser.serialize_field("error", &self.error)?;
3311 }
3312 struct_ser.end()
3313 }
3314}
3315impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3316 #[allow(deprecated)]
3317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3318 where
3319 D: serde::Deserializer<'de>,
3320 {
3321 const FIELDS: &[&str] = &[
3322 "id",
3323 "name",
3324 "definition",
3325 "error",
3326 ];
3327
3328 #[allow(clippy::enum_variant_names)]
3329 enum GeneratedField {
3330 Id,
3331 Name,
3332 Definition,
3333 Error,
3334 }
3335 impl<'de> serde::Deserialize<'de> for GeneratedField {
3336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3337 where
3338 D: serde::Deserializer<'de>,
3339 {
3340 struct GeneratedVisitor;
3341
3342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3343 type Value = GeneratedField;
3344
3345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3346 write!(formatter, "expected one of: {:?}", &FIELDS)
3347 }
3348
3349 #[allow(unused_variables)]
3350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3351 where
3352 E: serde::de::Error,
3353 {
3354 match value {
3355 "id" => Ok(GeneratedField::Id),
3356 "name" => Ok(GeneratedField::Name),
3357 "definition" => Ok(GeneratedField::Definition),
3358 "error" => Ok(GeneratedField::Error),
3359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3360 }
3361 }
3362 }
3363 deserializer.deserialize_identifier(GeneratedVisitor)
3364 }
3365 }
3366 struct GeneratedVisitor;
3367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3368 type Value = event_log::EventDirtyStreamJobClear;
3369
3370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3371 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3372 }
3373
3374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3375 where
3376 V: serde::de::MapAccess<'de>,
3377 {
3378 let mut id__ = None;
3379 let mut name__ = None;
3380 let mut definition__ = None;
3381 let mut error__ = None;
3382 while let Some(k) = map_.next_key()? {
3383 match k {
3384 GeneratedField::Id => {
3385 if id__.is_some() {
3386 return Err(serde::de::Error::duplicate_field("id"));
3387 }
3388 id__ =
3389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3390 ;
3391 }
3392 GeneratedField::Name => {
3393 if name__.is_some() {
3394 return Err(serde::de::Error::duplicate_field("name"));
3395 }
3396 name__ = Some(map_.next_value()?);
3397 }
3398 GeneratedField::Definition => {
3399 if definition__.is_some() {
3400 return Err(serde::de::Error::duplicate_field("definition"));
3401 }
3402 definition__ = Some(map_.next_value()?);
3403 }
3404 GeneratedField::Error => {
3405 if error__.is_some() {
3406 return Err(serde::de::Error::duplicate_field("error"));
3407 }
3408 error__ = Some(map_.next_value()?);
3409 }
3410 }
3411 }
3412 Ok(event_log::EventDirtyStreamJobClear {
3413 id: id__.unwrap_or_default(),
3414 name: name__.unwrap_or_default(),
3415 definition: definition__.unwrap_or_default(),
3416 error: error__.unwrap_or_default(),
3417 })
3418 }
3419 }
3420 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3421 }
3422}
3423impl serde::Serialize for event_log::EventInjectBarrierFail {
3424 #[allow(deprecated)]
3425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3426 where
3427 S: serde::Serializer,
3428 {
3429 use serde::ser::SerializeStruct;
3430 let mut len = 0;
3431 if self.prev_epoch != 0 {
3432 len += 1;
3433 }
3434 if self.cur_epoch != 0 {
3435 len += 1;
3436 }
3437 if !self.error.is_empty() {
3438 len += 1;
3439 }
3440 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3441 if self.prev_epoch != 0 {
3442 #[allow(clippy::needless_borrow)]
3443 #[allow(clippy::needless_borrows_for_generic_args)]
3444 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3445 }
3446 if self.cur_epoch != 0 {
3447 #[allow(clippy::needless_borrow)]
3448 #[allow(clippy::needless_borrows_for_generic_args)]
3449 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3450 }
3451 if !self.error.is_empty() {
3452 struct_ser.serialize_field("error", &self.error)?;
3453 }
3454 struct_ser.end()
3455 }
3456}
3457impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3458 #[allow(deprecated)]
3459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3460 where
3461 D: serde::Deserializer<'de>,
3462 {
3463 const FIELDS: &[&str] = &[
3464 "prev_epoch",
3465 "prevEpoch",
3466 "cur_epoch",
3467 "curEpoch",
3468 "error",
3469 ];
3470
3471 #[allow(clippy::enum_variant_names)]
3472 enum GeneratedField {
3473 PrevEpoch,
3474 CurEpoch,
3475 Error,
3476 }
3477 impl<'de> serde::Deserialize<'de> for GeneratedField {
3478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3479 where
3480 D: serde::Deserializer<'de>,
3481 {
3482 struct GeneratedVisitor;
3483
3484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3485 type Value = GeneratedField;
3486
3487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3488 write!(formatter, "expected one of: {:?}", &FIELDS)
3489 }
3490
3491 #[allow(unused_variables)]
3492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3493 where
3494 E: serde::de::Error,
3495 {
3496 match value {
3497 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3498 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3499 "error" => Ok(GeneratedField::Error),
3500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3501 }
3502 }
3503 }
3504 deserializer.deserialize_identifier(GeneratedVisitor)
3505 }
3506 }
3507 struct GeneratedVisitor;
3508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3509 type Value = event_log::EventInjectBarrierFail;
3510
3511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3512 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3513 }
3514
3515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3516 where
3517 V: serde::de::MapAccess<'de>,
3518 {
3519 let mut prev_epoch__ = None;
3520 let mut cur_epoch__ = None;
3521 let mut error__ = None;
3522 while let Some(k) = map_.next_key()? {
3523 match k {
3524 GeneratedField::PrevEpoch => {
3525 if prev_epoch__.is_some() {
3526 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3527 }
3528 prev_epoch__ =
3529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3530 ;
3531 }
3532 GeneratedField::CurEpoch => {
3533 if cur_epoch__.is_some() {
3534 return Err(serde::de::Error::duplicate_field("curEpoch"));
3535 }
3536 cur_epoch__ =
3537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3538 ;
3539 }
3540 GeneratedField::Error => {
3541 if error__.is_some() {
3542 return Err(serde::de::Error::duplicate_field("error"));
3543 }
3544 error__ = Some(map_.next_value()?);
3545 }
3546 }
3547 }
3548 Ok(event_log::EventInjectBarrierFail {
3549 prev_epoch: prev_epoch__.unwrap_or_default(),
3550 cur_epoch: cur_epoch__.unwrap_or_default(),
3551 error: error__.unwrap_or_default(),
3552 })
3553 }
3554 }
3555 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3556 }
3557}
3558impl serde::Serialize for event_log::EventMetaNodeStart {
3559 #[allow(deprecated)]
3560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3561 where
3562 S: serde::Serializer,
3563 {
3564 use serde::ser::SerializeStruct;
3565 let mut len = 0;
3566 if !self.advertise_addr.is_empty() {
3567 len += 1;
3568 }
3569 if !self.listen_addr.is_empty() {
3570 len += 1;
3571 }
3572 if !self.opts.is_empty() {
3573 len += 1;
3574 }
3575 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3576 if !self.advertise_addr.is_empty() {
3577 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3578 }
3579 if !self.listen_addr.is_empty() {
3580 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3581 }
3582 if !self.opts.is_empty() {
3583 struct_ser.serialize_field("opts", &self.opts)?;
3584 }
3585 struct_ser.end()
3586 }
3587}
3588impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3589 #[allow(deprecated)]
3590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3591 where
3592 D: serde::Deserializer<'de>,
3593 {
3594 const FIELDS: &[&str] = &[
3595 "advertise_addr",
3596 "advertiseAddr",
3597 "listen_addr",
3598 "listenAddr",
3599 "opts",
3600 ];
3601
3602 #[allow(clippy::enum_variant_names)]
3603 enum GeneratedField {
3604 AdvertiseAddr,
3605 ListenAddr,
3606 Opts,
3607 }
3608 impl<'de> serde::Deserialize<'de> for GeneratedField {
3609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3610 where
3611 D: serde::Deserializer<'de>,
3612 {
3613 struct GeneratedVisitor;
3614
3615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3616 type Value = GeneratedField;
3617
3618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3619 write!(formatter, "expected one of: {:?}", &FIELDS)
3620 }
3621
3622 #[allow(unused_variables)]
3623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3624 where
3625 E: serde::de::Error,
3626 {
3627 match value {
3628 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3629 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3630 "opts" => Ok(GeneratedField::Opts),
3631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632 }
3633 }
3634 }
3635 deserializer.deserialize_identifier(GeneratedVisitor)
3636 }
3637 }
3638 struct GeneratedVisitor;
3639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640 type Value = event_log::EventMetaNodeStart;
3641
3642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3644 }
3645
3646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3647 where
3648 V: serde::de::MapAccess<'de>,
3649 {
3650 let mut advertise_addr__ = None;
3651 let mut listen_addr__ = None;
3652 let mut opts__ = None;
3653 while let Some(k) = map_.next_key()? {
3654 match k {
3655 GeneratedField::AdvertiseAddr => {
3656 if advertise_addr__.is_some() {
3657 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3658 }
3659 advertise_addr__ = Some(map_.next_value()?);
3660 }
3661 GeneratedField::ListenAddr => {
3662 if listen_addr__.is_some() {
3663 return Err(serde::de::Error::duplicate_field("listenAddr"));
3664 }
3665 listen_addr__ = Some(map_.next_value()?);
3666 }
3667 GeneratedField::Opts => {
3668 if opts__.is_some() {
3669 return Err(serde::de::Error::duplicate_field("opts"));
3670 }
3671 opts__ = Some(map_.next_value()?);
3672 }
3673 }
3674 }
3675 Ok(event_log::EventMetaNodeStart {
3676 advertise_addr: advertise_addr__.unwrap_or_default(),
3677 listen_addr: listen_addr__.unwrap_or_default(),
3678 opts: opts__.unwrap_or_default(),
3679 })
3680 }
3681 }
3682 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3683 }
3684}
3685impl serde::Serialize for event_log::EventRecovery {
3686 #[allow(deprecated)]
3687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3688 where
3689 S: serde::Serializer,
3690 {
3691 use serde::ser::SerializeStruct;
3692 let mut len = 0;
3693 if self.recovery_event.is_some() {
3694 len += 1;
3695 }
3696 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3697 if let Some(v) = self.recovery_event.as_ref() {
3698 match v {
3699 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3700 struct_ser.serialize_field("globalStart", v)?;
3701 }
3702 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3703 struct_ser.serialize_field("globalSuccess", v)?;
3704 }
3705 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3706 struct_ser.serialize_field("globalFailure", v)?;
3707 }
3708 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3709 struct_ser.serialize_field("databaseStart", v)?;
3710 }
3711 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3712 struct_ser.serialize_field("databaseFailure", v)?;
3713 }
3714 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3715 struct_ser.serialize_field("databaseSuccess", v)?;
3716 }
3717 }
3718 }
3719 struct_ser.end()
3720 }
3721}
3722impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3723 #[allow(deprecated)]
3724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3725 where
3726 D: serde::Deserializer<'de>,
3727 {
3728 const FIELDS: &[&str] = &[
3729 "global_start",
3730 "globalStart",
3731 "global_success",
3732 "globalSuccess",
3733 "global_failure",
3734 "globalFailure",
3735 "database_start",
3736 "databaseStart",
3737 "database_failure",
3738 "databaseFailure",
3739 "database_success",
3740 "databaseSuccess",
3741 ];
3742
3743 #[allow(clippy::enum_variant_names)]
3744 enum GeneratedField {
3745 GlobalStart,
3746 GlobalSuccess,
3747 GlobalFailure,
3748 DatabaseStart,
3749 DatabaseFailure,
3750 DatabaseSuccess,
3751 }
3752 impl<'de> serde::Deserialize<'de> for GeneratedField {
3753 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3754 where
3755 D: serde::Deserializer<'de>,
3756 {
3757 struct GeneratedVisitor;
3758
3759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3760 type Value = GeneratedField;
3761
3762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3763 write!(formatter, "expected one of: {:?}", &FIELDS)
3764 }
3765
3766 #[allow(unused_variables)]
3767 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3768 where
3769 E: serde::de::Error,
3770 {
3771 match value {
3772 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3773 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3774 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3775 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3776 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3777 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3779 }
3780 }
3781 }
3782 deserializer.deserialize_identifier(GeneratedVisitor)
3783 }
3784 }
3785 struct GeneratedVisitor;
3786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3787 type Value = event_log::EventRecovery;
3788
3789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790 formatter.write_str("struct meta.EventLog.EventRecovery")
3791 }
3792
3793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3794 where
3795 V: serde::de::MapAccess<'de>,
3796 {
3797 let mut recovery_event__ = None;
3798 while let Some(k) = map_.next_key()? {
3799 match k {
3800 GeneratedField::GlobalStart => {
3801 if recovery_event__.is_some() {
3802 return Err(serde::de::Error::duplicate_field("globalStart"));
3803 }
3804 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3805;
3806 }
3807 GeneratedField::GlobalSuccess => {
3808 if recovery_event__.is_some() {
3809 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3810 }
3811 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3812;
3813 }
3814 GeneratedField::GlobalFailure => {
3815 if recovery_event__.is_some() {
3816 return Err(serde::de::Error::duplicate_field("globalFailure"));
3817 }
3818 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3819;
3820 }
3821 GeneratedField::DatabaseStart => {
3822 if recovery_event__.is_some() {
3823 return Err(serde::de::Error::duplicate_field("databaseStart"));
3824 }
3825 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3826;
3827 }
3828 GeneratedField::DatabaseFailure => {
3829 if recovery_event__.is_some() {
3830 return Err(serde::de::Error::duplicate_field("databaseFailure"));
3831 }
3832 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
3833;
3834 }
3835 GeneratedField::DatabaseSuccess => {
3836 if recovery_event__.is_some() {
3837 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
3838 }
3839 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
3840;
3841 }
3842 }
3843 }
3844 Ok(event_log::EventRecovery {
3845 recovery_event: recovery_event__,
3846 })
3847 }
3848 }
3849 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
3850 }
3851}
3852impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
3853 #[allow(deprecated)]
3854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3855 where
3856 S: serde::Serializer,
3857 {
3858 use serde::ser::SerializeStruct;
3859 let mut len = 0;
3860 if self.database_id != 0 {
3861 len += 1;
3862 }
3863 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
3864 if self.database_id != 0 {
3865 struct_ser.serialize_field("databaseId", &self.database_id)?;
3866 }
3867 struct_ser.end()
3868 }
3869}
3870impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
3871 #[allow(deprecated)]
3872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3873 where
3874 D: serde::Deserializer<'de>,
3875 {
3876 const FIELDS: &[&str] = &[
3877 "database_id",
3878 "databaseId",
3879 ];
3880
3881 #[allow(clippy::enum_variant_names)]
3882 enum GeneratedField {
3883 DatabaseId,
3884 }
3885 impl<'de> serde::Deserialize<'de> for GeneratedField {
3886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3887 where
3888 D: serde::Deserializer<'de>,
3889 {
3890 struct GeneratedVisitor;
3891
3892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3893 type Value = GeneratedField;
3894
3895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3896 write!(formatter, "expected one of: {:?}", &FIELDS)
3897 }
3898
3899 #[allow(unused_variables)]
3900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3901 where
3902 E: serde::de::Error,
3903 {
3904 match value {
3905 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3906 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3907 }
3908 }
3909 }
3910 deserializer.deserialize_identifier(GeneratedVisitor)
3911 }
3912 }
3913 struct GeneratedVisitor;
3914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
3916
3917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
3919 }
3920
3921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
3922 where
3923 V: serde::de::MapAccess<'de>,
3924 {
3925 let mut database_id__ = None;
3926 while let Some(k) = map_.next_key()? {
3927 match k {
3928 GeneratedField::DatabaseId => {
3929 if database_id__.is_some() {
3930 return Err(serde::de::Error::duplicate_field("databaseId"));
3931 }
3932 database_id__ =
3933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3934 ;
3935 }
3936 }
3937 }
3938 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
3939 database_id: database_id__.unwrap_or_default(),
3940 })
3941 }
3942 }
3943 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
3944 }
3945}
3946impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
3947 #[allow(deprecated)]
3948 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3949 where
3950 S: serde::Serializer,
3951 {
3952 use serde::ser::SerializeStruct;
3953 let mut len = 0;
3954 if self.database_id != 0 {
3955 len += 1;
3956 }
3957 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
3958 if self.database_id != 0 {
3959 struct_ser.serialize_field("databaseId", &self.database_id)?;
3960 }
3961 struct_ser.end()
3962 }
3963}
3964impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
3965 #[allow(deprecated)]
3966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3967 where
3968 D: serde::Deserializer<'de>,
3969 {
3970 const FIELDS: &[&str] = &[
3971 "database_id",
3972 "databaseId",
3973 ];
3974
3975 #[allow(clippy::enum_variant_names)]
3976 enum GeneratedField {
3977 DatabaseId,
3978 }
3979 impl<'de> serde::Deserialize<'de> for GeneratedField {
3980 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3981 where
3982 D: serde::Deserializer<'de>,
3983 {
3984 struct GeneratedVisitor;
3985
3986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3987 type Value = GeneratedField;
3988
3989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3990 write!(formatter, "expected one of: {:?}", &FIELDS)
3991 }
3992
3993 #[allow(unused_variables)]
3994 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3995 where
3996 E: serde::de::Error,
3997 {
3998 match value {
3999 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4001 }
4002 }
4003 }
4004 deserializer.deserialize_identifier(GeneratedVisitor)
4005 }
4006 }
4007 struct GeneratedVisitor;
4008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4009 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4010
4011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4012 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4013 }
4014
4015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4016 where
4017 V: serde::de::MapAccess<'de>,
4018 {
4019 let mut database_id__ = None;
4020 while let Some(k) = map_.next_key()? {
4021 match k {
4022 GeneratedField::DatabaseId => {
4023 if database_id__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("databaseId"));
4025 }
4026 database_id__ =
4027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4028 ;
4029 }
4030 }
4031 }
4032 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4033 database_id: database_id__.unwrap_or_default(),
4034 })
4035 }
4036 }
4037 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4038 }
4039}
4040impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4041 #[allow(deprecated)]
4042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4043 where
4044 S: serde::Serializer,
4045 {
4046 use serde::ser::SerializeStruct;
4047 let mut len = 0;
4048 if self.database_id != 0 {
4049 len += 1;
4050 }
4051 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4052 if self.database_id != 0 {
4053 struct_ser.serialize_field("databaseId", &self.database_id)?;
4054 }
4055 struct_ser.end()
4056 }
4057}
4058impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4059 #[allow(deprecated)]
4060 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4061 where
4062 D: serde::Deserializer<'de>,
4063 {
4064 const FIELDS: &[&str] = &[
4065 "database_id",
4066 "databaseId",
4067 ];
4068
4069 #[allow(clippy::enum_variant_names)]
4070 enum GeneratedField {
4071 DatabaseId,
4072 }
4073 impl<'de> serde::Deserialize<'de> for GeneratedField {
4074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4075 where
4076 D: serde::Deserializer<'de>,
4077 {
4078 struct GeneratedVisitor;
4079
4080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4081 type Value = GeneratedField;
4082
4083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4084 write!(formatter, "expected one of: {:?}", &FIELDS)
4085 }
4086
4087 #[allow(unused_variables)]
4088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4089 where
4090 E: serde::de::Error,
4091 {
4092 match value {
4093 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
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::DatabaseRecoverySuccess;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4107 }
4108
4109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4110 where
4111 V: serde::de::MapAccess<'de>,
4112 {
4113 let mut database_id__ = None;
4114 while let Some(k) = map_.next_key()? {
4115 match k {
4116 GeneratedField::DatabaseId => {
4117 if database_id__.is_some() {
4118 return Err(serde::de::Error::duplicate_field("databaseId"));
4119 }
4120 database_id__ =
4121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4122 ;
4123 }
4124 }
4125 }
4126 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4127 database_id: database_id__.unwrap_or_default(),
4128 })
4129 }
4130 }
4131 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4132 }
4133}
4134impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4135 #[allow(deprecated)]
4136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4137 where
4138 S: serde::Serializer,
4139 {
4140 use serde::ser::SerializeStruct;
4141 let mut len = 0;
4142 if !self.reason.is_empty() {
4143 len += 1;
4144 }
4145 if !self.error.is_empty() {
4146 len += 1;
4147 }
4148 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4149 if !self.reason.is_empty() {
4150 struct_ser.serialize_field("reason", &self.reason)?;
4151 }
4152 if !self.error.is_empty() {
4153 struct_ser.serialize_field("error", &self.error)?;
4154 }
4155 struct_ser.end()
4156 }
4157}
4158impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4159 #[allow(deprecated)]
4160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4161 where
4162 D: serde::Deserializer<'de>,
4163 {
4164 const FIELDS: &[&str] = &[
4165 "reason",
4166 "error",
4167 ];
4168
4169 #[allow(clippy::enum_variant_names)]
4170 enum GeneratedField {
4171 Reason,
4172 Error,
4173 }
4174 impl<'de> serde::Deserialize<'de> for GeneratedField {
4175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4176 where
4177 D: serde::Deserializer<'de>,
4178 {
4179 struct GeneratedVisitor;
4180
4181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4182 type Value = GeneratedField;
4183
4184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4185 write!(formatter, "expected one of: {:?}", &FIELDS)
4186 }
4187
4188 #[allow(unused_variables)]
4189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4190 where
4191 E: serde::de::Error,
4192 {
4193 match value {
4194 "reason" => Ok(GeneratedField::Reason),
4195 "error" => Ok(GeneratedField::Error),
4196 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4197 }
4198 }
4199 }
4200 deserializer.deserialize_identifier(GeneratedVisitor)
4201 }
4202 }
4203 struct GeneratedVisitor;
4204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4205 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4206
4207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4208 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4209 }
4210
4211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4212 where
4213 V: serde::de::MapAccess<'de>,
4214 {
4215 let mut reason__ = None;
4216 let mut error__ = None;
4217 while let Some(k) = map_.next_key()? {
4218 match k {
4219 GeneratedField::Reason => {
4220 if reason__.is_some() {
4221 return Err(serde::de::Error::duplicate_field("reason"));
4222 }
4223 reason__ = Some(map_.next_value()?);
4224 }
4225 GeneratedField::Error => {
4226 if error__.is_some() {
4227 return Err(serde::de::Error::duplicate_field("error"));
4228 }
4229 error__ = Some(map_.next_value()?);
4230 }
4231 }
4232 }
4233 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4234 reason: reason__.unwrap_or_default(),
4235 error: error__.unwrap_or_default(),
4236 })
4237 }
4238 }
4239 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4240 }
4241}
4242impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4243 #[allow(deprecated)]
4244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4245 where
4246 S: serde::Serializer,
4247 {
4248 use serde::ser::SerializeStruct;
4249 let mut len = 0;
4250 if !self.reason.is_empty() {
4251 len += 1;
4252 }
4253 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4254 if !self.reason.is_empty() {
4255 struct_ser.serialize_field("reason", &self.reason)?;
4256 }
4257 struct_ser.end()
4258 }
4259}
4260impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4261 #[allow(deprecated)]
4262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4263 where
4264 D: serde::Deserializer<'de>,
4265 {
4266 const FIELDS: &[&str] = &[
4267 "reason",
4268 ];
4269
4270 #[allow(clippy::enum_variant_names)]
4271 enum GeneratedField {
4272 Reason,
4273 }
4274 impl<'de> serde::Deserialize<'de> for GeneratedField {
4275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4276 where
4277 D: serde::Deserializer<'de>,
4278 {
4279 struct GeneratedVisitor;
4280
4281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4282 type Value = GeneratedField;
4283
4284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4285 write!(formatter, "expected one of: {:?}", &FIELDS)
4286 }
4287
4288 #[allow(unused_variables)]
4289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4290 where
4291 E: serde::de::Error,
4292 {
4293 match value {
4294 "reason" => Ok(GeneratedField::Reason),
4295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4296 }
4297 }
4298 }
4299 deserializer.deserialize_identifier(GeneratedVisitor)
4300 }
4301 }
4302 struct GeneratedVisitor;
4303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4304 type Value = event_log::event_recovery::GlobalRecoveryStart;
4305
4306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4307 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4308 }
4309
4310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4311 where
4312 V: serde::de::MapAccess<'de>,
4313 {
4314 let mut reason__ = None;
4315 while let Some(k) = map_.next_key()? {
4316 match k {
4317 GeneratedField::Reason => {
4318 if reason__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("reason"));
4320 }
4321 reason__ = Some(map_.next_value()?);
4322 }
4323 }
4324 }
4325 Ok(event_log::event_recovery::GlobalRecoveryStart {
4326 reason: reason__.unwrap_or_default(),
4327 })
4328 }
4329 }
4330 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4331 }
4332}
4333impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4334 #[allow(deprecated)]
4335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4336 where
4337 S: serde::Serializer,
4338 {
4339 use serde::ser::SerializeStruct;
4340 let mut len = 0;
4341 if !self.reason.is_empty() {
4342 len += 1;
4343 }
4344 if self.duration_secs != 0. {
4345 len += 1;
4346 }
4347 if !self.running_database_ids.is_empty() {
4348 len += 1;
4349 }
4350 if !self.recovering_database_ids.is_empty() {
4351 len += 1;
4352 }
4353 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4354 if !self.reason.is_empty() {
4355 struct_ser.serialize_field("reason", &self.reason)?;
4356 }
4357 if self.duration_secs != 0. {
4358 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4359 }
4360 if !self.running_database_ids.is_empty() {
4361 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4362 }
4363 if !self.recovering_database_ids.is_empty() {
4364 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4365 }
4366 struct_ser.end()
4367 }
4368}
4369impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4370 #[allow(deprecated)]
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 const FIELDS: &[&str] = &[
4376 "reason",
4377 "duration_secs",
4378 "durationSecs",
4379 "running_database_ids",
4380 "runningDatabaseIds",
4381 "recovering_database_ids",
4382 "recoveringDatabaseIds",
4383 ];
4384
4385 #[allow(clippy::enum_variant_names)]
4386 enum GeneratedField {
4387 Reason,
4388 DurationSecs,
4389 RunningDatabaseIds,
4390 RecoveringDatabaseIds,
4391 }
4392 impl<'de> serde::Deserialize<'de> for GeneratedField {
4393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4394 where
4395 D: serde::Deserializer<'de>,
4396 {
4397 struct GeneratedVisitor;
4398
4399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4400 type Value = GeneratedField;
4401
4402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4403 write!(formatter, "expected one of: {:?}", &FIELDS)
4404 }
4405
4406 #[allow(unused_variables)]
4407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4408 where
4409 E: serde::de::Error,
4410 {
4411 match value {
4412 "reason" => Ok(GeneratedField::Reason),
4413 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4414 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4415 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4417 }
4418 }
4419 }
4420 deserializer.deserialize_identifier(GeneratedVisitor)
4421 }
4422 }
4423 struct GeneratedVisitor;
4424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4425 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4426
4427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4428 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4429 }
4430
4431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4432 where
4433 V: serde::de::MapAccess<'de>,
4434 {
4435 let mut reason__ = None;
4436 let mut duration_secs__ = None;
4437 let mut running_database_ids__ = None;
4438 let mut recovering_database_ids__ = None;
4439 while let Some(k) = map_.next_key()? {
4440 match k {
4441 GeneratedField::Reason => {
4442 if reason__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("reason"));
4444 }
4445 reason__ = Some(map_.next_value()?);
4446 }
4447 GeneratedField::DurationSecs => {
4448 if duration_secs__.is_some() {
4449 return Err(serde::de::Error::duplicate_field("durationSecs"));
4450 }
4451 duration_secs__ =
4452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4453 ;
4454 }
4455 GeneratedField::RunningDatabaseIds => {
4456 if running_database_ids__.is_some() {
4457 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4458 }
4459 running_database_ids__ =
4460 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4461 .into_iter().map(|x| x.0).collect())
4462 ;
4463 }
4464 GeneratedField::RecoveringDatabaseIds => {
4465 if recovering_database_ids__.is_some() {
4466 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4467 }
4468 recovering_database_ids__ =
4469 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4470 .into_iter().map(|x| x.0).collect())
4471 ;
4472 }
4473 }
4474 }
4475 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4476 reason: reason__.unwrap_or_default(),
4477 duration_secs: duration_secs__.unwrap_or_default(),
4478 running_database_ids: running_database_ids__.unwrap_or_default(),
4479 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4480 })
4481 }
4482 }
4483 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4484 }
4485}
4486impl serde::Serialize for event_log::EventSinkFail {
4487 #[allow(deprecated)]
4488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4489 where
4490 S: serde::Serializer,
4491 {
4492 use serde::ser::SerializeStruct;
4493 let mut len = 0;
4494 if self.sink_id != 0 {
4495 len += 1;
4496 }
4497 if !self.sink_name.is_empty() {
4498 len += 1;
4499 }
4500 if !self.connector.is_empty() {
4501 len += 1;
4502 }
4503 if !self.error.is_empty() {
4504 len += 1;
4505 }
4506 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4507 if self.sink_id != 0 {
4508 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4509 }
4510 if !self.sink_name.is_empty() {
4511 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4512 }
4513 if !self.connector.is_empty() {
4514 struct_ser.serialize_field("connector", &self.connector)?;
4515 }
4516 if !self.error.is_empty() {
4517 struct_ser.serialize_field("error", &self.error)?;
4518 }
4519 struct_ser.end()
4520 }
4521}
4522impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4523 #[allow(deprecated)]
4524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4525 where
4526 D: serde::Deserializer<'de>,
4527 {
4528 const FIELDS: &[&str] = &[
4529 "sink_id",
4530 "sinkId",
4531 "sink_name",
4532 "sinkName",
4533 "connector",
4534 "error",
4535 ];
4536
4537 #[allow(clippy::enum_variant_names)]
4538 enum GeneratedField {
4539 SinkId,
4540 SinkName,
4541 Connector,
4542 Error,
4543 }
4544 impl<'de> serde::Deserialize<'de> for GeneratedField {
4545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4546 where
4547 D: serde::Deserializer<'de>,
4548 {
4549 struct GeneratedVisitor;
4550
4551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4552 type Value = GeneratedField;
4553
4554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4555 write!(formatter, "expected one of: {:?}", &FIELDS)
4556 }
4557
4558 #[allow(unused_variables)]
4559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4560 where
4561 E: serde::de::Error,
4562 {
4563 match value {
4564 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4565 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4566 "connector" => Ok(GeneratedField::Connector),
4567 "error" => Ok(GeneratedField::Error),
4568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4569 }
4570 }
4571 }
4572 deserializer.deserialize_identifier(GeneratedVisitor)
4573 }
4574 }
4575 struct GeneratedVisitor;
4576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4577 type Value = event_log::EventSinkFail;
4578
4579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4580 formatter.write_str("struct meta.EventLog.EventSinkFail")
4581 }
4582
4583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4584 where
4585 V: serde::de::MapAccess<'de>,
4586 {
4587 let mut sink_id__ = None;
4588 let mut sink_name__ = None;
4589 let mut connector__ = None;
4590 let mut error__ = None;
4591 while let Some(k) = map_.next_key()? {
4592 match k {
4593 GeneratedField::SinkId => {
4594 if sink_id__.is_some() {
4595 return Err(serde::de::Error::duplicate_field("sinkId"));
4596 }
4597 sink_id__ =
4598 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4599 ;
4600 }
4601 GeneratedField::SinkName => {
4602 if sink_name__.is_some() {
4603 return Err(serde::de::Error::duplicate_field("sinkName"));
4604 }
4605 sink_name__ = Some(map_.next_value()?);
4606 }
4607 GeneratedField::Connector => {
4608 if connector__.is_some() {
4609 return Err(serde::de::Error::duplicate_field("connector"));
4610 }
4611 connector__ = Some(map_.next_value()?);
4612 }
4613 GeneratedField::Error => {
4614 if error__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("error"));
4616 }
4617 error__ = Some(map_.next_value()?);
4618 }
4619 }
4620 }
4621 Ok(event_log::EventSinkFail {
4622 sink_id: sink_id__.unwrap_or_default(),
4623 sink_name: sink_name__.unwrap_or_default(),
4624 connector: connector__.unwrap_or_default(),
4625 error: error__.unwrap_or_default(),
4626 })
4627 }
4628 }
4629 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4630 }
4631}
4632impl serde::Serialize for event_log::EventWorkerNodePanic {
4633 #[allow(deprecated)]
4634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4635 where
4636 S: serde::Serializer,
4637 {
4638 use serde::ser::SerializeStruct;
4639 let mut len = 0;
4640 if self.worker_id != 0 {
4641 len += 1;
4642 }
4643 if self.worker_type != 0 {
4644 len += 1;
4645 }
4646 if self.host_addr.is_some() {
4647 len += 1;
4648 }
4649 if !self.panic_info.is_empty() {
4650 len += 1;
4651 }
4652 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4653 if self.worker_id != 0 {
4654 struct_ser.serialize_field("workerId", &self.worker_id)?;
4655 }
4656 if self.worker_type != 0 {
4657 let v = super::common::WorkerType::try_from(self.worker_type)
4658 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4659 struct_ser.serialize_field("workerType", &v)?;
4660 }
4661 if let Some(v) = self.host_addr.as_ref() {
4662 struct_ser.serialize_field("hostAddr", v)?;
4663 }
4664 if !self.panic_info.is_empty() {
4665 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4666 }
4667 struct_ser.end()
4668 }
4669}
4670impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4671 #[allow(deprecated)]
4672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4673 where
4674 D: serde::Deserializer<'de>,
4675 {
4676 const FIELDS: &[&str] = &[
4677 "worker_id",
4678 "workerId",
4679 "worker_type",
4680 "workerType",
4681 "host_addr",
4682 "hostAddr",
4683 "panic_info",
4684 "panicInfo",
4685 ];
4686
4687 #[allow(clippy::enum_variant_names)]
4688 enum GeneratedField {
4689 WorkerId,
4690 WorkerType,
4691 HostAddr,
4692 PanicInfo,
4693 }
4694 impl<'de> serde::Deserialize<'de> for GeneratedField {
4695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4696 where
4697 D: serde::Deserializer<'de>,
4698 {
4699 struct GeneratedVisitor;
4700
4701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4702 type Value = GeneratedField;
4703
4704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4705 write!(formatter, "expected one of: {:?}", &FIELDS)
4706 }
4707
4708 #[allow(unused_variables)]
4709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4710 where
4711 E: serde::de::Error,
4712 {
4713 match value {
4714 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4715 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4716 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4717 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4719 }
4720 }
4721 }
4722 deserializer.deserialize_identifier(GeneratedVisitor)
4723 }
4724 }
4725 struct GeneratedVisitor;
4726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4727 type Value = event_log::EventWorkerNodePanic;
4728
4729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4730 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4731 }
4732
4733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4734 where
4735 V: serde::de::MapAccess<'de>,
4736 {
4737 let mut worker_id__ = None;
4738 let mut worker_type__ = None;
4739 let mut host_addr__ = None;
4740 let mut panic_info__ = None;
4741 while let Some(k) = map_.next_key()? {
4742 match k {
4743 GeneratedField::WorkerId => {
4744 if worker_id__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("workerId"));
4746 }
4747 worker_id__ =
4748 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4749 ;
4750 }
4751 GeneratedField::WorkerType => {
4752 if worker_type__.is_some() {
4753 return Err(serde::de::Error::duplicate_field("workerType"));
4754 }
4755 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4756 }
4757 GeneratedField::HostAddr => {
4758 if host_addr__.is_some() {
4759 return Err(serde::de::Error::duplicate_field("hostAddr"));
4760 }
4761 host_addr__ = map_.next_value()?;
4762 }
4763 GeneratedField::PanicInfo => {
4764 if panic_info__.is_some() {
4765 return Err(serde::de::Error::duplicate_field("panicInfo"));
4766 }
4767 panic_info__ = Some(map_.next_value()?);
4768 }
4769 }
4770 }
4771 Ok(event_log::EventWorkerNodePanic {
4772 worker_id: worker_id__.unwrap_or_default(),
4773 worker_type: worker_type__.unwrap_or_default(),
4774 host_addr: host_addr__,
4775 panic_info: panic_info__.unwrap_or_default(),
4776 })
4777 }
4778 }
4779 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4780 }
4781}
4782impl serde::Serialize for FlushRequest {
4783 #[allow(deprecated)]
4784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4785 where
4786 S: serde::Serializer,
4787 {
4788 use serde::ser::SerializeStruct;
4789 let mut len = 0;
4790 if self.database_id != 0 {
4791 len += 1;
4792 }
4793 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4794 if self.database_id != 0 {
4795 struct_ser.serialize_field("databaseId", &self.database_id)?;
4796 }
4797 struct_ser.end()
4798 }
4799}
4800impl<'de> serde::Deserialize<'de> for FlushRequest {
4801 #[allow(deprecated)]
4802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4803 where
4804 D: serde::Deserializer<'de>,
4805 {
4806 const FIELDS: &[&str] = &[
4807 "database_id",
4808 "databaseId",
4809 ];
4810
4811 #[allow(clippy::enum_variant_names)]
4812 enum GeneratedField {
4813 DatabaseId,
4814 }
4815 impl<'de> serde::Deserialize<'de> for GeneratedField {
4816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4817 where
4818 D: serde::Deserializer<'de>,
4819 {
4820 struct GeneratedVisitor;
4821
4822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4823 type Value = GeneratedField;
4824
4825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4826 write!(formatter, "expected one of: {:?}", &FIELDS)
4827 }
4828
4829 #[allow(unused_variables)]
4830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4831 where
4832 E: serde::de::Error,
4833 {
4834 match value {
4835 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4837 }
4838 }
4839 }
4840 deserializer.deserialize_identifier(GeneratedVisitor)
4841 }
4842 }
4843 struct GeneratedVisitor;
4844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4845 type Value = FlushRequest;
4846
4847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4848 formatter.write_str("struct meta.FlushRequest")
4849 }
4850
4851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
4852 where
4853 V: serde::de::MapAccess<'de>,
4854 {
4855 let mut database_id__ = None;
4856 while let Some(k) = map_.next_key()? {
4857 match k {
4858 GeneratedField::DatabaseId => {
4859 if database_id__.is_some() {
4860 return Err(serde::de::Error::duplicate_field("databaseId"));
4861 }
4862 database_id__ =
4863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4864 ;
4865 }
4866 }
4867 }
4868 Ok(FlushRequest {
4869 database_id: database_id__.unwrap_or_default(),
4870 })
4871 }
4872 }
4873 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
4874 }
4875}
4876impl serde::Serialize for FlushResponse {
4877 #[allow(deprecated)]
4878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4879 where
4880 S: serde::Serializer,
4881 {
4882 use serde::ser::SerializeStruct;
4883 let mut len = 0;
4884 if self.status.is_some() {
4885 len += 1;
4886 }
4887 if self.hummock_version_id != 0 {
4888 len += 1;
4889 }
4890 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
4891 if let Some(v) = self.status.as_ref() {
4892 struct_ser.serialize_field("status", v)?;
4893 }
4894 if self.hummock_version_id != 0 {
4895 #[allow(clippy::needless_borrow)]
4896 #[allow(clippy::needless_borrows_for_generic_args)]
4897 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
4898 }
4899 struct_ser.end()
4900 }
4901}
4902impl<'de> serde::Deserialize<'de> for FlushResponse {
4903 #[allow(deprecated)]
4904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4905 where
4906 D: serde::Deserializer<'de>,
4907 {
4908 const FIELDS: &[&str] = &[
4909 "status",
4910 "hummock_version_id",
4911 "hummockVersionId",
4912 ];
4913
4914 #[allow(clippy::enum_variant_names)]
4915 enum GeneratedField {
4916 Status,
4917 HummockVersionId,
4918 }
4919 impl<'de> serde::Deserialize<'de> for GeneratedField {
4920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4921 where
4922 D: serde::Deserializer<'de>,
4923 {
4924 struct GeneratedVisitor;
4925
4926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4927 type Value = GeneratedField;
4928
4929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4930 write!(formatter, "expected one of: {:?}", &FIELDS)
4931 }
4932
4933 #[allow(unused_variables)]
4934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4935 where
4936 E: serde::de::Error,
4937 {
4938 match value {
4939 "status" => Ok(GeneratedField::Status),
4940 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
4941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4942 }
4943 }
4944 }
4945 deserializer.deserialize_identifier(GeneratedVisitor)
4946 }
4947 }
4948 struct GeneratedVisitor;
4949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4950 type Value = FlushResponse;
4951
4952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4953 formatter.write_str("struct meta.FlushResponse")
4954 }
4955
4956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
4957 where
4958 V: serde::de::MapAccess<'de>,
4959 {
4960 let mut status__ = None;
4961 let mut hummock_version_id__ = None;
4962 while let Some(k) = map_.next_key()? {
4963 match k {
4964 GeneratedField::Status => {
4965 if status__.is_some() {
4966 return Err(serde::de::Error::duplicate_field("status"));
4967 }
4968 status__ = map_.next_value()?;
4969 }
4970 GeneratedField::HummockVersionId => {
4971 if hummock_version_id__.is_some() {
4972 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
4973 }
4974 hummock_version_id__ =
4975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4976 ;
4977 }
4978 }
4979 }
4980 Ok(FlushResponse {
4981 status: status__,
4982 hummock_version_id: hummock_version_id__.unwrap_or_default(),
4983 })
4984 }
4985 }
4986 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
4987 }
4988}
4989impl serde::Serialize for FragmentDistribution {
4990 #[allow(deprecated)]
4991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4992 where
4993 S: serde::Serializer,
4994 {
4995 use serde::ser::SerializeStruct;
4996 let mut len = 0;
4997 if self.fragment_id != 0 {
4998 len += 1;
4999 }
5000 if self.table_id != 0 {
5001 len += 1;
5002 }
5003 if self.distribution_type != 0 {
5004 len += 1;
5005 }
5006 if !self.state_table_ids.is_empty() {
5007 len += 1;
5008 }
5009 if !self.upstream_fragment_ids.is_empty() {
5010 len += 1;
5011 }
5012 if self.fragment_type_mask != 0 {
5013 len += 1;
5014 }
5015 if self.parallelism != 0 {
5016 len += 1;
5017 }
5018 if self.vnode_count != 0 {
5019 len += 1;
5020 }
5021 if self.node.is_some() {
5022 len += 1;
5023 }
5024 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5025 if self.fragment_id != 0 {
5026 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5027 }
5028 if self.table_id != 0 {
5029 struct_ser.serialize_field("tableId", &self.table_id)?;
5030 }
5031 if self.distribution_type != 0 {
5032 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5033 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5034 struct_ser.serialize_field("distributionType", &v)?;
5035 }
5036 if !self.state_table_ids.is_empty() {
5037 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5038 }
5039 if !self.upstream_fragment_ids.is_empty() {
5040 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5041 }
5042 if self.fragment_type_mask != 0 {
5043 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5044 }
5045 if self.parallelism != 0 {
5046 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5047 }
5048 if self.vnode_count != 0 {
5049 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5050 }
5051 if let Some(v) = self.node.as_ref() {
5052 struct_ser.serialize_field("node", v)?;
5053 }
5054 struct_ser.end()
5055 }
5056}
5057impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5058 #[allow(deprecated)]
5059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5060 where
5061 D: serde::Deserializer<'de>,
5062 {
5063 const FIELDS: &[&str] = &[
5064 "fragment_id",
5065 "fragmentId",
5066 "table_id",
5067 "tableId",
5068 "distribution_type",
5069 "distributionType",
5070 "state_table_ids",
5071 "stateTableIds",
5072 "upstream_fragment_ids",
5073 "upstreamFragmentIds",
5074 "fragment_type_mask",
5075 "fragmentTypeMask",
5076 "parallelism",
5077 "vnode_count",
5078 "vnodeCount",
5079 "node",
5080 ];
5081
5082 #[allow(clippy::enum_variant_names)]
5083 enum GeneratedField {
5084 FragmentId,
5085 TableId,
5086 DistributionType,
5087 StateTableIds,
5088 UpstreamFragmentIds,
5089 FragmentTypeMask,
5090 Parallelism,
5091 VnodeCount,
5092 Node,
5093 }
5094 impl<'de> serde::Deserialize<'de> for GeneratedField {
5095 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5096 where
5097 D: serde::Deserializer<'de>,
5098 {
5099 struct GeneratedVisitor;
5100
5101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5102 type Value = GeneratedField;
5103
5104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5105 write!(formatter, "expected one of: {:?}", &FIELDS)
5106 }
5107
5108 #[allow(unused_variables)]
5109 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5110 where
5111 E: serde::de::Error,
5112 {
5113 match value {
5114 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5115 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5116 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5117 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5118 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5119 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5120 "parallelism" => Ok(GeneratedField::Parallelism),
5121 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5122 "node" => Ok(GeneratedField::Node),
5123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5124 }
5125 }
5126 }
5127 deserializer.deserialize_identifier(GeneratedVisitor)
5128 }
5129 }
5130 struct GeneratedVisitor;
5131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5132 type Value = FragmentDistribution;
5133
5134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5135 formatter.write_str("struct meta.FragmentDistribution")
5136 }
5137
5138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5139 where
5140 V: serde::de::MapAccess<'de>,
5141 {
5142 let mut fragment_id__ = None;
5143 let mut table_id__ = None;
5144 let mut distribution_type__ = None;
5145 let mut state_table_ids__ = None;
5146 let mut upstream_fragment_ids__ = None;
5147 let mut fragment_type_mask__ = None;
5148 let mut parallelism__ = None;
5149 let mut vnode_count__ = None;
5150 let mut node__ = None;
5151 while let Some(k) = map_.next_key()? {
5152 match k {
5153 GeneratedField::FragmentId => {
5154 if fragment_id__.is_some() {
5155 return Err(serde::de::Error::duplicate_field("fragmentId"));
5156 }
5157 fragment_id__ =
5158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5159 ;
5160 }
5161 GeneratedField::TableId => {
5162 if table_id__.is_some() {
5163 return Err(serde::de::Error::duplicate_field("tableId"));
5164 }
5165 table_id__ =
5166 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5167 ;
5168 }
5169 GeneratedField::DistributionType => {
5170 if distribution_type__.is_some() {
5171 return Err(serde::de::Error::duplicate_field("distributionType"));
5172 }
5173 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5174 }
5175 GeneratedField::StateTableIds => {
5176 if state_table_ids__.is_some() {
5177 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5178 }
5179 state_table_ids__ =
5180 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5181 .into_iter().map(|x| x.0).collect())
5182 ;
5183 }
5184 GeneratedField::UpstreamFragmentIds => {
5185 if upstream_fragment_ids__.is_some() {
5186 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5187 }
5188 upstream_fragment_ids__ =
5189 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5190 .into_iter().map(|x| x.0).collect())
5191 ;
5192 }
5193 GeneratedField::FragmentTypeMask => {
5194 if fragment_type_mask__.is_some() {
5195 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5196 }
5197 fragment_type_mask__ =
5198 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5199 ;
5200 }
5201 GeneratedField::Parallelism => {
5202 if parallelism__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("parallelism"));
5204 }
5205 parallelism__ =
5206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5207 ;
5208 }
5209 GeneratedField::VnodeCount => {
5210 if vnode_count__.is_some() {
5211 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5212 }
5213 vnode_count__ =
5214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5215 ;
5216 }
5217 GeneratedField::Node => {
5218 if node__.is_some() {
5219 return Err(serde::de::Error::duplicate_field("node"));
5220 }
5221 node__ = map_.next_value()?;
5222 }
5223 }
5224 }
5225 Ok(FragmentDistribution {
5226 fragment_id: fragment_id__.unwrap_or_default(),
5227 table_id: table_id__.unwrap_or_default(),
5228 distribution_type: distribution_type__.unwrap_or_default(),
5229 state_table_ids: state_table_ids__.unwrap_or_default(),
5230 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5231 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5232 parallelism: parallelism__.unwrap_or_default(),
5233 vnode_count: vnode_count__.unwrap_or_default(),
5234 node: node__,
5235 })
5236 }
5237 }
5238 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5239 }
5240}
5241impl serde::Serialize for FragmentIdToActorIdMap {
5242 #[allow(deprecated)]
5243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5244 where
5245 S: serde::Serializer,
5246 {
5247 use serde::ser::SerializeStruct;
5248 let mut len = 0;
5249 if !self.map.is_empty() {
5250 len += 1;
5251 }
5252 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5253 if !self.map.is_empty() {
5254 struct_ser.serialize_field("map", &self.map)?;
5255 }
5256 struct_ser.end()
5257 }
5258}
5259impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5260 #[allow(deprecated)]
5261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5262 where
5263 D: serde::Deserializer<'de>,
5264 {
5265 const FIELDS: &[&str] = &[
5266 "map",
5267 ];
5268
5269 #[allow(clippy::enum_variant_names)]
5270 enum GeneratedField {
5271 Map,
5272 }
5273 impl<'de> serde::Deserialize<'de> for GeneratedField {
5274 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5275 where
5276 D: serde::Deserializer<'de>,
5277 {
5278 struct GeneratedVisitor;
5279
5280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5281 type Value = GeneratedField;
5282
5283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5284 write!(formatter, "expected one of: {:?}", &FIELDS)
5285 }
5286
5287 #[allow(unused_variables)]
5288 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5289 where
5290 E: serde::de::Error,
5291 {
5292 match value {
5293 "map" => Ok(GeneratedField::Map),
5294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5295 }
5296 }
5297 }
5298 deserializer.deserialize_identifier(GeneratedVisitor)
5299 }
5300 }
5301 struct GeneratedVisitor;
5302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5303 type Value = FragmentIdToActorIdMap;
5304
5305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5306 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5307 }
5308
5309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5310 where
5311 V: serde::de::MapAccess<'de>,
5312 {
5313 let mut map__ = None;
5314 while let Some(k) = map_.next_key()? {
5315 match k {
5316 GeneratedField::Map => {
5317 if map__.is_some() {
5318 return Err(serde::de::Error::duplicate_field("map"));
5319 }
5320 map__ = Some(
5321 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5322 .into_iter().map(|(k,v)| (k.0, v)).collect()
5323 );
5324 }
5325 }
5326 }
5327 Ok(FragmentIdToActorIdMap {
5328 map: map__.unwrap_or_default(),
5329 })
5330 }
5331 }
5332 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5333 }
5334}
5335impl serde::Serialize for FragmentToRelationMap {
5336 #[allow(deprecated)]
5337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5338 where
5339 S: serde::Serializer,
5340 {
5341 use serde::ser::SerializeStruct;
5342 let mut len = 0;
5343 if !self.in_map.is_empty() {
5344 len += 1;
5345 }
5346 if !self.out_map.is_empty() {
5347 len += 1;
5348 }
5349 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5350 if !self.in_map.is_empty() {
5351 struct_ser.serialize_field("inMap", &self.in_map)?;
5352 }
5353 if !self.out_map.is_empty() {
5354 struct_ser.serialize_field("outMap", &self.out_map)?;
5355 }
5356 struct_ser.end()
5357 }
5358}
5359impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5360 #[allow(deprecated)]
5361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5362 where
5363 D: serde::Deserializer<'de>,
5364 {
5365 const FIELDS: &[&str] = &[
5366 "in_map",
5367 "inMap",
5368 "out_map",
5369 "outMap",
5370 ];
5371
5372 #[allow(clippy::enum_variant_names)]
5373 enum GeneratedField {
5374 InMap,
5375 OutMap,
5376 }
5377 impl<'de> serde::Deserialize<'de> for GeneratedField {
5378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5379 where
5380 D: serde::Deserializer<'de>,
5381 {
5382 struct GeneratedVisitor;
5383
5384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5385 type Value = GeneratedField;
5386
5387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5388 write!(formatter, "expected one of: {:?}", &FIELDS)
5389 }
5390
5391 #[allow(unused_variables)]
5392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5393 where
5394 E: serde::de::Error,
5395 {
5396 match value {
5397 "inMap" | "in_map" => Ok(GeneratedField::InMap),
5398 "outMap" | "out_map" => Ok(GeneratedField::OutMap),
5399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5400 }
5401 }
5402 }
5403 deserializer.deserialize_identifier(GeneratedVisitor)
5404 }
5405 }
5406 struct GeneratedVisitor;
5407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5408 type Value = FragmentToRelationMap;
5409
5410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5411 formatter.write_str("struct meta.FragmentToRelationMap")
5412 }
5413
5414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5415 where
5416 V: serde::de::MapAccess<'de>,
5417 {
5418 let mut in_map__ = None;
5419 let mut out_map__ = None;
5420 while let Some(k) = map_.next_key()? {
5421 match k {
5422 GeneratedField::InMap => {
5423 if in_map__.is_some() {
5424 return Err(serde::de::Error::duplicate_field("inMap"));
5425 }
5426 in_map__ = Some(
5427 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5428 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5429 );
5430 }
5431 GeneratedField::OutMap => {
5432 if out_map__.is_some() {
5433 return Err(serde::de::Error::duplicate_field("outMap"));
5434 }
5435 out_map__ = Some(
5436 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5437 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5438 );
5439 }
5440 }
5441 }
5442 Ok(FragmentToRelationMap {
5443 in_map: in_map__.unwrap_or_default(),
5444 out_map: out_map__.unwrap_or_default(),
5445 })
5446 }
5447 }
5448 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5449 }
5450}
5451impl serde::Serialize for FragmentWorkerSlotMapping {
5452 #[allow(deprecated)]
5453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5454 where
5455 S: serde::Serializer,
5456 {
5457 use serde::ser::SerializeStruct;
5458 let mut len = 0;
5459 if self.fragment_id != 0 {
5460 len += 1;
5461 }
5462 if self.mapping.is_some() {
5463 len += 1;
5464 }
5465 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5466 if self.fragment_id != 0 {
5467 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5468 }
5469 if let Some(v) = self.mapping.as_ref() {
5470 struct_ser.serialize_field("mapping", v)?;
5471 }
5472 struct_ser.end()
5473 }
5474}
5475impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5476 #[allow(deprecated)]
5477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5478 where
5479 D: serde::Deserializer<'de>,
5480 {
5481 const FIELDS: &[&str] = &[
5482 "fragment_id",
5483 "fragmentId",
5484 "mapping",
5485 ];
5486
5487 #[allow(clippy::enum_variant_names)]
5488 enum GeneratedField {
5489 FragmentId,
5490 Mapping,
5491 }
5492 impl<'de> serde::Deserialize<'de> for GeneratedField {
5493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5494 where
5495 D: serde::Deserializer<'de>,
5496 {
5497 struct GeneratedVisitor;
5498
5499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5500 type Value = GeneratedField;
5501
5502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5503 write!(formatter, "expected one of: {:?}", &FIELDS)
5504 }
5505
5506 #[allow(unused_variables)]
5507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5508 where
5509 E: serde::de::Error,
5510 {
5511 match value {
5512 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5513 "mapping" => Ok(GeneratedField::Mapping),
5514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5515 }
5516 }
5517 }
5518 deserializer.deserialize_identifier(GeneratedVisitor)
5519 }
5520 }
5521 struct GeneratedVisitor;
5522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5523 type Value = FragmentWorkerSlotMapping;
5524
5525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5526 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5527 }
5528
5529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5530 where
5531 V: serde::de::MapAccess<'de>,
5532 {
5533 let mut fragment_id__ = None;
5534 let mut mapping__ = None;
5535 while let Some(k) = map_.next_key()? {
5536 match k {
5537 GeneratedField::FragmentId => {
5538 if fragment_id__.is_some() {
5539 return Err(serde::de::Error::duplicate_field("fragmentId"));
5540 }
5541 fragment_id__ =
5542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5543 ;
5544 }
5545 GeneratedField::Mapping => {
5546 if mapping__.is_some() {
5547 return Err(serde::de::Error::duplicate_field("mapping"));
5548 }
5549 mapping__ = map_.next_value()?;
5550 }
5551 }
5552 }
5553 Ok(FragmentWorkerSlotMapping {
5554 fragment_id: fragment_id__.unwrap_or_default(),
5555 mapping: mapping__,
5556 })
5557 }
5558 }
5559 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5560 }
5561}
5562impl serde::Serialize for FragmentWorkerSlotMappings {
5563 #[allow(deprecated)]
5564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5565 where
5566 S: serde::Serializer,
5567 {
5568 use serde::ser::SerializeStruct;
5569 let mut len = 0;
5570 if !self.mappings.is_empty() {
5571 len += 1;
5572 }
5573 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5574 if !self.mappings.is_empty() {
5575 struct_ser.serialize_field("mappings", &self.mappings)?;
5576 }
5577 struct_ser.end()
5578 }
5579}
5580impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5581 #[allow(deprecated)]
5582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5583 where
5584 D: serde::Deserializer<'de>,
5585 {
5586 const FIELDS: &[&str] = &[
5587 "mappings",
5588 ];
5589
5590 #[allow(clippy::enum_variant_names)]
5591 enum GeneratedField {
5592 Mappings,
5593 }
5594 impl<'de> serde::Deserialize<'de> for GeneratedField {
5595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5596 where
5597 D: serde::Deserializer<'de>,
5598 {
5599 struct GeneratedVisitor;
5600
5601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5602 type Value = GeneratedField;
5603
5604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5605 write!(formatter, "expected one of: {:?}", &FIELDS)
5606 }
5607
5608 #[allow(unused_variables)]
5609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5610 where
5611 E: serde::de::Error,
5612 {
5613 match value {
5614 "mappings" => Ok(GeneratedField::Mappings),
5615 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5616 }
5617 }
5618 }
5619 deserializer.deserialize_identifier(GeneratedVisitor)
5620 }
5621 }
5622 struct GeneratedVisitor;
5623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5624 type Value = FragmentWorkerSlotMappings;
5625
5626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5627 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5628 }
5629
5630 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5631 where
5632 V: serde::de::MapAccess<'de>,
5633 {
5634 let mut mappings__ = None;
5635 while let Some(k) = map_.next_key()? {
5636 match k {
5637 GeneratedField::Mappings => {
5638 if mappings__.is_some() {
5639 return Err(serde::de::Error::duplicate_field("mappings"));
5640 }
5641 mappings__ = Some(map_.next_value()?);
5642 }
5643 }
5644 }
5645 Ok(FragmentWorkerSlotMappings {
5646 mappings: mappings__.unwrap_or_default(),
5647 })
5648 }
5649 }
5650 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5651 }
5652}
5653impl serde::Serialize for GetClusterInfoRequest {
5654 #[allow(deprecated)]
5655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5656 where
5657 S: serde::Serializer,
5658 {
5659 use serde::ser::SerializeStruct;
5660 let len = 0;
5661 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5662 struct_ser.end()
5663 }
5664}
5665impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5666 #[allow(deprecated)]
5667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5668 where
5669 D: serde::Deserializer<'de>,
5670 {
5671 const FIELDS: &[&str] = &[
5672 ];
5673
5674 #[allow(clippy::enum_variant_names)]
5675 enum GeneratedField {
5676 }
5677 impl<'de> serde::Deserialize<'de> for GeneratedField {
5678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5679 where
5680 D: serde::Deserializer<'de>,
5681 {
5682 struct GeneratedVisitor;
5683
5684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5685 type Value = GeneratedField;
5686
5687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5688 write!(formatter, "expected one of: {:?}", &FIELDS)
5689 }
5690
5691 #[allow(unused_variables)]
5692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5693 where
5694 E: serde::de::Error,
5695 {
5696 Err(serde::de::Error::unknown_field(value, FIELDS))
5697 }
5698 }
5699 deserializer.deserialize_identifier(GeneratedVisitor)
5700 }
5701 }
5702 struct GeneratedVisitor;
5703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5704 type Value = GetClusterInfoRequest;
5705
5706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5707 formatter.write_str("struct meta.GetClusterInfoRequest")
5708 }
5709
5710 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5711 where
5712 V: serde::de::MapAccess<'de>,
5713 {
5714 while map_.next_key::<GeneratedField>()?.is_some() {
5715 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5716 }
5717 Ok(GetClusterInfoRequest {
5718 })
5719 }
5720 }
5721 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5722 }
5723}
5724impl serde::Serialize for GetClusterInfoResponse {
5725 #[allow(deprecated)]
5726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5727 where
5728 S: serde::Serializer,
5729 {
5730 use serde::ser::SerializeStruct;
5731 let mut len = 0;
5732 if !self.worker_nodes.is_empty() {
5733 len += 1;
5734 }
5735 if !self.table_fragments.is_empty() {
5736 len += 1;
5737 }
5738 if !self.actor_splits.is_empty() {
5739 len += 1;
5740 }
5741 if !self.source_infos.is_empty() {
5742 len += 1;
5743 }
5744 if self.revision != 0 {
5745 len += 1;
5746 }
5747 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5748 if !self.worker_nodes.is_empty() {
5749 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5750 }
5751 if !self.table_fragments.is_empty() {
5752 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5753 }
5754 if !self.actor_splits.is_empty() {
5755 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5756 }
5757 if !self.source_infos.is_empty() {
5758 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5759 }
5760 if self.revision != 0 {
5761 #[allow(clippy::needless_borrow)]
5762 #[allow(clippy::needless_borrows_for_generic_args)]
5763 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5764 }
5765 struct_ser.end()
5766 }
5767}
5768impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5769 #[allow(deprecated)]
5770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5771 where
5772 D: serde::Deserializer<'de>,
5773 {
5774 const FIELDS: &[&str] = &[
5775 "worker_nodes",
5776 "workerNodes",
5777 "table_fragments",
5778 "tableFragments",
5779 "actor_splits",
5780 "actorSplits",
5781 "source_infos",
5782 "sourceInfos",
5783 "revision",
5784 ];
5785
5786 #[allow(clippy::enum_variant_names)]
5787 enum GeneratedField {
5788 WorkerNodes,
5789 TableFragments,
5790 ActorSplits,
5791 SourceInfos,
5792 Revision,
5793 }
5794 impl<'de> serde::Deserialize<'de> for GeneratedField {
5795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5796 where
5797 D: serde::Deserializer<'de>,
5798 {
5799 struct GeneratedVisitor;
5800
5801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5802 type Value = GeneratedField;
5803
5804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5805 write!(formatter, "expected one of: {:?}", &FIELDS)
5806 }
5807
5808 #[allow(unused_variables)]
5809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5810 where
5811 E: serde::de::Error,
5812 {
5813 match value {
5814 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5815 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5816 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5817 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5818 "revision" => Ok(GeneratedField::Revision),
5819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5820 }
5821 }
5822 }
5823 deserializer.deserialize_identifier(GeneratedVisitor)
5824 }
5825 }
5826 struct GeneratedVisitor;
5827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5828 type Value = GetClusterInfoResponse;
5829
5830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5831 formatter.write_str("struct meta.GetClusterInfoResponse")
5832 }
5833
5834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5835 where
5836 V: serde::de::MapAccess<'de>,
5837 {
5838 let mut worker_nodes__ = None;
5839 let mut table_fragments__ = None;
5840 let mut actor_splits__ = None;
5841 let mut source_infos__ = None;
5842 let mut revision__ = None;
5843 while let Some(k) = map_.next_key()? {
5844 match k {
5845 GeneratedField::WorkerNodes => {
5846 if worker_nodes__.is_some() {
5847 return Err(serde::de::Error::duplicate_field("workerNodes"));
5848 }
5849 worker_nodes__ = Some(map_.next_value()?);
5850 }
5851 GeneratedField::TableFragments => {
5852 if table_fragments__.is_some() {
5853 return Err(serde::de::Error::duplicate_field("tableFragments"));
5854 }
5855 table_fragments__ = Some(map_.next_value()?);
5856 }
5857 GeneratedField::ActorSplits => {
5858 if actor_splits__.is_some() {
5859 return Err(serde::de::Error::duplicate_field("actorSplits"));
5860 }
5861 actor_splits__ = Some(
5862 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5863 .into_iter().map(|(k,v)| (k.0, v)).collect()
5864 );
5865 }
5866 GeneratedField::SourceInfos => {
5867 if source_infos__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("sourceInfos"));
5869 }
5870 source_infos__ = Some(
5871 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5872 .into_iter().map(|(k,v)| (k.0, v)).collect()
5873 );
5874 }
5875 GeneratedField::Revision => {
5876 if revision__.is_some() {
5877 return Err(serde::de::Error::duplicate_field("revision"));
5878 }
5879 revision__ =
5880 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5881 ;
5882 }
5883 }
5884 }
5885 Ok(GetClusterInfoResponse {
5886 worker_nodes: worker_nodes__.unwrap_or_default(),
5887 table_fragments: table_fragments__.unwrap_or_default(),
5888 actor_splits: actor_splits__.unwrap_or_default(),
5889 source_infos: source_infos__.unwrap_or_default(),
5890 revision: revision__.unwrap_or_default(),
5891 })
5892 }
5893 }
5894 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
5895 }
5896}
5897impl serde::Serialize for GetClusterLimitsRequest {
5898 #[allow(deprecated)]
5899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5900 where
5901 S: serde::Serializer,
5902 {
5903 use serde::ser::SerializeStruct;
5904 let len = 0;
5905 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
5906 struct_ser.end()
5907 }
5908}
5909impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
5910 #[allow(deprecated)]
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 const FIELDS: &[&str] = &[
5916 ];
5917
5918 #[allow(clippy::enum_variant_names)]
5919 enum GeneratedField {
5920 }
5921 impl<'de> serde::Deserialize<'de> for GeneratedField {
5922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5923 where
5924 D: serde::Deserializer<'de>,
5925 {
5926 struct GeneratedVisitor;
5927
5928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5929 type Value = GeneratedField;
5930
5931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5932 write!(formatter, "expected one of: {:?}", &FIELDS)
5933 }
5934
5935 #[allow(unused_variables)]
5936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5937 where
5938 E: serde::de::Error,
5939 {
5940 Err(serde::de::Error::unknown_field(value, FIELDS))
5941 }
5942 }
5943 deserializer.deserialize_identifier(GeneratedVisitor)
5944 }
5945 }
5946 struct GeneratedVisitor;
5947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5948 type Value = GetClusterLimitsRequest;
5949
5950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5951 formatter.write_str("struct meta.GetClusterLimitsRequest")
5952 }
5953
5954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
5955 where
5956 V: serde::de::MapAccess<'de>,
5957 {
5958 while map_.next_key::<GeneratedField>()?.is_some() {
5959 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5960 }
5961 Ok(GetClusterLimitsRequest {
5962 })
5963 }
5964 }
5965 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
5966 }
5967}
5968impl serde::Serialize for GetClusterLimitsResponse {
5969 #[allow(deprecated)]
5970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5971 where
5972 S: serde::Serializer,
5973 {
5974 use serde::ser::SerializeStruct;
5975 let mut len = 0;
5976 if !self.active_limits.is_empty() {
5977 len += 1;
5978 }
5979 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
5980 if !self.active_limits.is_empty() {
5981 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
5982 }
5983 struct_ser.end()
5984 }
5985}
5986impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
5987 #[allow(deprecated)]
5988 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5989 where
5990 D: serde::Deserializer<'de>,
5991 {
5992 const FIELDS: &[&str] = &[
5993 "active_limits",
5994 "activeLimits",
5995 ];
5996
5997 #[allow(clippy::enum_variant_names)]
5998 enum GeneratedField {
5999 ActiveLimits,
6000 }
6001 impl<'de> serde::Deserialize<'de> for GeneratedField {
6002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6003 where
6004 D: serde::Deserializer<'de>,
6005 {
6006 struct GeneratedVisitor;
6007
6008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6009 type Value = GeneratedField;
6010
6011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6012 write!(formatter, "expected one of: {:?}", &FIELDS)
6013 }
6014
6015 #[allow(unused_variables)]
6016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6017 where
6018 E: serde::de::Error,
6019 {
6020 match value {
6021 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6022 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6023 }
6024 }
6025 }
6026 deserializer.deserialize_identifier(GeneratedVisitor)
6027 }
6028 }
6029 struct GeneratedVisitor;
6030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6031 type Value = GetClusterLimitsResponse;
6032
6033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6034 formatter.write_str("struct meta.GetClusterLimitsResponse")
6035 }
6036
6037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6038 where
6039 V: serde::de::MapAccess<'de>,
6040 {
6041 let mut active_limits__ = None;
6042 while let Some(k) = map_.next_key()? {
6043 match k {
6044 GeneratedField::ActiveLimits => {
6045 if active_limits__.is_some() {
6046 return Err(serde::de::Error::duplicate_field("activeLimits"));
6047 }
6048 active_limits__ = Some(map_.next_value()?);
6049 }
6050 }
6051 }
6052 Ok(GetClusterLimitsResponse {
6053 active_limits: active_limits__.unwrap_or_default(),
6054 })
6055 }
6056 }
6057 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6058 }
6059}
6060impl serde::Serialize for GetClusterRecoveryStatusRequest {
6061 #[allow(deprecated)]
6062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6063 where
6064 S: serde::Serializer,
6065 {
6066 use serde::ser::SerializeStruct;
6067 let len = 0;
6068 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6069 struct_ser.end()
6070 }
6071}
6072impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6073 #[allow(deprecated)]
6074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6075 where
6076 D: serde::Deserializer<'de>,
6077 {
6078 const FIELDS: &[&str] = &[
6079 ];
6080
6081 #[allow(clippy::enum_variant_names)]
6082 enum GeneratedField {
6083 }
6084 impl<'de> serde::Deserialize<'de> for GeneratedField {
6085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6086 where
6087 D: serde::Deserializer<'de>,
6088 {
6089 struct GeneratedVisitor;
6090
6091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6092 type Value = GeneratedField;
6093
6094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6095 write!(formatter, "expected one of: {:?}", &FIELDS)
6096 }
6097
6098 #[allow(unused_variables)]
6099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6100 where
6101 E: serde::de::Error,
6102 {
6103 Err(serde::de::Error::unknown_field(value, FIELDS))
6104 }
6105 }
6106 deserializer.deserialize_identifier(GeneratedVisitor)
6107 }
6108 }
6109 struct GeneratedVisitor;
6110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6111 type Value = GetClusterRecoveryStatusRequest;
6112
6113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6114 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6115 }
6116
6117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6118 where
6119 V: serde::de::MapAccess<'de>,
6120 {
6121 while map_.next_key::<GeneratedField>()?.is_some() {
6122 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6123 }
6124 Ok(GetClusterRecoveryStatusRequest {
6125 })
6126 }
6127 }
6128 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6129 }
6130}
6131impl serde::Serialize for GetClusterRecoveryStatusResponse {
6132 #[allow(deprecated)]
6133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6134 where
6135 S: serde::Serializer,
6136 {
6137 use serde::ser::SerializeStruct;
6138 let mut len = 0;
6139 if self.status != 0 {
6140 len += 1;
6141 }
6142 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6143 if self.status != 0 {
6144 let v = RecoveryStatus::try_from(self.status)
6145 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6146 struct_ser.serialize_field("status", &v)?;
6147 }
6148 struct_ser.end()
6149 }
6150}
6151impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6152 #[allow(deprecated)]
6153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6154 where
6155 D: serde::Deserializer<'de>,
6156 {
6157 const FIELDS: &[&str] = &[
6158 "status",
6159 ];
6160
6161 #[allow(clippy::enum_variant_names)]
6162 enum GeneratedField {
6163 Status,
6164 }
6165 impl<'de> serde::Deserialize<'de> for GeneratedField {
6166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6167 where
6168 D: serde::Deserializer<'de>,
6169 {
6170 struct GeneratedVisitor;
6171
6172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6173 type Value = GeneratedField;
6174
6175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6176 write!(formatter, "expected one of: {:?}", &FIELDS)
6177 }
6178
6179 #[allow(unused_variables)]
6180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6181 where
6182 E: serde::de::Error,
6183 {
6184 match value {
6185 "status" => Ok(GeneratedField::Status),
6186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6187 }
6188 }
6189 }
6190 deserializer.deserialize_identifier(GeneratedVisitor)
6191 }
6192 }
6193 struct GeneratedVisitor;
6194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6195 type Value = GetClusterRecoveryStatusResponse;
6196
6197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6198 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6199 }
6200
6201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6202 where
6203 V: serde::de::MapAccess<'de>,
6204 {
6205 let mut status__ = None;
6206 while let Some(k) = map_.next_key()? {
6207 match k {
6208 GeneratedField::Status => {
6209 if status__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("status"));
6211 }
6212 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6213 }
6214 }
6215 }
6216 Ok(GetClusterRecoveryStatusResponse {
6217 status: status__.unwrap_or_default(),
6218 })
6219 }
6220 }
6221 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6222 }
6223}
6224impl serde::Serialize for GetFragmentByIdRequest {
6225 #[allow(deprecated)]
6226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6227 where
6228 S: serde::Serializer,
6229 {
6230 use serde::ser::SerializeStruct;
6231 let mut len = 0;
6232 if self.fragment_id != 0 {
6233 len += 1;
6234 }
6235 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6236 if self.fragment_id != 0 {
6237 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6238 }
6239 struct_ser.end()
6240 }
6241}
6242impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6243 #[allow(deprecated)]
6244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6245 where
6246 D: serde::Deserializer<'de>,
6247 {
6248 const FIELDS: &[&str] = &[
6249 "fragment_id",
6250 "fragmentId",
6251 ];
6252
6253 #[allow(clippy::enum_variant_names)]
6254 enum GeneratedField {
6255 FragmentId,
6256 }
6257 impl<'de> serde::Deserialize<'de> for GeneratedField {
6258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6259 where
6260 D: serde::Deserializer<'de>,
6261 {
6262 struct GeneratedVisitor;
6263
6264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6265 type Value = GeneratedField;
6266
6267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6268 write!(formatter, "expected one of: {:?}", &FIELDS)
6269 }
6270
6271 #[allow(unused_variables)]
6272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6273 where
6274 E: serde::de::Error,
6275 {
6276 match value {
6277 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6279 }
6280 }
6281 }
6282 deserializer.deserialize_identifier(GeneratedVisitor)
6283 }
6284 }
6285 struct GeneratedVisitor;
6286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6287 type Value = GetFragmentByIdRequest;
6288
6289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6290 formatter.write_str("struct meta.GetFragmentByIdRequest")
6291 }
6292
6293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6294 where
6295 V: serde::de::MapAccess<'de>,
6296 {
6297 let mut fragment_id__ = None;
6298 while let Some(k) = map_.next_key()? {
6299 match k {
6300 GeneratedField::FragmentId => {
6301 if fragment_id__.is_some() {
6302 return Err(serde::de::Error::duplicate_field("fragmentId"));
6303 }
6304 fragment_id__ =
6305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6306 ;
6307 }
6308 }
6309 }
6310 Ok(GetFragmentByIdRequest {
6311 fragment_id: fragment_id__.unwrap_or_default(),
6312 })
6313 }
6314 }
6315 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6316 }
6317}
6318impl serde::Serialize for GetFragmentByIdResponse {
6319 #[allow(deprecated)]
6320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6321 where
6322 S: serde::Serializer,
6323 {
6324 use serde::ser::SerializeStruct;
6325 let mut len = 0;
6326 if self.distribution.is_some() {
6327 len += 1;
6328 }
6329 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6330 if let Some(v) = self.distribution.as_ref() {
6331 struct_ser.serialize_field("distribution", v)?;
6332 }
6333 struct_ser.end()
6334 }
6335}
6336impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6337 #[allow(deprecated)]
6338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6339 where
6340 D: serde::Deserializer<'de>,
6341 {
6342 const FIELDS: &[&str] = &[
6343 "distribution",
6344 ];
6345
6346 #[allow(clippy::enum_variant_names)]
6347 enum GeneratedField {
6348 Distribution,
6349 }
6350 impl<'de> serde::Deserialize<'de> for GeneratedField {
6351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6352 where
6353 D: serde::Deserializer<'de>,
6354 {
6355 struct GeneratedVisitor;
6356
6357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6358 type Value = GeneratedField;
6359
6360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6361 write!(formatter, "expected one of: {:?}", &FIELDS)
6362 }
6363
6364 #[allow(unused_variables)]
6365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6366 where
6367 E: serde::de::Error,
6368 {
6369 match value {
6370 "distribution" => Ok(GeneratedField::Distribution),
6371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6372 }
6373 }
6374 }
6375 deserializer.deserialize_identifier(GeneratedVisitor)
6376 }
6377 }
6378 struct GeneratedVisitor;
6379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6380 type Value = GetFragmentByIdResponse;
6381
6382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6383 formatter.write_str("struct meta.GetFragmentByIdResponse")
6384 }
6385
6386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6387 where
6388 V: serde::de::MapAccess<'de>,
6389 {
6390 let mut distribution__ = None;
6391 while let Some(k) = map_.next_key()? {
6392 match k {
6393 GeneratedField::Distribution => {
6394 if distribution__.is_some() {
6395 return Err(serde::de::Error::duplicate_field("distribution"));
6396 }
6397 distribution__ = map_.next_value()?;
6398 }
6399 }
6400 }
6401 Ok(GetFragmentByIdResponse {
6402 distribution: distribution__,
6403 })
6404 }
6405 }
6406 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6407 }
6408}
6409impl serde::Serialize for GetMetaStoreInfoRequest {
6410 #[allow(deprecated)]
6411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6412 where
6413 S: serde::Serializer,
6414 {
6415 use serde::ser::SerializeStruct;
6416 let len = 0;
6417 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6418 struct_ser.end()
6419 }
6420}
6421impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6422 #[allow(deprecated)]
6423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6424 where
6425 D: serde::Deserializer<'de>,
6426 {
6427 const FIELDS: &[&str] = &[
6428 ];
6429
6430 #[allow(clippy::enum_variant_names)]
6431 enum GeneratedField {
6432 }
6433 impl<'de> serde::Deserialize<'de> for GeneratedField {
6434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6435 where
6436 D: serde::Deserializer<'de>,
6437 {
6438 struct GeneratedVisitor;
6439
6440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6441 type Value = GeneratedField;
6442
6443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6444 write!(formatter, "expected one of: {:?}", &FIELDS)
6445 }
6446
6447 #[allow(unused_variables)]
6448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6449 where
6450 E: serde::de::Error,
6451 {
6452 Err(serde::de::Error::unknown_field(value, FIELDS))
6453 }
6454 }
6455 deserializer.deserialize_identifier(GeneratedVisitor)
6456 }
6457 }
6458 struct GeneratedVisitor;
6459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6460 type Value = GetMetaStoreInfoRequest;
6461
6462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6463 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6464 }
6465
6466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6467 where
6468 V: serde::de::MapAccess<'de>,
6469 {
6470 while map_.next_key::<GeneratedField>()?.is_some() {
6471 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6472 }
6473 Ok(GetMetaStoreInfoRequest {
6474 })
6475 }
6476 }
6477 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6478 }
6479}
6480impl serde::Serialize for GetMetaStoreInfoResponse {
6481 #[allow(deprecated)]
6482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6483 where
6484 S: serde::Serializer,
6485 {
6486 use serde::ser::SerializeStruct;
6487 let mut len = 0;
6488 if !self.meta_store_endpoint.is_empty() {
6489 len += 1;
6490 }
6491 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6492 if !self.meta_store_endpoint.is_empty() {
6493 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6494 }
6495 struct_ser.end()
6496 }
6497}
6498impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6499 #[allow(deprecated)]
6500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6501 where
6502 D: serde::Deserializer<'de>,
6503 {
6504 const FIELDS: &[&str] = &[
6505 "meta_store_endpoint",
6506 "metaStoreEndpoint",
6507 ];
6508
6509 #[allow(clippy::enum_variant_names)]
6510 enum GeneratedField {
6511 MetaStoreEndpoint,
6512 }
6513 impl<'de> serde::Deserialize<'de> for GeneratedField {
6514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6515 where
6516 D: serde::Deserializer<'de>,
6517 {
6518 struct GeneratedVisitor;
6519
6520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6521 type Value = GeneratedField;
6522
6523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 write!(formatter, "expected one of: {:?}", &FIELDS)
6525 }
6526
6527 #[allow(unused_variables)]
6528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6529 where
6530 E: serde::de::Error,
6531 {
6532 match value {
6533 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6535 }
6536 }
6537 }
6538 deserializer.deserialize_identifier(GeneratedVisitor)
6539 }
6540 }
6541 struct GeneratedVisitor;
6542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6543 type Value = GetMetaStoreInfoResponse;
6544
6545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6546 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6547 }
6548
6549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6550 where
6551 V: serde::de::MapAccess<'de>,
6552 {
6553 let mut meta_store_endpoint__ = None;
6554 while let Some(k) = map_.next_key()? {
6555 match k {
6556 GeneratedField::MetaStoreEndpoint => {
6557 if meta_store_endpoint__.is_some() {
6558 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6559 }
6560 meta_store_endpoint__ = Some(map_.next_value()?);
6561 }
6562 }
6563 }
6564 Ok(GetMetaStoreInfoResponse {
6565 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6566 })
6567 }
6568 }
6569 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6570 }
6571}
6572impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6573 #[allow(deprecated)]
6574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6575 where
6576 S: serde::Serializer,
6577 {
6578 use serde::ser::SerializeStruct;
6579 let len = 0;
6580 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6581 struct_ser.end()
6582 }
6583}
6584impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6585 #[allow(deprecated)]
6586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6587 where
6588 D: serde::Deserializer<'de>,
6589 {
6590 const FIELDS: &[&str] = &[
6591 ];
6592
6593 #[allow(clippy::enum_variant_names)]
6594 enum GeneratedField {
6595 }
6596 impl<'de> serde::Deserialize<'de> for GeneratedField {
6597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6598 where
6599 D: serde::Deserializer<'de>,
6600 {
6601 struct GeneratedVisitor;
6602
6603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6604 type Value = GeneratedField;
6605
6606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6607 write!(formatter, "expected one of: {:?}", &FIELDS)
6608 }
6609
6610 #[allow(unused_variables)]
6611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6612 where
6613 E: serde::de::Error,
6614 {
6615 Err(serde::de::Error::unknown_field(value, FIELDS))
6616 }
6617 }
6618 deserializer.deserialize_identifier(GeneratedVisitor)
6619 }
6620 }
6621 struct GeneratedVisitor;
6622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6623 type Value = GetServerlessStreamingJobsStatusRequest;
6624
6625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6626 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6627 }
6628
6629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6630 where
6631 V: serde::de::MapAccess<'de>,
6632 {
6633 while map_.next_key::<GeneratedField>()?.is_some() {
6634 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6635 }
6636 Ok(GetServerlessStreamingJobsStatusRequest {
6637 })
6638 }
6639 }
6640 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6641 }
6642}
6643impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6644 #[allow(deprecated)]
6645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6646 where
6647 S: serde::Serializer,
6648 {
6649 use serde::ser::SerializeStruct;
6650 let mut len = 0;
6651 if !self.streaming_job_statuses.is_empty() {
6652 len += 1;
6653 }
6654 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6655 if !self.streaming_job_statuses.is_empty() {
6656 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6657 }
6658 struct_ser.end()
6659 }
6660}
6661impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6662 #[allow(deprecated)]
6663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6664 where
6665 D: serde::Deserializer<'de>,
6666 {
6667 const FIELDS: &[&str] = &[
6668 "streaming_job_statuses",
6669 "streamingJobStatuses",
6670 ];
6671
6672 #[allow(clippy::enum_variant_names)]
6673 enum GeneratedField {
6674 StreamingJobStatuses,
6675 }
6676 impl<'de> serde::Deserialize<'de> for GeneratedField {
6677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6678 where
6679 D: serde::Deserializer<'de>,
6680 {
6681 struct GeneratedVisitor;
6682
6683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6684 type Value = GeneratedField;
6685
6686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6687 write!(formatter, "expected one of: {:?}", &FIELDS)
6688 }
6689
6690 #[allow(unused_variables)]
6691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6692 where
6693 E: serde::de::Error,
6694 {
6695 match value {
6696 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6698 }
6699 }
6700 }
6701 deserializer.deserialize_identifier(GeneratedVisitor)
6702 }
6703 }
6704 struct GeneratedVisitor;
6705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6706 type Value = GetServerlessStreamingJobsStatusResponse;
6707
6708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6709 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6710 }
6711
6712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6713 where
6714 V: serde::de::MapAccess<'de>,
6715 {
6716 let mut streaming_job_statuses__ = None;
6717 while let Some(k) = map_.next_key()? {
6718 match k {
6719 GeneratedField::StreamingJobStatuses => {
6720 if streaming_job_statuses__.is_some() {
6721 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6722 }
6723 streaming_job_statuses__ = Some(map_.next_value()?);
6724 }
6725 }
6726 }
6727 Ok(GetServerlessStreamingJobsStatusResponse {
6728 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6729 })
6730 }
6731 }
6732 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6733 }
6734}
6735impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6736 #[allow(deprecated)]
6737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6738 where
6739 S: serde::Serializer,
6740 {
6741 use serde::ser::SerializeStruct;
6742 let mut len = 0;
6743 if self.table_id != 0 {
6744 len += 1;
6745 }
6746 if !self.node_label.is_empty() {
6747 len += 1;
6748 }
6749 if self.backfill_done {
6750 len += 1;
6751 }
6752 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6753 if self.table_id != 0 {
6754 struct_ser.serialize_field("tableId", &self.table_id)?;
6755 }
6756 if !self.node_label.is_empty() {
6757 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6758 }
6759 if self.backfill_done {
6760 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6761 }
6762 struct_ser.end()
6763 }
6764}
6765impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6766 #[allow(deprecated)]
6767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6768 where
6769 D: serde::Deserializer<'de>,
6770 {
6771 const FIELDS: &[&str] = &[
6772 "table_id",
6773 "tableId",
6774 "node_label",
6775 "nodeLabel",
6776 "backfill_done",
6777 "backfillDone",
6778 ];
6779
6780 #[allow(clippy::enum_variant_names)]
6781 enum GeneratedField {
6782 TableId,
6783 NodeLabel,
6784 BackfillDone,
6785 }
6786 impl<'de> serde::Deserialize<'de> for GeneratedField {
6787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6788 where
6789 D: serde::Deserializer<'de>,
6790 {
6791 struct GeneratedVisitor;
6792
6793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6794 type Value = GeneratedField;
6795
6796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6797 write!(formatter, "expected one of: {:?}", &FIELDS)
6798 }
6799
6800 #[allow(unused_variables)]
6801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6802 where
6803 E: serde::de::Error,
6804 {
6805 match value {
6806 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6807 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6808 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = get_serverless_streaming_jobs_status_response::Status;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut table_id__ = None;
6829 let mut node_label__ = None;
6830 let mut backfill_done__ = None;
6831 while let Some(k) = map_.next_key()? {
6832 match k {
6833 GeneratedField::TableId => {
6834 if table_id__.is_some() {
6835 return Err(serde::de::Error::duplicate_field("tableId"));
6836 }
6837 table_id__ =
6838 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6839 ;
6840 }
6841 GeneratedField::NodeLabel => {
6842 if node_label__.is_some() {
6843 return Err(serde::de::Error::duplicate_field("nodeLabel"));
6844 }
6845 node_label__ = Some(map_.next_value()?);
6846 }
6847 GeneratedField::BackfillDone => {
6848 if backfill_done__.is_some() {
6849 return Err(serde::de::Error::duplicate_field("backfillDone"));
6850 }
6851 backfill_done__ = Some(map_.next_value()?);
6852 }
6853 }
6854 }
6855 Ok(get_serverless_streaming_jobs_status_response::Status {
6856 table_id: table_id__.unwrap_or_default(),
6857 node_label: node_label__.unwrap_or_default(),
6858 backfill_done: backfill_done__.unwrap_or_default(),
6859 })
6860 }
6861 }
6862 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
6863 }
6864}
6865impl serde::Serialize for GetServingVnodeMappingsRequest {
6866 #[allow(deprecated)]
6867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6868 where
6869 S: serde::Serializer,
6870 {
6871 use serde::ser::SerializeStruct;
6872 let len = 0;
6873 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
6874 struct_ser.end()
6875 }
6876}
6877impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
6878 #[allow(deprecated)]
6879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6880 where
6881 D: serde::Deserializer<'de>,
6882 {
6883 const FIELDS: &[&str] = &[
6884 ];
6885
6886 #[allow(clippy::enum_variant_names)]
6887 enum GeneratedField {
6888 }
6889 impl<'de> serde::Deserialize<'de> for GeneratedField {
6890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6891 where
6892 D: serde::Deserializer<'de>,
6893 {
6894 struct GeneratedVisitor;
6895
6896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6897 type Value = GeneratedField;
6898
6899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6900 write!(formatter, "expected one of: {:?}", &FIELDS)
6901 }
6902
6903 #[allow(unused_variables)]
6904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6905 where
6906 E: serde::de::Error,
6907 {
6908 Err(serde::de::Error::unknown_field(value, FIELDS))
6909 }
6910 }
6911 deserializer.deserialize_identifier(GeneratedVisitor)
6912 }
6913 }
6914 struct GeneratedVisitor;
6915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6916 type Value = GetServingVnodeMappingsRequest;
6917
6918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6919 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
6920 }
6921
6922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
6923 where
6924 V: serde::de::MapAccess<'de>,
6925 {
6926 while map_.next_key::<GeneratedField>()?.is_some() {
6927 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6928 }
6929 Ok(GetServingVnodeMappingsRequest {
6930 })
6931 }
6932 }
6933 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
6934 }
6935}
6936impl serde::Serialize for GetServingVnodeMappingsResponse {
6937 #[allow(deprecated)]
6938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6939 where
6940 S: serde::Serializer,
6941 {
6942 use serde::ser::SerializeStruct;
6943 let mut len = 0;
6944 if !self.fragment_to_table.is_empty() {
6945 len += 1;
6946 }
6947 if !self.worker_slot_mappings.is_empty() {
6948 len += 1;
6949 }
6950 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
6951 if !self.fragment_to_table.is_empty() {
6952 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
6953 }
6954 if !self.worker_slot_mappings.is_empty() {
6955 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
6956 }
6957 struct_ser.end()
6958 }
6959}
6960impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
6961 #[allow(deprecated)]
6962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6963 where
6964 D: serde::Deserializer<'de>,
6965 {
6966 const FIELDS: &[&str] = &[
6967 "fragment_to_table",
6968 "fragmentToTable",
6969 "worker_slot_mappings",
6970 "workerSlotMappings",
6971 ];
6972
6973 #[allow(clippy::enum_variant_names)]
6974 enum GeneratedField {
6975 FragmentToTable,
6976 WorkerSlotMappings,
6977 }
6978 impl<'de> serde::Deserialize<'de> for GeneratedField {
6979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6980 where
6981 D: serde::Deserializer<'de>,
6982 {
6983 struct GeneratedVisitor;
6984
6985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6986 type Value = GeneratedField;
6987
6988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6989 write!(formatter, "expected one of: {:?}", &FIELDS)
6990 }
6991
6992 #[allow(unused_variables)]
6993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6994 where
6995 E: serde::de::Error,
6996 {
6997 match value {
6998 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
6999 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7001 }
7002 }
7003 }
7004 deserializer.deserialize_identifier(GeneratedVisitor)
7005 }
7006 }
7007 struct GeneratedVisitor;
7008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7009 type Value = GetServingVnodeMappingsResponse;
7010
7011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7012 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7013 }
7014
7015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7016 where
7017 V: serde::de::MapAccess<'de>,
7018 {
7019 let mut fragment_to_table__ = None;
7020 let mut worker_slot_mappings__ = None;
7021 while let Some(k) = map_.next_key()? {
7022 match k {
7023 GeneratedField::FragmentToTable => {
7024 if fragment_to_table__.is_some() {
7025 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7026 }
7027 fragment_to_table__ = Some(
7028 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7029 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7030 );
7031 }
7032 GeneratedField::WorkerSlotMappings => {
7033 if worker_slot_mappings__.is_some() {
7034 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7035 }
7036 worker_slot_mappings__ = Some(map_.next_value()?);
7037 }
7038 }
7039 }
7040 Ok(GetServingVnodeMappingsResponse {
7041 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7042 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7043 })
7044 }
7045 }
7046 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7047 }
7048}
7049impl serde::Serialize for GetSessionParamsRequest {
7050 #[allow(deprecated)]
7051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7052 where
7053 S: serde::Serializer,
7054 {
7055 use serde::ser::SerializeStruct;
7056 let len = 0;
7057 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7058 struct_ser.end()
7059 }
7060}
7061impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7062 #[allow(deprecated)]
7063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7064 where
7065 D: serde::Deserializer<'de>,
7066 {
7067 const FIELDS: &[&str] = &[
7068 ];
7069
7070 #[allow(clippy::enum_variant_names)]
7071 enum GeneratedField {
7072 }
7073 impl<'de> serde::Deserialize<'de> for GeneratedField {
7074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7075 where
7076 D: serde::Deserializer<'de>,
7077 {
7078 struct GeneratedVisitor;
7079
7080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7081 type Value = GeneratedField;
7082
7083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7084 write!(formatter, "expected one of: {:?}", &FIELDS)
7085 }
7086
7087 #[allow(unused_variables)]
7088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7089 where
7090 E: serde::de::Error,
7091 {
7092 Err(serde::de::Error::unknown_field(value, FIELDS))
7093 }
7094 }
7095 deserializer.deserialize_identifier(GeneratedVisitor)
7096 }
7097 }
7098 struct GeneratedVisitor;
7099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7100 type Value = GetSessionParamsRequest;
7101
7102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7103 formatter.write_str("struct meta.GetSessionParamsRequest")
7104 }
7105
7106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7107 where
7108 V: serde::de::MapAccess<'de>,
7109 {
7110 while map_.next_key::<GeneratedField>()?.is_some() {
7111 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7112 }
7113 Ok(GetSessionParamsRequest {
7114 })
7115 }
7116 }
7117 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7118 }
7119}
7120impl serde::Serialize for GetSessionParamsResponse {
7121 #[allow(deprecated)]
7122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7123 where
7124 S: serde::Serializer,
7125 {
7126 use serde::ser::SerializeStruct;
7127 let mut len = 0;
7128 if !self.params.is_empty() {
7129 len += 1;
7130 }
7131 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7132 if !self.params.is_empty() {
7133 struct_ser.serialize_field("params", &self.params)?;
7134 }
7135 struct_ser.end()
7136 }
7137}
7138impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7139 #[allow(deprecated)]
7140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7141 where
7142 D: serde::Deserializer<'de>,
7143 {
7144 const FIELDS: &[&str] = &[
7145 "params",
7146 ];
7147
7148 #[allow(clippy::enum_variant_names)]
7149 enum GeneratedField {
7150 Params,
7151 }
7152 impl<'de> serde::Deserialize<'de> for GeneratedField {
7153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7154 where
7155 D: serde::Deserializer<'de>,
7156 {
7157 struct GeneratedVisitor;
7158
7159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7160 type Value = GeneratedField;
7161
7162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7163 write!(formatter, "expected one of: {:?}", &FIELDS)
7164 }
7165
7166 #[allow(unused_variables)]
7167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7168 where
7169 E: serde::de::Error,
7170 {
7171 match value {
7172 "params" => Ok(GeneratedField::Params),
7173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7174 }
7175 }
7176 }
7177 deserializer.deserialize_identifier(GeneratedVisitor)
7178 }
7179 }
7180 struct GeneratedVisitor;
7181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7182 type Value = GetSessionParamsResponse;
7183
7184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7185 formatter.write_str("struct meta.GetSessionParamsResponse")
7186 }
7187
7188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7189 where
7190 V: serde::de::MapAccess<'de>,
7191 {
7192 let mut params__ = None;
7193 while let Some(k) = map_.next_key()? {
7194 match k {
7195 GeneratedField::Params => {
7196 if params__.is_some() {
7197 return Err(serde::de::Error::duplicate_field("params"));
7198 }
7199 params__ = Some(map_.next_value()?);
7200 }
7201 }
7202 }
7203 Ok(GetSessionParamsResponse {
7204 params: params__.unwrap_or_default(),
7205 })
7206 }
7207 }
7208 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7209 }
7210}
7211impl serde::Serialize for GetSystemParamsRequest {
7212 #[allow(deprecated)]
7213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7214 where
7215 S: serde::Serializer,
7216 {
7217 use serde::ser::SerializeStruct;
7218 let len = 0;
7219 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7220 struct_ser.end()
7221 }
7222}
7223impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7224 #[allow(deprecated)]
7225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7226 where
7227 D: serde::Deserializer<'de>,
7228 {
7229 const FIELDS: &[&str] = &[
7230 ];
7231
7232 #[allow(clippy::enum_variant_names)]
7233 enum GeneratedField {
7234 }
7235 impl<'de> serde::Deserialize<'de> for GeneratedField {
7236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7237 where
7238 D: serde::Deserializer<'de>,
7239 {
7240 struct GeneratedVisitor;
7241
7242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7243 type Value = GeneratedField;
7244
7245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7246 write!(formatter, "expected one of: {:?}", &FIELDS)
7247 }
7248
7249 #[allow(unused_variables)]
7250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7251 where
7252 E: serde::de::Error,
7253 {
7254 Err(serde::de::Error::unknown_field(value, FIELDS))
7255 }
7256 }
7257 deserializer.deserialize_identifier(GeneratedVisitor)
7258 }
7259 }
7260 struct GeneratedVisitor;
7261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7262 type Value = GetSystemParamsRequest;
7263
7264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7265 formatter.write_str("struct meta.GetSystemParamsRequest")
7266 }
7267
7268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7269 where
7270 V: serde::de::MapAccess<'de>,
7271 {
7272 while map_.next_key::<GeneratedField>()?.is_some() {
7273 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7274 }
7275 Ok(GetSystemParamsRequest {
7276 })
7277 }
7278 }
7279 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7280 }
7281}
7282impl serde::Serialize for GetSystemParamsResponse {
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 mut len = 0;
7290 if self.params.is_some() {
7291 len += 1;
7292 }
7293 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7294 if let Some(v) = self.params.as_ref() {
7295 struct_ser.serialize_field("params", v)?;
7296 }
7297 struct_ser.end()
7298 }
7299}
7300impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7301 #[allow(deprecated)]
7302 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7303 where
7304 D: serde::Deserializer<'de>,
7305 {
7306 const FIELDS: &[&str] = &[
7307 "params",
7308 ];
7309
7310 #[allow(clippy::enum_variant_names)]
7311 enum GeneratedField {
7312 Params,
7313 }
7314 impl<'de> serde::Deserialize<'de> for GeneratedField {
7315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7316 where
7317 D: serde::Deserializer<'de>,
7318 {
7319 struct GeneratedVisitor;
7320
7321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7322 type Value = GeneratedField;
7323
7324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7325 write!(formatter, "expected one of: {:?}", &FIELDS)
7326 }
7327
7328 #[allow(unused_variables)]
7329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7330 where
7331 E: serde::de::Error,
7332 {
7333 match value {
7334 "params" => Ok(GeneratedField::Params),
7335 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7336 }
7337 }
7338 }
7339 deserializer.deserialize_identifier(GeneratedVisitor)
7340 }
7341 }
7342 struct GeneratedVisitor;
7343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7344 type Value = GetSystemParamsResponse;
7345
7346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7347 formatter.write_str("struct meta.GetSystemParamsResponse")
7348 }
7349
7350 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7351 where
7352 V: serde::de::MapAccess<'de>,
7353 {
7354 let mut params__ = None;
7355 while let Some(k) = map_.next_key()? {
7356 match k {
7357 GeneratedField::Params => {
7358 if params__.is_some() {
7359 return Err(serde::de::Error::duplicate_field("params"));
7360 }
7361 params__ = map_.next_value()?;
7362 }
7363 }
7364 }
7365 Ok(GetSystemParamsResponse {
7366 params: params__,
7367 })
7368 }
7369 }
7370 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7371 }
7372}
7373impl serde::Serialize for GetTelemetryInfoRequest {
7374 #[allow(deprecated)]
7375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7376 where
7377 S: serde::Serializer,
7378 {
7379 use serde::ser::SerializeStruct;
7380 let len = 0;
7381 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7382 struct_ser.end()
7383 }
7384}
7385impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7386 #[allow(deprecated)]
7387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7388 where
7389 D: serde::Deserializer<'de>,
7390 {
7391 const FIELDS: &[&str] = &[
7392 ];
7393
7394 #[allow(clippy::enum_variant_names)]
7395 enum GeneratedField {
7396 }
7397 impl<'de> serde::Deserialize<'de> for GeneratedField {
7398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7399 where
7400 D: serde::Deserializer<'de>,
7401 {
7402 struct GeneratedVisitor;
7403
7404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7405 type Value = GeneratedField;
7406
7407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7408 write!(formatter, "expected one of: {:?}", &FIELDS)
7409 }
7410
7411 #[allow(unused_variables)]
7412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7413 where
7414 E: serde::de::Error,
7415 {
7416 Err(serde::de::Error::unknown_field(value, FIELDS))
7417 }
7418 }
7419 deserializer.deserialize_identifier(GeneratedVisitor)
7420 }
7421 }
7422 struct GeneratedVisitor;
7423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7424 type Value = GetTelemetryInfoRequest;
7425
7426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7427 formatter.write_str("struct meta.GetTelemetryInfoRequest")
7428 }
7429
7430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7431 where
7432 V: serde::de::MapAccess<'de>,
7433 {
7434 while map_.next_key::<GeneratedField>()?.is_some() {
7435 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7436 }
7437 Ok(GetTelemetryInfoRequest {
7438 })
7439 }
7440 }
7441 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7442 }
7443}
7444impl serde::Serialize for HeartbeatRequest {
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.node_id != 0 {
7453 len += 1;
7454 }
7455 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7456 if self.node_id != 0 {
7457 struct_ser.serialize_field("nodeId", &self.node_id)?;
7458 }
7459 struct_ser.end()
7460 }
7461}
7462impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7463 #[allow(deprecated)]
7464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7465 where
7466 D: serde::Deserializer<'de>,
7467 {
7468 const FIELDS: &[&str] = &[
7469 "node_id",
7470 "nodeId",
7471 ];
7472
7473 #[allow(clippy::enum_variant_names)]
7474 enum GeneratedField {
7475 NodeId,
7476 }
7477 impl<'de> serde::Deserialize<'de> for GeneratedField {
7478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7479 where
7480 D: serde::Deserializer<'de>,
7481 {
7482 struct GeneratedVisitor;
7483
7484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7485 type Value = GeneratedField;
7486
7487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7488 write!(formatter, "expected one of: {:?}", &FIELDS)
7489 }
7490
7491 #[allow(unused_variables)]
7492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7493 where
7494 E: serde::de::Error,
7495 {
7496 match value {
7497 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7499 }
7500 }
7501 }
7502 deserializer.deserialize_identifier(GeneratedVisitor)
7503 }
7504 }
7505 struct GeneratedVisitor;
7506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7507 type Value = HeartbeatRequest;
7508
7509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7510 formatter.write_str("struct meta.HeartbeatRequest")
7511 }
7512
7513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7514 where
7515 V: serde::de::MapAccess<'de>,
7516 {
7517 let mut node_id__ = None;
7518 while let Some(k) = map_.next_key()? {
7519 match k {
7520 GeneratedField::NodeId => {
7521 if node_id__.is_some() {
7522 return Err(serde::de::Error::duplicate_field("nodeId"));
7523 }
7524 node_id__ =
7525 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7526 ;
7527 }
7528 }
7529 }
7530 Ok(HeartbeatRequest {
7531 node_id: node_id__.unwrap_or_default(),
7532 })
7533 }
7534 }
7535 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7536 }
7537}
7538impl serde::Serialize for HeartbeatResponse {
7539 #[allow(deprecated)]
7540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7541 where
7542 S: serde::Serializer,
7543 {
7544 use serde::ser::SerializeStruct;
7545 let mut len = 0;
7546 if self.status.is_some() {
7547 len += 1;
7548 }
7549 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7550 if let Some(v) = self.status.as_ref() {
7551 struct_ser.serialize_field("status", v)?;
7552 }
7553 struct_ser.end()
7554 }
7555}
7556impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7557 #[allow(deprecated)]
7558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7559 where
7560 D: serde::Deserializer<'de>,
7561 {
7562 const FIELDS: &[&str] = &[
7563 "status",
7564 ];
7565
7566 #[allow(clippy::enum_variant_names)]
7567 enum GeneratedField {
7568 Status,
7569 }
7570 impl<'de> serde::Deserialize<'de> for GeneratedField {
7571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7572 where
7573 D: serde::Deserializer<'de>,
7574 {
7575 struct GeneratedVisitor;
7576
7577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7578 type Value = GeneratedField;
7579
7580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7581 write!(formatter, "expected one of: {:?}", &FIELDS)
7582 }
7583
7584 #[allow(unused_variables)]
7585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7586 where
7587 E: serde::de::Error,
7588 {
7589 match value {
7590 "status" => Ok(GeneratedField::Status),
7591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7592 }
7593 }
7594 }
7595 deserializer.deserialize_identifier(GeneratedVisitor)
7596 }
7597 }
7598 struct GeneratedVisitor;
7599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7600 type Value = HeartbeatResponse;
7601
7602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7603 formatter.write_str("struct meta.HeartbeatResponse")
7604 }
7605
7606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7607 where
7608 V: serde::de::MapAccess<'de>,
7609 {
7610 let mut status__ = None;
7611 while let Some(k) = map_.next_key()? {
7612 match k {
7613 GeneratedField::Status => {
7614 if status__.is_some() {
7615 return Err(serde::de::Error::duplicate_field("status"));
7616 }
7617 status__ = map_.next_value()?;
7618 }
7619 }
7620 }
7621 Ok(HeartbeatResponse {
7622 status: status__,
7623 })
7624 }
7625 }
7626 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7627 }
7628}
7629impl serde::Serialize for ListActorSplitsRequest {
7630 #[allow(deprecated)]
7631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7632 where
7633 S: serde::Serializer,
7634 {
7635 use serde::ser::SerializeStruct;
7636 let len = 0;
7637 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7638 struct_ser.end()
7639 }
7640}
7641impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7642 #[allow(deprecated)]
7643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7644 where
7645 D: serde::Deserializer<'de>,
7646 {
7647 const FIELDS: &[&str] = &[
7648 ];
7649
7650 #[allow(clippy::enum_variant_names)]
7651 enum GeneratedField {
7652 }
7653 impl<'de> serde::Deserialize<'de> for GeneratedField {
7654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7655 where
7656 D: serde::Deserializer<'de>,
7657 {
7658 struct GeneratedVisitor;
7659
7660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7661 type Value = GeneratedField;
7662
7663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7664 write!(formatter, "expected one of: {:?}", &FIELDS)
7665 }
7666
7667 #[allow(unused_variables)]
7668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7669 where
7670 E: serde::de::Error,
7671 {
7672 Err(serde::de::Error::unknown_field(value, FIELDS))
7673 }
7674 }
7675 deserializer.deserialize_identifier(GeneratedVisitor)
7676 }
7677 }
7678 struct GeneratedVisitor;
7679 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7680 type Value = ListActorSplitsRequest;
7681
7682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7683 formatter.write_str("struct meta.ListActorSplitsRequest")
7684 }
7685
7686 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7687 where
7688 V: serde::de::MapAccess<'de>,
7689 {
7690 while map_.next_key::<GeneratedField>()?.is_some() {
7691 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7692 }
7693 Ok(ListActorSplitsRequest {
7694 })
7695 }
7696 }
7697 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7698 }
7699}
7700impl serde::Serialize for ListActorSplitsResponse {
7701 #[allow(deprecated)]
7702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7703 where
7704 S: serde::Serializer,
7705 {
7706 use serde::ser::SerializeStruct;
7707 let mut len = 0;
7708 if !self.actor_splits.is_empty() {
7709 len += 1;
7710 }
7711 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7712 if !self.actor_splits.is_empty() {
7713 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7714 }
7715 struct_ser.end()
7716 }
7717}
7718impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7719 #[allow(deprecated)]
7720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7721 where
7722 D: serde::Deserializer<'de>,
7723 {
7724 const FIELDS: &[&str] = &[
7725 "actor_splits",
7726 "actorSplits",
7727 ];
7728
7729 #[allow(clippy::enum_variant_names)]
7730 enum GeneratedField {
7731 ActorSplits,
7732 }
7733 impl<'de> serde::Deserialize<'de> for GeneratedField {
7734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7735 where
7736 D: serde::Deserializer<'de>,
7737 {
7738 struct GeneratedVisitor;
7739
7740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7741 type Value = GeneratedField;
7742
7743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7744 write!(formatter, "expected one of: {:?}", &FIELDS)
7745 }
7746
7747 #[allow(unused_variables)]
7748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7749 where
7750 E: serde::de::Error,
7751 {
7752 match value {
7753 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7755 }
7756 }
7757 }
7758 deserializer.deserialize_identifier(GeneratedVisitor)
7759 }
7760 }
7761 struct GeneratedVisitor;
7762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7763 type Value = ListActorSplitsResponse;
7764
7765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7766 formatter.write_str("struct meta.ListActorSplitsResponse")
7767 }
7768
7769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7770 where
7771 V: serde::de::MapAccess<'de>,
7772 {
7773 let mut actor_splits__ = None;
7774 while let Some(k) = map_.next_key()? {
7775 match k {
7776 GeneratedField::ActorSplits => {
7777 if actor_splits__.is_some() {
7778 return Err(serde::de::Error::duplicate_field("actorSplits"));
7779 }
7780 actor_splits__ = Some(map_.next_value()?);
7781 }
7782 }
7783 }
7784 Ok(ListActorSplitsResponse {
7785 actor_splits: actor_splits__.unwrap_or_default(),
7786 })
7787 }
7788 }
7789 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7790 }
7791}
7792impl serde::Serialize for list_actor_splits_response::ActorSplit {
7793 #[allow(deprecated)]
7794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7795 where
7796 S: serde::Serializer,
7797 {
7798 use serde::ser::SerializeStruct;
7799 let mut len = 0;
7800 if self.actor_id != 0 {
7801 len += 1;
7802 }
7803 if self.fragment_id != 0 {
7804 len += 1;
7805 }
7806 if self.source_id != 0 {
7807 len += 1;
7808 }
7809 if !self.split_id.is_empty() {
7810 len += 1;
7811 }
7812 if self.fragment_type != 0 {
7813 len += 1;
7814 }
7815 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7816 if self.actor_id != 0 {
7817 struct_ser.serialize_field("actorId", &self.actor_id)?;
7818 }
7819 if self.fragment_id != 0 {
7820 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7821 }
7822 if self.source_id != 0 {
7823 struct_ser.serialize_field("sourceId", &self.source_id)?;
7824 }
7825 if !self.split_id.is_empty() {
7826 struct_ser.serialize_field("splitId", &self.split_id)?;
7827 }
7828 if self.fragment_type != 0 {
7829 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7830 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7831 struct_ser.serialize_field("fragmentType", &v)?;
7832 }
7833 struct_ser.end()
7834 }
7835}
7836impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7837 #[allow(deprecated)]
7838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7839 where
7840 D: serde::Deserializer<'de>,
7841 {
7842 const FIELDS: &[&str] = &[
7843 "actor_id",
7844 "actorId",
7845 "fragment_id",
7846 "fragmentId",
7847 "source_id",
7848 "sourceId",
7849 "split_id",
7850 "splitId",
7851 "fragment_type",
7852 "fragmentType",
7853 ];
7854
7855 #[allow(clippy::enum_variant_names)]
7856 enum GeneratedField {
7857 ActorId,
7858 FragmentId,
7859 SourceId,
7860 SplitId,
7861 FragmentType,
7862 }
7863 impl<'de> serde::Deserialize<'de> for GeneratedField {
7864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7865 where
7866 D: serde::Deserializer<'de>,
7867 {
7868 struct GeneratedVisitor;
7869
7870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7871 type Value = GeneratedField;
7872
7873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7874 write!(formatter, "expected one of: {:?}", &FIELDS)
7875 }
7876
7877 #[allow(unused_variables)]
7878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7879 where
7880 E: serde::de::Error,
7881 {
7882 match value {
7883 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7884 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7885 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7886 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
7887 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
7888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7889 }
7890 }
7891 }
7892 deserializer.deserialize_identifier(GeneratedVisitor)
7893 }
7894 }
7895 struct GeneratedVisitor;
7896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7897 type Value = list_actor_splits_response::ActorSplit;
7898
7899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7900 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
7901 }
7902
7903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
7904 where
7905 V: serde::de::MapAccess<'de>,
7906 {
7907 let mut actor_id__ = None;
7908 let mut fragment_id__ = None;
7909 let mut source_id__ = None;
7910 let mut split_id__ = None;
7911 let mut fragment_type__ = None;
7912 while let Some(k) = map_.next_key()? {
7913 match k {
7914 GeneratedField::ActorId => {
7915 if actor_id__.is_some() {
7916 return Err(serde::de::Error::duplicate_field("actorId"));
7917 }
7918 actor_id__ =
7919 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7920 ;
7921 }
7922 GeneratedField::FragmentId => {
7923 if fragment_id__.is_some() {
7924 return Err(serde::de::Error::duplicate_field("fragmentId"));
7925 }
7926 fragment_id__ =
7927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7928 ;
7929 }
7930 GeneratedField::SourceId => {
7931 if source_id__.is_some() {
7932 return Err(serde::de::Error::duplicate_field("sourceId"));
7933 }
7934 source_id__ =
7935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7936 ;
7937 }
7938 GeneratedField::SplitId => {
7939 if split_id__.is_some() {
7940 return Err(serde::de::Error::duplicate_field("splitId"));
7941 }
7942 split_id__ = Some(map_.next_value()?);
7943 }
7944 GeneratedField::FragmentType => {
7945 if fragment_type__.is_some() {
7946 return Err(serde::de::Error::duplicate_field("fragmentType"));
7947 }
7948 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
7949 }
7950 }
7951 }
7952 Ok(list_actor_splits_response::ActorSplit {
7953 actor_id: actor_id__.unwrap_or_default(),
7954 fragment_id: fragment_id__.unwrap_or_default(),
7955 source_id: source_id__.unwrap_or_default(),
7956 split_id: split_id__.unwrap_or_default(),
7957 fragment_type: fragment_type__.unwrap_or_default(),
7958 })
7959 }
7960 }
7961 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
7962 }
7963}
7964impl serde::Serialize for list_actor_splits_response::FragmentType {
7965 #[allow(deprecated)]
7966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7967 where
7968 S: serde::Serializer,
7969 {
7970 let variant = match self {
7971 Self::Unspecified => "UNSPECIFIED",
7972 Self::NonSharedSource => "NON_SHARED_SOURCE",
7973 Self::SharedSource => "SHARED_SOURCE",
7974 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
7975 };
7976 serializer.serialize_str(variant)
7977 }
7978}
7979impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
7980 #[allow(deprecated)]
7981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7982 where
7983 D: serde::Deserializer<'de>,
7984 {
7985 const FIELDS: &[&str] = &[
7986 "UNSPECIFIED",
7987 "NON_SHARED_SOURCE",
7988 "SHARED_SOURCE",
7989 "SHARED_SOURCE_BACKFILL",
7990 ];
7991
7992 struct GeneratedVisitor;
7993
7994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7995 type Value = list_actor_splits_response::FragmentType;
7996
7997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7998 write!(formatter, "expected one of: {:?}", &FIELDS)
7999 }
8000
8001 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8002 where
8003 E: serde::de::Error,
8004 {
8005 i32::try_from(v)
8006 .ok()
8007 .and_then(|x| x.try_into().ok())
8008 .ok_or_else(|| {
8009 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8010 })
8011 }
8012
8013 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8014 where
8015 E: serde::de::Error,
8016 {
8017 i32::try_from(v)
8018 .ok()
8019 .and_then(|x| x.try_into().ok())
8020 .ok_or_else(|| {
8021 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8022 })
8023 }
8024
8025 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8026 where
8027 E: serde::de::Error,
8028 {
8029 match value {
8030 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8031 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8032 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8033 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8034 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8035 }
8036 }
8037 }
8038 deserializer.deserialize_any(GeneratedVisitor)
8039 }
8040}
8041impl serde::Serialize for ListActorStatesRequest {
8042 #[allow(deprecated)]
8043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8044 where
8045 S: serde::Serializer,
8046 {
8047 use serde::ser::SerializeStruct;
8048 let len = 0;
8049 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8050 struct_ser.end()
8051 }
8052}
8053impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8054 #[allow(deprecated)]
8055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8056 where
8057 D: serde::Deserializer<'de>,
8058 {
8059 const FIELDS: &[&str] = &[
8060 ];
8061
8062 #[allow(clippy::enum_variant_names)]
8063 enum GeneratedField {
8064 }
8065 impl<'de> serde::Deserialize<'de> for GeneratedField {
8066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8067 where
8068 D: serde::Deserializer<'de>,
8069 {
8070 struct GeneratedVisitor;
8071
8072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8073 type Value = GeneratedField;
8074
8075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8076 write!(formatter, "expected one of: {:?}", &FIELDS)
8077 }
8078
8079 #[allow(unused_variables)]
8080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8081 where
8082 E: serde::de::Error,
8083 {
8084 Err(serde::de::Error::unknown_field(value, FIELDS))
8085 }
8086 }
8087 deserializer.deserialize_identifier(GeneratedVisitor)
8088 }
8089 }
8090 struct GeneratedVisitor;
8091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8092 type Value = ListActorStatesRequest;
8093
8094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8095 formatter.write_str("struct meta.ListActorStatesRequest")
8096 }
8097
8098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8099 where
8100 V: serde::de::MapAccess<'de>,
8101 {
8102 while map_.next_key::<GeneratedField>()?.is_some() {
8103 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8104 }
8105 Ok(ListActorStatesRequest {
8106 })
8107 }
8108 }
8109 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8110 }
8111}
8112impl serde::Serialize for ListActorStatesResponse {
8113 #[allow(deprecated)]
8114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8115 where
8116 S: serde::Serializer,
8117 {
8118 use serde::ser::SerializeStruct;
8119 let mut len = 0;
8120 if !self.states.is_empty() {
8121 len += 1;
8122 }
8123 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8124 if !self.states.is_empty() {
8125 struct_ser.serialize_field("states", &self.states)?;
8126 }
8127 struct_ser.end()
8128 }
8129}
8130impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8131 #[allow(deprecated)]
8132 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8133 where
8134 D: serde::Deserializer<'de>,
8135 {
8136 const FIELDS: &[&str] = &[
8137 "states",
8138 ];
8139
8140 #[allow(clippy::enum_variant_names)]
8141 enum GeneratedField {
8142 States,
8143 }
8144 impl<'de> serde::Deserialize<'de> for GeneratedField {
8145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8146 where
8147 D: serde::Deserializer<'de>,
8148 {
8149 struct GeneratedVisitor;
8150
8151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8152 type Value = GeneratedField;
8153
8154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8155 write!(formatter, "expected one of: {:?}", &FIELDS)
8156 }
8157
8158 #[allow(unused_variables)]
8159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8160 where
8161 E: serde::de::Error,
8162 {
8163 match value {
8164 "states" => Ok(GeneratedField::States),
8165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8166 }
8167 }
8168 }
8169 deserializer.deserialize_identifier(GeneratedVisitor)
8170 }
8171 }
8172 struct GeneratedVisitor;
8173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8174 type Value = ListActorStatesResponse;
8175
8176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8177 formatter.write_str("struct meta.ListActorStatesResponse")
8178 }
8179
8180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8181 where
8182 V: serde::de::MapAccess<'de>,
8183 {
8184 let mut states__ = None;
8185 while let Some(k) = map_.next_key()? {
8186 match k {
8187 GeneratedField::States => {
8188 if states__.is_some() {
8189 return Err(serde::de::Error::duplicate_field("states"));
8190 }
8191 states__ = Some(map_.next_value()?);
8192 }
8193 }
8194 }
8195 Ok(ListActorStatesResponse {
8196 states: states__.unwrap_or_default(),
8197 })
8198 }
8199 }
8200 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8201 }
8202}
8203impl serde::Serialize for list_actor_states_response::ActorState {
8204 #[allow(deprecated)]
8205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8206 where
8207 S: serde::Serializer,
8208 {
8209 use serde::ser::SerializeStruct;
8210 let mut len = 0;
8211 if self.actor_id != 0 {
8212 len += 1;
8213 }
8214 if self.fragment_id != 0 {
8215 len += 1;
8216 }
8217 if self.state != 0 {
8218 len += 1;
8219 }
8220 if self.worker_id != 0 {
8221 len += 1;
8222 }
8223 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8224 if self.actor_id != 0 {
8225 struct_ser.serialize_field("actorId", &self.actor_id)?;
8226 }
8227 if self.fragment_id != 0 {
8228 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8229 }
8230 if self.state != 0 {
8231 let v = table_fragments::actor_status::ActorState::try_from(self.state)
8232 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8233 struct_ser.serialize_field("state", &v)?;
8234 }
8235 if self.worker_id != 0 {
8236 struct_ser.serialize_field("workerId", &self.worker_id)?;
8237 }
8238 struct_ser.end()
8239 }
8240}
8241impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8242 #[allow(deprecated)]
8243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8244 where
8245 D: serde::Deserializer<'de>,
8246 {
8247 const FIELDS: &[&str] = &[
8248 "actor_id",
8249 "actorId",
8250 "fragment_id",
8251 "fragmentId",
8252 "state",
8253 "worker_id",
8254 "workerId",
8255 ];
8256
8257 #[allow(clippy::enum_variant_names)]
8258 enum GeneratedField {
8259 ActorId,
8260 FragmentId,
8261 State,
8262 WorkerId,
8263 }
8264 impl<'de> serde::Deserialize<'de> for GeneratedField {
8265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8266 where
8267 D: serde::Deserializer<'de>,
8268 {
8269 struct GeneratedVisitor;
8270
8271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8272 type Value = GeneratedField;
8273
8274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8275 write!(formatter, "expected one of: {:?}", &FIELDS)
8276 }
8277
8278 #[allow(unused_variables)]
8279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8280 where
8281 E: serde::de::Error,
8282 {
8283 match value {
8284 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8285 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8286 "state" => Ok(GeneratedField::State),
8287 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8289 }
8290 }
8291 }
8292 deserializer.deserialize_identifier(GeneratedVisitor)
8293 }
8294 }
8295 struct GeneratedVisitor;
8296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8297 type Value = list_actor_states_response::ActorState;
8298
8299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8300 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8301 }
8302
8303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8304 where
8305 V: serde::de::MapAccess<'de>,
8306 {
8307 let mut actor_id__ = None;
8308 let mut fragment_id__ = None;
8309 let mut state__ = None;
8310 let mut worker_id__ = None;
8311 while let Some(k) = map_.next_key()? {
8312 match k {
8313 GeneratedField::ActorId => {
8314 if actor_id__.is_some() {
8315 return Err(serde::de::Error::duplicate_field("actorId"));
8316 }
8317 actor_id__ =
8318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8319 ;
8320 }
8321 GeneratedField::FragmentId => {
8322 if fragment_id__.is_some() {
8323 return Err(serde::de::Error::duplicate_field("fragmentId"));
8324 }
8325 fragment_id__ =
8326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8327 ;
8328 }
8329 GeneratedField::State => {
8330 if state__.is_some() {
8331 return Err(serde::de::Error::duplicate_field("state"));
8332 }
8333 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8334 }
8335 GeneratedField::WorkerId => {
8336 if worker_id__.is_some() {
8337 return Err(serde::de::Error::duplicate_field("workerId"));
8338 }
8339 worker_id__ =
8340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8341 ;
8342 }
8343 }
8344 }
8345 Ok(list_actor_states_response::ActorState {
8346 actor_id: actor_id__.unwrap_or_default(),
8347 fragment_id: fragment_id__.unwrap_or_default(),
8348 state: state__.unwrap_or_default(),
8349 worker_id: worker_id__.unwrap_or_default(),
8350 })
8351 }
8352 }
8353 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8354 }
8355}
8356impl serde::Serialize for ListAllNodesRequest {
8357 #[allow(deprecated)]
8358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8359 where
8360 S: serde::Serializer,
8361 {
8362 use serde::ser::SerializeStruct;
8363 let mut len = 0;
8364 if self.worker_type.is_some() {
8365 len += 1;
8366 }
8367 if self.include_starting_nodes {
8368 len += 1;
8369 }
8370 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8371 if let Some(v) = self.worker_type.as_ref() {
8372 let v = super::common::WorkerType::try_from(*v)
8373 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8374 struct_ser.serialize_field("workerType", &v)?;
8375 }
8376 if self.include_starting_nodes {
8377 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8378 }
8379 struct_ser.end()
8380 }
8381}
8382impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8383 #[allow(deprecated)]
8384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8385 where
8386 D: serde::Deserializer<'de>,
8387 {
8388 const FIELDS: &[&str] = &[
8389 "worker_type",
8390 "workerType",
8391 "include_starting_nodes",
8392 "includeStartingNodes",
8393 ];
8394
8395 #[allow(clippy::enum_variant_names)]
8396 enum GeneratedField {
8397 WorkerType,
8398 IncludeStartingNodes,
8399 }
8400 impl<'de> serde::Deserialize<'de> for GeneratedField {
8401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8402 where
8403 D: serde::Deserializer<'de>,
8404 {
8405 struct GeneratedVisitor;
8406
8407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8408 type Value = GeneratedField;
8409
8410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8411 write!(formatter, "expected one of: {:?}", &FIELDS)
8412 }
8413
8414 #[allow(unused_variables)]
8415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8416 where
8417 E: serde::de::Error,
8418 {
8419 match value {
8420 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8421 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8423 }
8424 }
8425 }
8426 deserializer.deserialize_identifier(GeneratedVisitor)
8427 }
8428 }
8429 struct GeneratedVisitor;
8430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8431 type Value = ListAllNodesRequest;
8432
8433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8434 formatter.write_str("struct meta.ListAllNodesRequest")
8435 }
8436
8437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8438 where
8439 V: serde::de::MapAccess<'de>,
8440 {
8441 let mut worker_type__ = None;
8442 let mut include_starting_nodes__ = None;
8443 while let Some(k) = map_.next_key()? {
8444 match k {
8445 GeneratedField::WorkerType => {
8446 if worker_type__.is_some() {
8447 return Err(serde::de::Error::duplicate_field("workerType"));
8448 }
8449 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8450 }
8451 GeneratedField::IncludeStartingNodes => {
8452 if include_starting_nodes__.is_some() {
8453 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8454 }
8455 include_starting_nodes__ = Some(map_.next_value()?);
8456 }
8457 }
8458 }
8459 Ok(ListAllNodesRequest {
8460 worker_type: worker_type__,
8461 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8462 })
8463 }
8464 }
8465 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8466 }
8467}
8468impl serde::Serialize for ListAllNodesResponse {
8469 #[allow(deprecated)]
8470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8471 where
8472 S: serde::Serializer,
8473 {
8474 use serde::ser::SerializeStruct;
8475 let mut len = 0;
8476 if self.status.is_some() {
8477 len += 1;
8478 }
8479 if !self.nodes.is_empty() {
8480 len += 1;
8481 }
8482 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8483 if let Some(v) = self.status.as_ref() {
8484 struct_ser.serialize_field("status", v)?;
8485 }
8486 if !self.nodes.is_empty() {
8487 struct_ser.serialize_field("nodes", &self.nodes)?;
8488 }
8489 struct_ser.end()
8490 }
8491}
8492impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8493 #[allow(deprecated)]
8494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8495 where
8496 D: serde::Deserializer<'de>,
8497 {
8498 const FIELDS: &[&str] = &[
8499 "status",
8500 "nodes",
8501 ];
8502
8503 #[allow(clippy::enum_variant_names)]
8504 enum GeneratedField {
8505 Status,
8506 Nodes,
8507 }
8508 impl<'de> serde::Deserialize<'de> for GeneratedField {
8509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8510 where
8511 D: serde::Deserializer<'de>,
8512 {
8513 struct GeneratedVisitor;
8514
8515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8516 type Value = GeneratedField;
8517
8518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8519 write!(formatter, "expected one of: {:?}", &FIELDS)
8520 }
8521
8522 #[allow(unused_variables)]
8523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8524 where
8525 E: serde::de::Error,
8526 {
8527 match value {
8528 "status" => Ok(GeneratedField::Status),
8529 "nodes" => Ok(GeneratedField::Nodes),
8530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8531 }
8532 }
8533 }
8534 deserializer.deserialize_identifier(GeneratedVisitor)
8535 }
8536 }
8537 struct GeneratedVisitor;
8538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8539 type Value = ListAllNodesResponse;
8540
8541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8542 formatter.write_str("struct meta.ListAllNodesResponse")
8543 }
8544
8545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8546 where
8547 V: serde::de::MapAccess<'de>,
8548 {
8549 let mut status__ = None;
8550 let mut nodes__ = None;
8551 while let Some(k) = map_.next_key()? {
8552 match k {
8553 GeneratedField::Status => {
8554 if status__.is_some() {
8555 return Err(serde::de::Error::duplicate_field("status"));
8556 }
8557 status__ = map_.next_value()?;
8558 }
8559 GeneratedField::Nodes => {
8560 if nodes__.is_some() {
8561 return Err(serde::de::Error::duplicate_field("nodes"));
8562 }
8563 nodes__ = Some(map_.next_value()?);
8564 }
8565 }
8566 }
8567 Ok(ListAllNodesResponse {
8568 status: status__,
8569 nodes: nodes__.unwrap_or_default(),
8570 })
8571 }
8572 }
8573 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8574 }
8575}
8576impl serde::Serialize for ListEventLogRequest {
8577 #[allow(deprecated)]
8578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8579 where
8580 S: serde::Serializer,
8581 {
8582 use serde::ser::SerializeStruct;
8583 let len = 0;
8584 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
8585 struct_ser.end()
8586 }
8587}
8588impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
8589 #[allow(deprecated)]
8590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8591 where
8592 D: serde::Deserializer<'de>,
8593 {
8594 const FIELDS: &[&str] = &[
8595 ];
8596
8597 #[allow(clippy::enum_variant_names)]
8598 enum GeneratedField {
8599 }
8600 impl<'de> serde::Deserialize<'de> for GeneratedField {
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 struct GeneratedVisitor;
8606
8607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8608 type Value = GeneratedField;
8609
8610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8611 write!(formatter, "expected one of: {:?}", &FIELDS)
8612 }
8613
8614 #[allow(unused_variables)]
8615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8616 where
8617 E: serde::de::Error,
8618 {
8619 Err(serde::de::Error::unknown_field(value, FIELDS))
8620 }
8621 }
8622 deserializer.deserialize_identifier(GeneratedVisitor)
8623 }
8624 }
8625 struct GeneratedVisitor;
8626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8627 type Value = ListEventLogRequest;
8628
8629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8630 formatter.write_str("struct meta.ListEventLogRequest")
8631 }
8632
8633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
8634 where
8635 V: serde::de::MapAccess<'de>,
8636 {
8637 while map_.next_key::<GeneratedField>()?.is_some() {
8638 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8639 }
8640 Ok(ListEventLogRequest {
8641 })
8642 }
8643 }
8644 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
8645 }
8646}
8647impl serde::Serialize for ListEventLogResponse {
8648 #[allow(deprecated)]
8649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8650 where
8651 S: serde::Serializer,
8652 {
8653 use serde::ser::SerializeStruct;
8654 let mut len = 0;
8655 if !self.event_logs.is_empty() {
8656 len += 1;
8657 }
8658 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
8659 if !self.event_logs.is_empty() {
8660 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
8661 }
8662 struct_ser.end()
8663 }
8664}
8665impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
8666 #[allow(deprecated)]
8667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8668 where
8669 D: serde::Deserializer<'de>,
8670 {
8671 const FIELDS: &[&str] = &[
8672 "event_logs",
8673 "eventLogs",
8674 ];
8675
8676 #[allow(clippy::enum_variant_names)]
8677 enum GeneratedField {
8678 EventLogs,
8679 }
8680 impl<'de> serde::Deserialize<'de> for GeneratedField {
8681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8682 where
8683 D: serde::Deserializer<'de>,
8684 {
8685 struct GeneratedVisitor;
8686
8687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8688 type Value = GeneratedField;
8689
8690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8691 write!(formatter, "expected one of: {:?}", &FIELDS)
8692 }
8693
8694 #[allow(unused_variables)]
8695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8696 where
8697 E: serde::de::Error,
8698 {
8699 match value {
8700 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
8701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8702 }
8703 }
8704 }
8705 deserializer.deserialize_identifier(GeneratedVisitor)
8706 }
8707 }
8708 struct GeneratedVisitor;
8709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8710 type Value = ListEventLogResponse;
8711
8712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8713 formatter.write_str("struct meta.ListEventLogResponse")
8714 }
8715
8716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
8717 where
8718 V: serde::de::MapAccess<'de>,
8719 {
8720 let mut event_logs__ = None;
8721 while let Some(k) = map_.next_key()? {
8722 match k {
8723 GeneratedField::EventLogs => {
8724 if event_logs__.is_some() {
8725 return Err(serde::de::Error::duplicate_field("eventLogs"));
8726 }
8727 event_logs__ = Some(map_.next_value()?);
8728 }
8729 }
8730 }
8731 Ok(ListEventLogResponse {
8732 event_logs: event_logs__.unwrap_or_default(),
8733 })
8734 }
8735 }
8736 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
8737 }
8738}
8739impl serde::Serialize for ListFragmentDistributionRequest {
8740 #[allow(deprecated)]
8741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8742 where
8743 S: serde::Serializer,
8744 {
8745 use serde::ser::SerializeStruct;
8746 let len = 0;
8747 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
8748 struct_ser.end()
8749 }
8750}
8751impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
8752 #[allow(deprecated)]
8753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8754 where
8755 D: serde::Deserializer<'de>,
8756 {
8757 const FIELDS: &[&str] = &[
8758 ];
8759
8760 #[allow(clippy::enum_variant_names)]
8761 enum GeneratedField {
8762 }
8763 impl<'de> serde::Deserialize<'de> for GeneratedField {
8764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8765 where
8766 D: serde::Deserializer<'de>,
8767 {
8768 struct GeneratedVisitor;
8769
8770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8771 type Value = GeneratedField;
8772
8773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8774 write!(formatter, "expected one of: {:?}", &FIELDS)
8775 }
8776
8777 #[allow(unused_variables)]
8778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8779 where
8780 E: serde::de::Error,
8781 {
8782 Err(serde::de::Error::unknown_field(value, FIELDS))
8783 }
8784 }
8785 deserializer.deserialize_identifier(GeneratedVisitor)
8786 }
8787 }
8788 struct GeneratedVisitor;
8789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8790 type Value = ListFragmentDistributionRequest;
8791
8792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8793 formatter.write_str("struct meta.ListFragmentDistributionRequest")
8794 }
8795
8796 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
8797 where
8798 V: serde::de::MapAccess<'de>,
8799 {
8800 while map_.next_key::<GeneratedField>()?.is_some() {
8801 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8802 }
8803 Ok(ListFragmentDistributionRequest {
8804 })
8805 }
8806 }
8807 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8808 }
8809}
8810impl serde::Serialize for ListFragmentDistributionResponse {
8811 #[allow(deprecated)]
8812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8813 where
8814 S: serde::Serializer,
8815 {
8816 use serde::ser::SerializeStruct;
8817 let mut len = 0;
8818 if !self.distributions.is_empty() {
8819 len += 1;
8820 }
8821 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
8822 if !self.distributions.is_empty() {
8823 struct_ser.serialize_field("distributions", &self.distributions)?;
8824 }
8825 struct_ser.end()
8826 }
8827}
8828impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
8829 #[allow(deprecated)]
8830 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8831 where
8832 D: serde::Deserializer<'de>,
8833 {
8834 const FIELDS: &[&str] = &[
8835 "distributions",
8836 ];
8837
8838 #[allow(clippy::enum_variant_names)]
8839 enum GeneratedField {
8840 Distributions,
8841 }
8842 impl<'de> serde::Deserialize<'de> for GeneratedField {
8843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8844 where
8845 D: serde::Deserializer<'de>,
8846 {
8847 struct GeneratedVisitor;
8848
8849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8850 type Value = GeneratedField;
8851
8852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8853 write!(formatter, "expected one of: {:?}", &FIELDS)
8854 }
8855
8856 #[allow(unused_variables)]
8857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8858 where
8859 E: serde::de::Error,
8860 {
8861 match value {
8862 "distributions" => Ok(GeneratedField::Distributions),
8863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8864 }
8865 }
8866 }
8867 deserializer.deserialize_identifier(GeneratedVisitor)
8868 }
8869 }
8870 struct GeneratedVisitor;
8871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8872 type Value = ListFragmentDistributionResponse;
8873
8874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8875 formatter.write_str("struct meta.ListFragmentDistributionResponse")
8876 }
8877
8878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
8879 where
8880 V: serde::de::MapAccess<'de>,
8881 {
8882 let mut distributions__ = None;
8883 while let Some(k) = map_.next_key()? {
8884 match k {
8885 GeneratedField::Distributions => {
8886 if distributions__.is_some() {
8887 return Err(serde::de::Error::duplicate_field("distributions"));
8888 }
8889 distributions__ = Some(map_.next_value()?);
8890 }
8891 }
8892 }
8893 Ok(ListFragmentDistributionResponse {
8894 distributions: distributions__.unwrap_or_default(),
8895 })
8896 }
8897 }
8898 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
8899 }
8900}
8901impl serde::Serialize for ListIcebergTablesRequest {
8902 #[allow(deprecated)]
8903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8904 where
8905 S: serde::Serializer,
8906 {
8907 use serde::ser::SerializeStruct;
8908 let len = 0;
8909 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
8910 struct_ser.end()
8911 }
8912}
8913impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
8914 #[allow(deprecated)]
8915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8916 where
8917 D: serde::Deserializer<'de>,
8918 {
8919 const FIELDS: &[&str] = &[
8920 ];
8921
8922 #[allow(clippy::enum_variant_names)]
8923 enum GeneratedField {
8924 }
8925 impl<'de> serde::Deserialize<'de> for GeneratedField {
8926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8927 where
8928 D: serde::Deserializer<'de>,
8929 {
8930 struct GeneratedVisitor;
8931
8932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8933 type Value = GeneratedField;
8934
8935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8936 write!(formatter, "expected one of: {:?}", &FIELDS)
8937 }
8938
8939 #[allow(unused_variables)]
8940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8941 where
8942 E: serde::de::Error,
8943 {
8944 Err(serde::de::Error::unknown_field(value, FIELDS))
8945 }
8946 }
8947 deserializer.deserialize_identifier(GeneratedVisitor)
8948 }
8949 }
8950 struct GeneratedVisitor;
8951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8952 type Value = ListIcebergTablesRequest;
8953
8954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8955 formatter.write_str("struct meta.ListIcebergTablesRequest")
8956 }
8957
8958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
8959 where
8960 V: serde::de::MapAccess<'de>,
8961 {
8962 while map_.next_key::<GeneratedField>()?.is_some() {
8963 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8964 }
8965 Ok(ListIcebergTablesRequest {
8966 })
8967 }
8968 }
8969 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
8970 }
8971}
8972impl serde::Serialize for ListIcebergTablesResponse {
8973 #[allow(deprecated)]
8974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8975 where
8976 S: serde::Serializer,
8977 {
8978 use serde::ser::SerializeStruct;
8979 let mut len = 0;
8980 if !self.iceberg_tables.is_empty() {
8981 len += 1;
8982 }
8983 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
8984 if !self.iceberg_tables.is_empty() {
8985 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
8986 }
8987 struct_ser.end()
8988 }
8989}
8990impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
8991 #[allow(deprecated)]
8992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8993 where
8994 D: serde::Deserializer<'de>,
8995 {
8996 const FIELDS: &[&str] = &[
8997 "iceberg_tables",
8998 "icebergTables",
8999 ];
9000
9001 #[allow(clippy::enum_variant_names)]
9002 enum GeneratedField {
9003 IcebergTables,
9004 }
9005 impl<'de> serde::Deserialize<'de> for GeneratedField {
9006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9007 where
9008 D: serde::Deserializer<'de>,
9009 {
9010 struct GeneratedVisitor;
9011
9012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9013 type Value = GeneratedField;
9014
9015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9016 write!(formatter, "expected one of: {:?}", &FIELDS)
9017 }
9018
9019 #[allow(unused_variables)]
9020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9021 where
9022 E: serde::de::Error,
9023 {
9024 match value {
9025 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9026 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9027 }
9028 }
9029 }
9030 deserializer.deserialize_identifier(GeneratedVisitor)
9031 }
9032 }
9033 struct GeneratedVisitor;
9034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9035 type Value = ListIcebergTablesResponse;
9036
9037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9038 formatter.write_str("struct meta.ListIcebergTablesResponse")
9039 }
9040
9041 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9042 where
9043 V: serde::de::MapAccess<'de>,
9044 {
9045 let mut iceberg_tables__ = None;
9046 while let Some(k) = map_.next_key()? {
9047 match k {
9048 GeneratedField::IcebergTables => {
9049 if iceberg_tables__.is_some() {
9050 return Err(serde::de::Error::duplicate_field("icebergTables"));
9051 }
9052 iceberg_tables__ = Some(map_.next_value()?);
9053 }
9054 }
9055 }
9056 Ok(ListIcebergTablesResponse {
9057 iceberg_tables: iceberg_tables__.unwrap_or_default(),
9058 })
9059 }
9060 }
9061 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9062 }
9063}
9064impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9065 #[allow(deprecated)]
9066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9067 where
9068 S: serde::Serializer,
9069 {
9070 use serde::ser::SerializeStruct;
9071 let mut len = 0;
9072 if !self.catalog_name.is_empty() {
9073 len += 1;
9074 }
9075 if !self.table_namespace.is_empty() {
9076 len += 1;
9077 }
9078 if !self.table_name.is_empty() {
9079 len += 1;
9080 }
9081 if self.metadata_location.is_some() {
9082 len += 1;
9083 }
9084 if self.previous_metadata_location.is_some() {
9085 len += 1;
9086 }
9087 if self.iceberg_type.is_some() {
9088 len += 1;
9089 }
9090 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9091 if !self.catalog_name.is_empty() {
9092 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9093 }
9094 if !self.table_namespace.is_empty() {
9095 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9096 }
9097 if !self.table_name.is_empty() {
9098 struct_ser.serialize_field("tableName", &self.table_name)?;
9099 }
9100 if let Some(v) = self.metadata_location.as_ref() {
9101 struct_ser.serialize_field("metadataLocation", v)?;
9102 }
9103 if let Some(v) = self.previous_metadata_location.as_ref() {
9104 struct_ser.serialize_field("previousMetadataLocation", v)?;
9105 }
9106 if let Some(v) = self.iceberg_type.as_ref() {
9107 struct_ser.serialize_field("icebergType", v)?;
9108 }
9109 struct_ser.end()
9110 }
9111}
9112impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9113 #[allow(deprecated)]
9114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9115 where
9116 D: serde::Deserializer<'de>,
9117 {
9118 const FIELDS: &[&str] = &[
9119 "catalog_name",
9120 "catalogName",
9121 "table_namespace",
9122 "tableNamespace",
9123 "table_name",
9124 "tableName",
9125 "metadata_location",
9126 "metadataLocation",
9127 "previous_metadata_location",
9128 "previousMetadataLocation",
9129 "iceberg_type",
9130 "icebergType",
9131 ];
9132
9133 #[allow(clippy::enum_variant_names)]
9134 enum GeneratedField {
9135 CatalogName,
9136 TableNamespace,
9137 TableName,
9138 MetadataLocation,
9139 PreviousMetadataLocation,
9140 IcebergType,
9141 }
9142 impl<'de> serde::Deserialize<'de> for GeneratedField {
9143 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9144 where
9145 D: serde::Deserializer<'de>,
9146 {
9147 struct GeneratedVisitor;
9148
9149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9150 type Value = GeneratedField;
9151
9152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9153 write!(formatter, "expected one of: {:?}", &FIELDS)
9154 }
9155
9156 #[allow(unused_variables)]
9157 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9158 where
9159 E: serde::de::Error,
9160 {
9161 match value {
9162 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9163 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9164 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9165 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9166 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9167 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9168 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9169 }
9170 }
9171 }
9172 deserializer.deserialize_identifier(GeneratedVisitor)
9173 }
9174 }
9175 struct GeneratedVisitor;
9176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9177 type Value = list_iceberg_tables_response::IcebergTable;
9178
9179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9180 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9181 }
9182
9183 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9184 where
9185 V: serde::de::MapAccess<'de>,
9186 {
9187 let mut catalog_name__ = None;
9188 let mut table_namespace__ = None;
9189 let mut table_name__ = None;
9190 let mut metadata_location__ = None;
9191 let mut previous_metadata_location__ = None;
9192 let mut iceberg_type__ = None;
9193 while let Some(k) = map_.next_key()? {
9194 match k {
9195 GeneratedField::CatalogName => {
9196 if catalog_name__.is_some() {
9197 return Err(serde::de::Error::duplicate_field("catalogName"));
9198 }
9199 catalog_name__ = Some(map_.next_value()?);
9200 }
9201 GeneratedField::TableNamespace => {
9202 if table_namespace__.is_some() {
9203 return Err(serde::de::Error::duplicate_field("tableNamespace"));
9204 }
9205 table_namespace__ = Some(map_.next_value()?);
9206 }
9207 GeneratedField::TableName => {
9208 if table_name__.is_some() {
9209 return Err(serde::de::Error::duplicate_field("tableName"));
9210 }
9211 table_name__ = Some(map_.next_value()?);
9212 }
9213 GeneratedField::MetadataLocation => {
9214 if metadata_location__.is_some() {
9215 return Err(serde::de::Error::duplicate_field("metadataLocation"));
9216 }
9217 metadata_location__ = map_.next_value()?;
9218 }
9219 GeneratedField::PreviousMetadataLocation => {
9220 if previous_metadata_location__.is_some() {
9221 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9222 }
9223 previous_metadata_location__ = map_.next_value()?;
9224 }
9225 GeneratedField::IcebergType => {
9226 if iceberg_type__.is_some() {
9227 return Err(serde::de::Error::duplicate_field("icebergType"));
9228 }
9229 iceberg_type__ = map_.next_value()?;
9230 }
9231 }
9232 }
9233 Ok(list_iceberg_tables_response::IcebergTable {
9234 catalog_name: catalog_name__.unwrap_or_default(),
9235 table_namespace: table_namespace__.unwrap_or_default(),
9236 table_name: table_name__.unwrap_or_default(),
9237 metadata_location: metadata_location__,
9238 previous_metadata_location: previous_metadata_location__,
9239 iceberg_type: iceberg_type__,
9240 })
9241 }
9242 }
9243 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9244 }
9245}
9246impl serde::Serialize for ListObjectDependenciesRequest {
9247 #[allow(deprecated)]
9248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9249 where
9250 S: serde::Serializer,
9251 {
9252 use serde::ser::SerializeStruct;
9253 let len = 0;
9254 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9255 struct_ser.end()
9256 }
9257}
9258impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9259 #[allow(deprecated)]
9260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9261 where
9262 D: serde::Deserializer<'de>,
9263 {
9264 const FIELDS: &[&str] = &[
9265 ];
9266
9267 #[allow(clippy::enum_variant_names)]
9268 enum GeneratedField {
9269 }
9270 impl<'de> serde::Deserialize<'de> for GeneratedField {
9271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9272 where
9273 D: serde::Deserializer<'de>,
9274 {
9275 struct GeneratedVisitor;
9276
9277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9278 type Value = GeneratedField;
9279
9280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9281 write!(formatter, "expected one of: {:?}", &FIELDS)
9282 }
9283
9284 #[allow(unused_variables)]
9285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9286 where
9287 E: serde::de::Error,
9288 {
9289 Err(serde::de::Error::unknown_field(value, FIELDS))
9290 }
9291 }
9292 deserializer.deserialize_identifier(GeneratedVisitor)
9293 }
9294 }
9295 struct GeneratedVisitor;
9296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9297 type Value = ListObjectDependenciesRequest;
9298
9299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9300 formatter.write_str("struct meta.ListObjectDependenciesRequest")
9301 }
9302
9303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9304 where
9305 V: serde::de::MapAccess<'de>,
9306 {
9307 while map_.next_key::<GeneratedField>()?.is_some() {
9308 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9309 }
9310 Ok(ListObjectDependenciesRequest {
9311 })
9312 }
9313 }
9314 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9315 }
9316}
9317impl serde::Serialize for ListObjectDependenciesResponse {
9318 #[allow(deprecated)]
9319 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9320 where
9321 S: serde::Serializer,
9322 {
9323 use serde::ser::SerializeStruct;
9324 let mut len = 0;
9325 if !self.dependencies.is_empty() {
9326 len += 1;
9327 }
9328 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9329 if !self.dependencies.is_empty() {
9330 struct_ser.serialize_field("dependencies", &self.dependencies)?;
9331 }
9332 struct_ser.end()
9333 }
9334}
9335impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9336 #[allow(deprecated)]
9337 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9338 where
9339 D: serde::Deserializer<'de>,
9340 {
9341 const FIELDS: &[&str] = &[
9342 "dependencies",
9343 ];
9344
9345 #[allow(clippy::enum_variant_names)]
9346 enum GeneratedField {
9347 Dependencies,
9348 }
9349 impl<'de> serde::Deserialize<'de> for GeneratedField {
9350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9351 where
9352 D: serde::Deserializer<'de>,
9353 {
9354 struct GeneratedVisitor;
9355
9356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9357 type Value = GeneratedField;
9358
9359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9360 write!(formatter, "expected one of: {:?}", &FIELDS)
9361 }
9362
9363 #[allow(unused_variables)]
9364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9365 where
9366 E: serde::de::Error,
9367 {
9368 match value {
9369 "dependencies" => Ok(GeneratedField::Dependencies),
9370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9371 }
9372 }
9373 }
9374 deserializer.deserialize_identifier(GeneratedVisitor)
9375 }
9376 }
9377 struct GeneratedVisitor;
9378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9379 type Value = ListObjectDependenciesResponse;
9380
9381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9382 formatter.write_str("struct meta.ListObjectDependenciesResponse")
9383 }
9384
9385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
9386 where
9387 V: serde::de::MapAccess<'de>,
9388 {
9389 let mut dependencies__ = None;
9390 while let Some(k) = map_.next_key()? {
9391 match k {
9392 GeneratedField::Dependencies => {
9393 if dependencies__.is_some() {
9394 return Err(serde::de::Error::duplicate_field("dependencies"));
9395 }
9396 dependencies__ = Some(map_.next_value()?);
9397 }
9398 }
9399 }
9400 Ok(ListObjectDependenciesResponse {
9401 dependencies: dependencies__.unwrap_or_default(),
9402 })
9403 }
9404 }
9405 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
9406 }
9407}
9408impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
9409 #[allow(deprecated)]
9410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9411 where
9412 S: serde::Serializer,
9413 {
9414 use serde::ser::SerializeStruct;
9415 let mut len = 0;
9416 if self.object_id != 0 {
9417 len += 1;
9418 }
9419 if self.referenced_object_id != 0 {
9420 len += 1;
9421 }
9422 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
9423 if self.object_id != 0 {
9424 struct_ser.serialize_field("objectId", &self.object_id)?;
9425 }
9426 if self.referenced_object_id != 0 {
9427 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
9428 }
9429 struct_ser.end()
9430 }
9431}
9432impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
9433 #[allow(deprecated)]
9434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9435 where
9436 D: serde::Deserializer<'de>,
9437 {
9438 const FIELDS: &[&str] = &[
9439 "object_id",
9440 "objectId",
9441 "referenced_object_id",
9442 "referencedObjectId",
9443 ];
9444
9445 #[allow(clippy::enum_variant_names)]
9446 enum GeneratedField {
9447 ObjectId,
9448 ReferencedObjectId,
9449 }
9450 impl<'de> serde::Deserialize<'de> for GeneratedField {
9451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9452 where
9453 D: serde::Deserializer<'de>,
9454 {
9455 struct GeneratedVisitor;
9456
9457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9458 type Value = GeneratedField;
9459
9460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9461 write!(formatter, "expected one of: {:?}", &FIELDS)
9462 }
9463
9464 #[allow(unused_variables)]
9465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9466 where
9467 E: serde::de::Error,
9468 {
9469 match value {
9470 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
9471 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
9472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9473 }
9474 }
9475 }
9476 deserializer.deserialize_identifier(GeneratedVisitor)
9477 }
9478 }
9479 struct GeneratedVisitor;
9480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9481 type Value = list_object_dependencies_response::ObjectDependencies;
9482
9483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9484 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
9485 }
9486
9487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
9488 where
9489 V: serde::de::MapAccess<'de>,
9490 {
9491 let mut object_id__ = None;
9492 let mut referenced_object_id__ = None;
9493 while let Some(k) = map_.next_key()? {
9494 match k {
9495 GeneratedField::ObjectId => {
9496 if object_id__.is_some() {
9497 return Err(serde::de::Error::duplicate_field("objectId"));
9498 }
9499 object_id__ =
9500 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9501 ;
9502 }
9503 GeneratedField::ReferencedObjectId => {
9504 if referenced_object_id__.is_some() {
9505 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
9506 }
9507 referenced_object_id__ =
9508 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9509 ;
9510 }
9511 }
9512 }
9513 Ok(list_object_dependencies_response::ObjectDependencies {
9514 object_id: object_id__.unwrap_or_default(),
9515 referenced_object_id: referenced_object_id__.unwrap_or_default(),
9516 })
9517 }
9518 }
9519 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
9520 }
9521}
9522impl serde::Serialize for ListRateLimitsRequest {
9523 #[allow(deprecated)]
9524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9525 where
9526 S: serde::Serializer,
9527 {
9528 use serde::ser::SerializeStruct;
9529 let len = 0;
9530 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
9531 struct_ser.end()
9532 }
9533}
9534impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
9535 #[allow(deprecated)]
9536 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9537 where
9538 D: serde::Deserializer<'de>,
9539 {
9540 const FIELDS: &[&str] = &[
9541 ];
9542
9543 #[allow(clippy::enum_variant_names)]
9544 enum GeneratedField {
9545 }
9546 impl<'de> serde::Deserialize<'de> for GeneratedField {
9547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9548 where
9549 D: serde::Deserializer<'de>,
9550 {
9551 struct GeneratedVisitor;
9552
9553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9554 type Value = GeneratedField;
9555
9556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9557 write!(formatter, "expected one of: {:?}", &FIELDS)
9558 }
9559
9560 #[allow(unused_variables)]
9561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9562 where
9563 E: serde::de::Error,
9564 {
9565 Err(serde::de::Error::unknown_field(value, FIELDS))
9566 }
9567 }
9568 deserializer.deserialize_identifier(GeneratedVisitor)
9569 }
9570 }
9571 struct GeneratedVisitor;
9572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9573 type Value = ListRateLimitsRequest;
9574
9575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9576 formatter.write_str("struct meta.ListRateLimitsRequest")
9577 }
9578
9579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
9580 where
9581 V: serde::de::MapAccess<'de>,
9582 {
9583 while map_.next_key::<GeneratedField>()?.is_some() {
9584 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9585 }
9586 Ok(ListRateLimitsRequest {
9587 })
9588 }
9589 }
9590 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
9591 }
9592}
9593impl serde::Serialize for ListRateLimitsResponse {
9594 #[allow(deprecated)]
9595 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9596 where
9597 S: serde::Serializer,
9598 {
9599 use serde::ser::SerializeStruct;
9600 let mut len = 0;
9601 if !self.rate_limits.is_empty() {
9602 len += 1;
9603 }
9604 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
9605 if !self.rate_limits.is_empty() {
9606 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
9607 }
9608 struct_ser.end()
9609 }
9610}
9611impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
9612 #[allow(deprecated)]
9613 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9614 where
9615 D: serde::Deserializer<'de>,
9616 {
9617 const FIELDS: &[&str] = &[
9618 "rate_limits",
9619 "rateLimits",
9620 ];
9621
9622 #[allow(clippy::enum_variant_names)]
9623 enum GeneratedField {
9624 RateLimits,
9625 }
9626 impl<'de> serde::Deserialize<'de> for GeneratedField {
9627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9628 where
9629 D: serde::Deserializer<'de>,
9630 {
9631 struct GeneratedVisitor;
9632
9633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9634 type Value = GeneratedField;
9635
9636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9637 write!(formatter, "expected one of: {:?}", &FIELDS)
9638 }
9639
9640 #[allow(unused_variables)]
9641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9642 where
9643 E: serde::de::Error,
9644 {
9645 match value {
9646 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
9647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9648 }
9649 }
9650 }
9651 deserializer.deserialize_identifier(GeneratedVisitor)
9652 }
9653 }
9654 struct GeneratedVisitor;
9655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9656 type Value = ListRateLimitsResponse;
9657
9658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9659 formatter.write_str("struct meta.ListRateLimitsResponse")
9660 }
9661
9662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
9663 where
9664 V: serde::de::MapAccess<'de>,
9665 {
9666 let mut rate_limits__ = None;
9667 while let Some(k) = map_.next_key()? {
9668 match k {
9669 GeneratedField::RateLimits => {
9670 if rate_limits__.is_some() {
9671 return Err(serde::de::Error::duplicate_field("rateLimits"));
9672 }
9673 rate_limits__ = Some(map_.next_value()?);
9674 }
9675 }
9676 }
9677 Ok(ListRateLimitsResponse {
9678 rate_limits: rate_limits__.unwrap_or_default(),
9679 })
9680 }
9681 }
9682 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
9683 }
9684}
9685impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
9686 #[allow(deprecated)]
9687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9688 where
9689 S: serde::Serializer,
9690 {
9691 use serde::ser::SerializeStruct;
9692 let mut len = 0;
9693 if self.fragment_id != 0 {
9694 len += 1;
9695 }
9696 if self.job_id != 0 {
9697 len += 1;
9698 }
9699 if self.fragment_type_mask != 0 {
9700 len += 1;
9701 }
9702 if self.rate_limit != 0 {
9703 len += 1;
9704 }
9705 if !self.node_name.is_empty() {
9706 len += 1;
9707 }
9708 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
9709 if self.fragment_id != 0 {
9710 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9711 }
9712 if self.job_id != 0 {
9713 struct_ser.serialize_field("jobId", &self.job_id)?;
9714 }
9715 if self.fragment_type_mask != 0 {
9716 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
9717 }
9718 if self.rate_limit != 0 {
9719 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
9720 }
9721 if !self.node_name.is_empty() {
9722 struct_ser.serialize_field("nodeName", &self.node_name)?;
9723 }
9724 struct_ser.end()
9725 }
9726}
9727impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
9728 #[allow(deprecated)]
9729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9730 where
9731 D: serde::Deserializer<'de>,
9732 {
9733 const FIELDS: &[&str] = &[
9734 "fragment_id",
9735 "fragmentId",
9736 "job_id",
9737 "jobId",
9738 "fragment_type_mask",
9739 "fragmentTypeMask",
9740 "rate_limit",
9741 "rateLimit",
9742 "node_name",
9743 "nodeName",
9744 ];
9745
9746 #[allow(clippy::enum_variant_names)]
9747 enum GeneratedField {
9748 FragmentId,
9749 JobId,
9750 FragmentTypeMask,
9751 RateLimit,
9752 NodeName,
9753 }
9754 impl<'de> serde::Deserialize<'de> for GeneratedField {
9755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9756 where
9757 D: serde::Deserializer<'de>,
9758 {
9759 struct GeneratedVisitor;
9760
9761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9762 type Value = GeneratedField;
9763
9764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9765 write!(formatter, "expected one of: {:?}", &FIELDS)
9766 }
9767
9768 #[allow(unused_variables)]
9769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9770 where
9771 E: serde::de::Error,
9772 {
9773 match value {
9774 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9775 "jobId" | "job_id" => Ok(GeneratedField::JobId),
9776 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
9777 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9778 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
9779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9780 }
9781 }
9782 }
9783 deserializer.deserialize_identifier(GeneratedVisitor)
9784 }
9785 }
9786 struct GeneratedVisitor;
9787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9788 type Value = list_rate_limits_response::RateLimitInfo;
9789
9790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9791 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
9792 }
9793
9794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
9795 where
9796 V: serde::de::MapAccess<'de>,
9797 {
9798 let mut fragment_id__ = None;
9799 let mut job_id__ = None;
9800 let mut fragment_type_mask__ = None;
9801 let mut rate_limit__ = None;
9802 let mut node_name__ = None;
9803 while let Some(k) = map_.next_key()? {
9804 match k {
9805 GeneratedField::FragmentId => {
9806 if fragment_id__.is_some() {
9807 return Err(serde::de::Error::duplicate_field("fragmentId"));
9808 }
9809 fragment_id__ =
9810 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9811 ;
9812 }
9813 GeneratedField::JobId => {
9814 if job_id__.is_some() {
9815 return Err(serde::de::Error::duplicate_field("jobId"));
9816 }
9817 job_id__ =
9818 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9819 ;
9820 }
9821 GeneratedField::FragmentTypeMask => {
9822 if fragment_type_mask__.is_some() {
9823 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
9824 }
9825 fragment_type_mask__ =
9826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9827 ;
9828 }
9829 GeneratedField::RateLimit => {
9830 if rate_limit__.is_some() {
9831 return Err(serde::de::Error::duplicate_field("rateLimit"));
9832 }
9833 rate_limit__ =
9834 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9835 ;
9836 }
9837 GeneratedField::NodeName => {
9838 if node_name__.is_some() {
9839 return Err(serde::de::Error::duplicate_field("nodeName"));
9840 }
9841 node_name__ = Some(map_.next_value()?);
9842 }
9843 }
9844 }
9845 Ok(list_rate_limits_response::RateLimitInfo {
9846 fragment_id: fragment_id__.unwrap_or_default(),
9847 job_id: job_id__.unwrap_or_default(),
9848 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
9849 rate_limit: rate_limit__.unwrap_or_default(),
9850 node_name: node_name__.unwrap_or_default(),
9851 })
9852 }
9853 }
9854 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
9855 }
9856}
9857impl serde::Serialize for ListStreamingJobStatesRequest {
9858 #[allow(deprecated)]
9859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9860 where
9861 S: serde::Serializer,
9862 {
9863 use serde::ser::SerializeStruct;
9864 let len = 0;
9865 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
9866 struct_ser.end()
9867 }
9868}
9869impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
9870 #[allow(deprecated)]
9871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9872 where
9873 D: serde::Deserializer<'de>,
9874 {
9875 const FIELDS: &[&str] = &[
9876 ];
9877
9878 #[allow(clippy::enum_variant_names)]
9879 enum GeneratedField {
9880 }
9881 impl<'de> serde::Deserialize<'de> for GeneratedField {
9882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9883 where
9884 D: serde::Deserializer<'de>,
9885 {
9886 struct GeneratedVisitor;
9887
9888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9889 type Value = GeneratedField;
9890
9891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9892 write!(formatter, "expected one of: {:?}", &FIELDS)
9893 }
9894
9895 #[allow(unused_variables)]
9896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9897 where
9898 E: serde::de::Error,
9899 {
9900 Err(serde::de::Error::unknown_field(value, FIELDS))
9901 }
9902 }
9903 deserializer.deserialize_identifier(GeneratedVisitor)
9904 }
9905 }
9906 struct GeneratedVisitor;
9907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9908 type Value = ListStreamingJobStatesRequest;
9909
9910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9911 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
9912 }
9913
9914 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
9915 where
9916 V: serde::de::MapAccess<'de>,
9917 {
9918 while map_.next_key::<GeneratedField>()?.is_some() {
9919 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9920 }
9921 Ok(ListStreamingJobStatesRequest {
9922 })
9923 }
9924 }
9925 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
9926 }
9927}
9928impl serde::Serialize for ListStreamingJobStatesResponse {
9929 #[allow(deprecated)]
9930 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9931 where
9932 S: serde::Serializer,
9933 {
9934 use serde::ser::SerializeStruct;
9935 let mut len = 0;
9936 if !self.states.is_empty() {
9937 len += 1;
9938 }
9939 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
9940 if !self.states.is_empty() {
9941 struct_ser.serialize_field("states", &self.states)?;
9942 }
9943 struct_ser.end()
9944 }
9945}
9946impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
9947 #[allow(deprecated)]
9948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9949 where
9950 D: serde::Deserializer<'de>,
9951 {
9952 const FIELDS: &[&str] = &[
9953 "states",
9954 ];
9955
9956 #[allow(clippy::enum_variant_names)]
9957 enum GeneratedField {
9958 States,
9959 }
9960 impl<'de> serde::Deserialize<'de> for GeneratedField {
9961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9962 where
9963 D: serde::Deserializer<'de>,
9964 {
9965 struct GeneratedVisitor;
9966
9967 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9968 type Value = GeneratedField;
9969
9970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9971 write!(formatter, "expected one of: {:?}", &FIELDS)
9972 }
9973
9974 #[allow(unused_variables)]
9975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9976 where
9977 E: serde::de::Error,
9978 {
9979 match value {
9980 "states" => Ok(GeneratedField::States),
9981 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9982 }
9983 }
9984 }
9985 deserializer.deserialize_identifier(GeneratedVisitor)
9986 }
9987 }
9988 struct GeneratedVisitor;
9989 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9990 type Value = ListStreamingJobStatesResponse;
9991
9992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9993 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
9994 }
9995
9996 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
9997 where
9998 V: serde::de::MapAccess<'de>,
9999 {
10000 let mut states__ = None;
10001 while let Some(k) = map_.next_key()? {
10002 match k {
10003 GeneratedField::States => {
10004 if states__.is_some() {
10005 return Err(serde::de::Error::duplicate_field("states"));
10006 }
10007 states__ = Some(map_.next_value()?);
10008 }
10009 }
10010 }
10011 Ok(ListStreamingJobStatesResponse {
10012 states: states__.unwrap_or_default(),
10013 })
10014 }
10015 }
10016 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10017 }
10018}
10019impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10020 #[allow(deprecated)]
10021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10022 where
10023 S: serde::Serializer,
10024 {
10025 use serde::ser::SerializeStruct;
10026 let mut len = 0;
10027 if self.table_id != 0 {
10028 len += 1;
10029 }
10030 if self.state != 0 {
10031 len += 1;
10032 }
10033 if self.parallelism.is_some() {
10034 len += 1;
10035 }
10036 if self.max_parallelism != 0 {
10037 len += 1;
10038 }
10039 if !self.name.is_empty() {
10040 len += 1;
10041 }
10042 if !self.resource_group.is_empty() {
10043 len += 1;
10044 }
10045 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10046 if self.table_id != 0 {
10047 struct_ser.serialize_field("tableId", &self.table_id)?;
10048 }
10049 if self.state != 0 {
10050 let v = table_fragments::State::try_from(self.state)
10051 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10052 struct_ser.serialize_field("state", &v)?;
10053 }
10054 if let Some(v) = self.parallelism.as_ref() {
10055 struct_ser.serialize_field("parallelism", v)?;
10056 }
10057 if self.max_parallelism != 0 {
10058 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10059 }
10060 if !self.name.is_empty() {
10061 struct_ser.serialize_field("name", &self.name)?;
10062 }
10063 if !self.resource_group.is_empty() {
10064 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10065 }
10066 struct_ser.end()
10067 }
10068}
10069impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10070 #[allow(deprecated)]
10071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10072 where
10073 D: serde::Deserializer<'de>,
10074 {
10075 const FIELDS: &[&str] = &[
10076 "table_id",
10077 "tableId",
10078 "state",
10079 "parallelism",
10080 "max_parallelism",
10081 "maxParallelism",
10082 "name",
10083 "resource_group",
10084 "resourceGroup",
10085 ];
10086
10087 #[allow(clippy::enum_variant_names)]
10088 enum GeneratedField {
10089 TableId,
10090 State,
10091 Parallelism,
10092 MaxParallelism,
10093 Name,
10094 ResourceGroup,
10095 }
10096 impl<'de> serde::Deserialize<'de> for GeneratedField {
10097 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10098 where
10099 D: serde::Deserializer<'de>,
10100 {
10101 struct GeneratedVisitor;
10102
10103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10104 type Value = GeneratedField;
10105
10106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10107 write!(formatter, "expected one of: {:?}", &FIELDS)
10108 }
10109
10110 #[allow(unused_variables)]
10111 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10112 where
10113 E: serde::de::Error,
10114 {
10115 match value {
10116 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10117 "state" => Ok(GeneratedField::State),
10118 "parallelism" => Ok(GeneratedField::Parallelism),
10119 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10120 "name" => Ok(GeneratedField::Name),
10121 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10122 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10123 }
10124 }
10125 }
10126 deserializer.deserialize_identifier(GeneratedVisitor)
10127 }
10128 }
10129 struct GeneratedVisitor;
10130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10131 type Value = list_streaming_job_states_response::StreamingJobState;
10132
10133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10134 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10135 }
10136
10137 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10138 where
10139 V: serde::de::MapAccess<'de>,
10140 {
10141 let mut table_id__ = None;
10142 let mut state__ = None;
10143 let mut parallelism__ = None;
10144 let mut max_parallelism__ = None;
10145 let mut name__ = None;
10146 let mut resource_group__ = None;
10147 while let Some(k) = map_.next_key()? {
10148 match k {
10149 GeneratedField::TableId => {
10150 if table_id__.is_some() {
10151 return Err(serde::de::Error::duplicate_field("tableId"));
10152 }
10153 table_id__ =
10154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10155 ;
10156 }
10157 GeneratedField::State => {
10158 if state__.is_some() {
10159 return Err(serde::de::Error::duplicate_field("state"));
10160 }
10161 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10162 }
10163 GeneratedField::Parallelism => {
10164 if parallelism__.is_some() {
10165 return Err(serde::de::Error::duplicate_field("parallelism"));
10166 }
10167 parallelism__ = map_.next_value()?;
10168 }
10169 GeneratedField::MaxParallelism => {
10170 if max_parallelism__.is_some() {
10171 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10172 }
10173 max_parallelism__ =
10174 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10175 ;
10176 }
10177 GeneratedField::Name => {
10178 if name__.is_some() {
10179 return Err(serde::de::Error::duplicate_field("name"));
10180 }
10181 name__ = Some(map_.next_value()?);
10182 }
10183 GeneratedField::ResourceGroup => {
10184 if resource_group__.is_some() {
10185 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10186 }
10187 resource_group__ = Some(map_.next_value()?);
10188 }
10189 }
10190 }
10191 Ok(list_streaming_job_states_response::StreamingJobState {
10192 table_id: table_id__.unwrap_or_default(),
10193 state: state__.unwrap_or_default(),
10194 parallelism: parallelism__,
10195 max_parallelism: max_parallelism__.unwrap_or_default(),
10196 name: name__.unwrap_or_default(),
10197 resource_group: resource_group__.unwrap_or_default(),
10198 })
10199 }
10200 }
10201 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10202 }
10203}
10204impl serde::Serialize for ListTableFragmentsRequest {
10205 #[allow(deprecated)]
10206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10207 where
10208 S: serde::Serializer,
10209 {
10210 use serde::ser::SerializeStruct;
10211 let mut len = 0;
10212 if !self.table_ids.is_empty() {
10213 len += 1;
10214 }
10215 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10216 if !self.table_ids.is_empty() {
10217 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10218 }
10219 struct_ser.end()
10220 }
10221}
10222impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10223 #[allow(deprecated)]
10224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10225 where
10226 D: serde::Deserializer<'de>,
10227 {
10228 const FIELDS: &[&str] = &[
10229 "table_ids",
10230 "tableIds",
10231 ];
10232
10233 #[allow(clippy::enum_variant_names)]
10234 enum GeneratedField {
10235 TableIds,
10236 }
10237 impl<'de> serde::Deserialize<'de> for GeneratedField {
10238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10239 where
10240 D: serde::Deserializer<'de>,
10241 {
10242 struct GeneratedVisitor;
10243
10244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10245 type Value = GeneratedField;
10246
10247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10248 write!(formatter, "expected one of: {:?}", &FIELDS)
10249 }
10250
10251 #[allow(unused_variables)]
10252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10253 where
10254 E: serde::de::Error,
10255 {
10256 match value {
10257 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10259 }
10260 }
10261 }
10262 deserializer.deserialize_identifier(GeneratedVisitor)
10263 }
10264 }
10265 struct GeneratedVisitor;
10266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10267 type Value = ListTableFragmentsRequest;
10268
10269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10270 formatter.write_str("struct meta.ListTableFragmentsRequest")
10271 }
10272
10273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10274 where
10275 V: serde::de::MapAccess<'de>,
10276 {
10277 let mut table_ids__ = None;
10278 while let Some(k) = map_.next_key()? {
10279 match k {
10280 GeneratedField::TableIds => {
10281 if table_ids__.is_some() {
10282 return Err(serde::de::Error::duplicate_field("tableIds"));
10283 }
10284 table_ids__ =
10285 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10286 .into_iter().map(|x| x.0).collect())
10287 ;
10288 }
10289 }
10290 }
10291 Ok(ListTableFragmentsRequest {
10292 table_ids: table_ids__.unwrap_or_default(),
10293 })
10294 }
10295 }
10296 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10297 }
10298}
10299impl serde::Serialize for ListTableFragmentsResponse {
10300 #[allow(deprecated)]
10301 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10302 where
10303 S: serde::Serializer,
10304 {
10305 use serde::ser::SerializeStruct;
10306 let mut len = 0;
10307 if !self.table_fragments.is_empty() {
10308 len += 1;
10309 }
10310 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10311 if !self.table_fragments.is_empty() {
10312 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10313 }
10314 struct_ser.end()
10315 }
10316}
10317impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10318 #[allow(deprecated)]
10319 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10320 where
10321 D: serde::Deserializer<'de>,
10322 {
10323 const FIELDS: &[&str] = &[
10324 "table_fragments",
10325 "tableFragments",
10326 ];
10327
10328 #[allow(clippy::enum_variant_names)]
10329 enum GeneratedField {
10330 TableFragments,
10331 }
10332 impl<'de> serde::Deserialize<'de> for GeneratedField {
10333 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10334 where
10335 D: serde::Deserializer<'de>,
10336 {
10337 struct GeneratedVisitor;
10338
10339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10340 type Value = GeneratedField;
10341
10342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10343 write!(formatter, "expected one of: {:?}", &FIELDS)
10344 }
10345
10346 #[allow(unused_variables)]
10347 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10348 where
10349 E: serde::de::Error,
10350 {
10351 match value {
10352 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
10353 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10354 }
10355 }
10356 }
10357 deserializer.deserialize_identifier(GeneratedVisitor)
10358 }
10359 }
10360 struct GeneratedVisitor;
10361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10362 type Value = ListTableFragmentsResponse;
10363
10364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10365 formatter.write_str("struct meta.ListTableFragmentsResponse")
10366 }
10367
10368 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
10369 where
10370 V: serde::de::MapAccess<'de>,
10371 {
10372 let mut table_fragments__ = None;
10373 while let Some(k) = map_.next_key()? {
10374 match k {
10375 GeneratedField::TableFragments => {
10376 if table_fragments__.is_some() {
10377 return Err(serde::de::Error::duplicate_field("tableFragments"));
10378 }
10379 table_fragments__ = Some(
10380 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10381 .into_iter().map(|(k,v)| (k.0, v)).collect()
10382 );
10383 }
10384 }
10385 }
10386 Ok(ListTableFragmentsResponse {
10387 table_fragments: table_fragments__.unwrap_or_default(),
10388 })
10389 }
10390 }
10391 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
10392 }
10393}
10394impl serde::Serialize for list_table_fragments_response::ActorInfo {
10395 #[allow(deprecated)]
10396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10397 where
10398 S: serde::Serializer,
10399 {
10400 use serde::ser::SerializeStruct;
10401 let mut len = 0;
10402 if self.id != 0 {
10403 len += 1;
10404 }
10405 if self.node.is_some() {
10406 len += 1;
10407 }
10408 if !self.dispatcher.is_empty() {
10409 len += 1;
10410 }
10411 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
10412 if self.id != 0 {
10413 struct_ser.serialize_field("id", &self.id)?;
10414 }
10415 if let Some(v) = self.node.as_ref() {
10416 struct_ser.serialize_field("node", v)?;
10417 }
10418 if !self.dispatcher.is_empty() {
10419 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10420 }
10421 struct_ser.end()
10422 }
10423}
10424impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
10425 #[allow(deprecated)]
10426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10427 where
10428 D: serde::Deserializer<'de>,
10429 {
10430 const FIELDS: &[&str] = &[
10431 "id",
10432 "node",
10433 "dispatcher",
10434 ];
10435
10436 #[allow(clippy::enum_variant_names)]
10437 enum GeneratedField {
10438 Id,
10439 Node,
10440 Dispatcher,
10441 }
10442 impl<'de> serde::Deserialize<'de> for GeneratedField {
10443 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10444 where
10445 D: serde::Deserializer<'de>,
10446 {
10447 struct GeneratedVisitor;
10448
10449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10450 type Value = GeneratedField;
10451
10452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10453 write!(formatter, "expected one of: {:?}", &FIELDS)
10454 }
10455
10456 #[allow(unused_variables)]
10457 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10458 where
10459 E: serde::de::Error,
10460 {
10461 match value {
10462 "id" => Ok(GeneratedField::Id),
10463 "node" => Ok(GeneratedField::Node),
10464 "dispatcher" => Ok(GeneratedField::Dispatcher),
10465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10466 }
10467 }
10468 }
10469 deserializer.deserialize_identifier(GeneratedVisitor)
10470 }
10471 }
10472 struct GeneratedVisitor;
10473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10474 type Value = list_table_fragments_response::ActorInfo;
10475
10476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10477 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
10478 }
10479
10480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
10481 where
10482 V: serde::de::MapAccess<'de>,
10483 {
10484 let mut id__ = None;
10485 let mut node__ = None;
10486 let mut dispatcher__ = None;
10487 while let Some(k) = map_.next_key()? {
10488 match k {
10489 GeneratedField::Id => {
10490 if id__.is_some() {
10491 return Err(serde::de::Error::duplicate_field("id"));
10492 }
10493 id__ =
10494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10495 ;
10496 }
10497 GeneratedField::Node => {
10498 if node__.is_some() {
10499 return Err(serde::de::Error::duplicate_field("node"));
10500 }
10501 node__ = map_.next_value()?;
10502 }
10503 GeneratedField::Dispatcher => {
10504 if dispatcher__.is_some() {
10505 return Err(serde::de::Error::duplicate_field("dispatcher"));
10506 }
10507 dispatcher__ = Some(map_.next_value()?);
10508 }
10509 }
10510 }
10511 Ok(list_table_fragments_response::ActorInfo {
10512 id: id__.unwrap_or_default(),
10513 node: node__,
10514 dispatcher: dispatcher__.unwrap_or_default(),
10515 })
10516 }
10517 }
10518 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
10519 }
10520}
10521impl serde::Serialize for list_table_fragments_response::FragmentInfo {
10522 #[allow(deprecated)]
10523 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10524 where
10525 S: serde::Serializer,
10526 {
10527 use serde::ser::SerializeStruct;
10528 let mut len = 0;
10529 if self.id != 0 {
10530 len += 1;
10531 }
10532 if !self.actors.is_empty() {
10533 len += 1;
10534 }
10535 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
10536 if self.id != 0 {
10537 struct_ser.serialize_field("id", &self.id)?;
10538 }
10539 if !self.actors.is_empty() {
10540 struct_ser.serialize_field("actors", &self.actors)?;
10541 }
10542 struct_ser.end()
10543 }
10544}
10545impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
10546 #[allow(deprecated)]
10547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10548 where
10549 D: serde::Deserializer<'de>,
10550 {
10551 const FIELDS: &[&str] = &[
10552 "id",
10553 "actors",
10554 ];
10555
10556 #[allow(clippy::enum_variant_names)]
10557 enum GeneratedField {
10558 Id,
10559 Actors,
10560 }
10561 impl<'de> serde::Deserialize<'de> for GeneratedField {
10562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10563 where
10564 D: serde::Deserializer<'de>,
10565 {
10566 struct GeneratedVisitor;
10567
10568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10569 type Value = GeneratedField;
10570
10571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10572 write!(formatter, "expected one of: {:?}", &FIELDS)
10573 }
10574
10575 #[allow(unused_variables)]
10576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10577 where
10578 E: serde::de::Error,
10579 {
10580 match value {
10581 "id" => Ok(GeneratedField::Id),
10582 "actors" => Ok(GeneratedField::Actors),
10583 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10584 }
10585 }
10586 }
10587 deserializer.deserialize_identifier(GeneratedVisitor)
10588 }
10589 }
10590 struct GeneratedVisitor;
10591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10592 type Value = list_table_fragments_response::FragmentInfo;
10593
10594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10595 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
10596 }
10597
10598 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
10599 where
10600 V: serde::de::MapAccess<'de>,
10601 {
10602 let mut id__ = None;
10603 let mut actors__ = None;
10604 while let Some(k) = map_.next_key()? {
10605 match k {
10606 GeneratedField::Id => {
10607 if id__.is_some() {
10608 return Err(serde::de::Error::duplicate_field("id"));
10609 }
10610 id__ =
10611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10612 ;
10613 }
10614 GeneratedField::Actors => {
10615 if actors__.is_some() {
10616 return Err(serde::de::Error::duplicate_field("actors"));
10617 }
10618 actors__ = Some(map_.next_value()?);
10619 }
10620 }
10621 }
10622 Ok(list_table_fragments_response::FragmentInfo {
10623 id: id__.unwrap_or_default(),
10624 actors: actors__.unwrap_or_default(),
10625 })
10626 }
10627 }
10628 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
10629 }
10630}
10631impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
10632 #[allow(deprecated)]
10633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10634 where
10635 S: serde::Serializer,
10636 {
10637 use serde::ser::SerializeStruct;
10638 let mut len = 0;
10639 if !self.fragments.is_empty() {
10640 len += 1;
10641 }
10642 if self.ctx.is_some() {
10643 len += 1;
10644 }
10645 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
10646 if !self.fragments.is_empty() {
10647 struct_ser.serialize_field("fragments", &self.fragments)?;
10648 }
10649 if let Some(v) = self.ctx.as_ref() {
10650 struct_ser.serialize_field("ctx", v)?;
10651 }
10652 struct_ser.end()
10653 }
10654}
10655impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
10656 #[allow(deprecated)]
10657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10658 where
10659 D: serde::Deserializer<'de>,
10660 {
10661 const FIELDS: &[&str] = &[
10662 "fragments",
10663 "ctx",
10664 ];
10665
10666 #[allow(clippy::enum_variant_names)]
10667 enum GeneratedField {
10668 Fragments,
10669 Ctx,
10670 }
10671 impl<'de> serde::Deserialize<'de> for GeneratedField {
10672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10673 where
10674 D: serde::Deserializer<'de>,
10675 {
10676 struct GeneratedVisitor;
10677
10678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10679 type Value = GeneratedField;
10680
10681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10682 write!(formatter, "expected one of: {:?}", &FIELDS)
10683 }
10684
10685 #[allow(unused_variables)]
10686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10687 where
10688 E: serde::de::Error,
10689 {
10690 match value {
10691 "fragments" => Ok(GeneratedField::Fragments),
10692 "ctx" => Ok(GeneratedField::Ctx),
10693 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10694 }
10695 }
10696 }
10697 deserializer.deserialize_identifier(GeneratedVisitor)
10698 }
10699 }
10700 struct GeneratedVisitor;
10701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10702 type Value = list_table_fragments_response::TableFragmentInfo;
10703
10704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10705 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
10706 }
10707
10708 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
10709 where
10710 V: serde::de::MapAccess<'de>,
10711 {
10712 let mut fragments__ = None;
10713 let mut ctx__ = None;
10714 while let Some(k) = map_.next_key()? {
10715 match k {
10716 GeneratedField::Fragments => {
10717 if fragments__.is_some() {
10718 return Err(serde::de::Error::duplicate_field("fragments"));
10719 }
10720 fragments__ = Some(map_.next_value()?);
10721 }
10722 GeneratedField::Ctx => {
10723 if ctx__.is_some() {
10724 return Err(serde::de::Error::duplicate_field("ctx"));
10725 }
10726 ctx__ = map_.next_value()?;
10727 }
10728 }
10729 }
10730 Ok(list_table_fragments_response::TableFragmentInfo {
10731 fragments: fragments__.unwrap_or_default(),
10732 ctx: ctx__,
10733 })
10734 }
10735 }
10736 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
10737 }
10738}
10739impl serde::Serialize for MembersRequest {
10740 #[allow(deprecated)]
10741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10742 where
10743 S: serde::Serializer,
10744 {
10745 use serde::ser::SerializeStruct;
10746 let len = 0;
10747 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
10748 struct_ser.end()
10749 }
10750}
10751impl<'de> serde::Deserialize<'de> for MembersRequest {
10752 #[allow(deprecated)]
10753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10754 where
10755 D: serde::Deserializer<'de>,
10756 {
10757 const FIELDS: &[&str] = &[
10758 ];
10759
10760 #[allow(clippy::enum_variant_names)]
10761 enum GeneratedField {
10762 }
10763 impl<'de> serde::Deserialize<'de> for GeneratedField {
10764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10765 where
10766 D: serde::Deserializer<'de>,
10767 {
10768 struct GeneratedVisitor;
10769
10770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10771 type Value = GeneratedField;
10772
10773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10774 write!(formatter, "expected one of: {:?}", &FIELDS)
10775 }
10776
10777 #[allow(unused_variables)]
10778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10779 where
10780 E: serde::de::Error,
10781 {
10782 Err(serde::de::Error::unknown_field(value, FIELDS))
10783 }
10784 }
10785 deserializer.deserialize_identifier(GeneratedVisitor)
10786 }
10787 }
10788 struct GeneratedVisitor;
10789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10790 type Value = MembersRequest;
10791
10792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10793 formatter.write_str("struct meta.MembersRequest")
10794 }
10795
10796 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
10797 where
10798 V: serde::de::MapAccess<'de>,
10799 {
10800 while map_.next_key::<GeneratedField>()?.is_some() {
10801 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10802 }
10803 Ok(MembersRequest {
10804 })
10805 }
10806 }
10807 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
10808 }
10809}
10810impl serde::Serialize for MembersResponse {
10811 #[allow(deprecated)]
10812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10813 where
10814 S: serde::Serializer,
10815 {
10816 use serde::ser::SerializeStruct;
10817 let mut len = 0;
10818 if !self.members.is_empty() {
10819 len += 1;
10820 }
10821 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
10822 if !self.members.is_empty() {
10823 struct_ser.serialize_field("members", &self.members)?;
10824 }
10825 struct_ser.end()
10826 }
10827}
10828impl<'de> serde::Deserialize<'de> for MembersResponse {
10829 #[allow(deprecated)]
10830 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10831 where
10832 D: serde::Deserializer<'de>,
10833 {
10834 const FIELDS: &[&str] = &[
10835 "members",
10836 ];
10837
10838 #[allow(clippy::enum_variant_names)]
10839 enum GeneratedField {
10840 Members,
10841 }
10842 impl<'de> serde::Deserialize<'de> for GeneratedField {
10843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10844 where
10845 D: serde::Deserializer<'de>,
10846 {
10847 struct GeneratedVisitor;
10848
10849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10850 type Value = GeneratedField;
10851
10852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10853 write!(formatter, "expected one of: {:?}", &FIELDS)
10854 }
10855
10856 #[allow(unused_variables)]
10857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10858 where
10859 E: serde::de::Error,
10860 {
10861 match value {
10862 "members" => Ok(GeneratedField::Members),
10863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10864 }
10865 }
10866 }
10867 deserializer.deserialize_identifier(GeneratedVisitor)
10868 }
10869 }
10870 struct GeneratedVisitor;
10871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10872 type Value = MembersResponse;
10873
10874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10875 formatter.write_str("struct meta.MembersResponse")
10876 }
10877
10878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
10879 where
10880 V: serde::de::MapAccess<'de>,
10881 {
10882 let mut members__ = None;
10883 while let Some(k) = map_.next_key()? {
10884 match k {
10885 GeneratedField::Members => {
10886 if members__.is_some() {
10887 return Err(serde::de::Error::duplicate_field("members"));
10888 }
10889 members__ = Some(map_.next_value()?);
10890 }
10891 }
10892 }
10893 Ok(MembersResponse {
10894 members: members__.unwrap_or_default(),
10895 })
10896 }
10897 }
10898 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
10899 }
10900}
10901impl serde::Serialize for MetaMember {
10902 #[allow(deprecated)]
10903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10904 where
10905 S: serde::Serializer,
10906 {
10907 use serde::ser::SerializeStruct;
10908 let mut len = 0;
10909 if self.address.is_some() {
10910 len += 1;
10911 }
10912 if self.is_leader {
10913 len += 1;
10914 }
10915 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
10916 if let Some(v) = self.address.as_ref() {
10917 struct_ser.serialize_field("address", v)?;
10918 }
10919 if self.is_leader {
10920 struct_ser.serialize_field("isLeader", &self.is_leader)?;
10921 }
10922 struct_ser.end()
10923 }
10924}
10925impl<'de> serde::Deserialize<'de> for MetaMember {
10926 #[allow(deprecated)]
10927 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10928 where
10929 D: serde::Deserializer<'de>,
10930 {
10931 const FIELDS: &[&str] = &[
10932 "address",
10933 "is_leader",
10934 "isLeader",
10935 ];
10936
10937 #[allow(clippy::enum_variant_names)]
10938 enum GeneratedField {
10939 Address,
10940 IsLeader,
10941 }
10942 impl<'de> serde::Deserialize<'de> for GeneratedField {
10943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10944 where
10945 D: serde::Deserializer<'de>,
10946 {
10947 struct GeneratedVisitor;
10948
10949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10950 type Value = GeneratedField;
10951
10952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10953 write!(formatter, "expected one of: {:?}", &FIELDS)
10954 }
10955
10956 #[allow(unused_variables)]
10957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10958 where
10959 E: serde::de::Error,
10960 {
10961 match value {
10962 "address" => Ok(GeneratedField::Address),
10963 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
10964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10965 }
10966 }
10967 }
10968 deserializer.deserialize_identifier(GeneratedVisitor)
10969 }
10970 }
10971 struct GeneratedVisitor;
10972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10973 type Value = MetaMember;
10974
10975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10976 formatter.write_str("struct meta.MetaMember")
10977 }
10978
10979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
10980 where
10981 V: serde::de::MapAccess<'de>,
10982 {
10983 let mut address__ = None;
10984 let mut is_leader__ = None;
10985 while let Some(k) = map_.next_key()? {
10986 match k {
10987 GeneratedField::Address => {
10988 if address__.is_some() {
10989 return Err(serde::de::Error::duplicate_field("address"));
10990 }
10991 address__ = map_.next_value()?;
10992 }
10993 GeneratedField::IsLeader => {
10994 if is_leader__.is_some() {
10995 return Err(serde::de::Error::duplicate_field("isLeader"));
10996 }
10997 is_leader__ = Some(map_.next_value()?);
10998 }
10999 }
11000 }
11001 Ok(MetaMember {
11002 address: address__,
11003 is_leader: is_leader__.unwrap_or_default(),
11004 })
11005 }
11006 }
11007 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11008 }
11009}
11010impl serde::Serialize for MetaSnapshot {
11011 #[allow(deprecated)]
11012 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11013 where
11014 S: serde::Serializer,
11015 {
11016 use serde::ser::SerializeStruct;
11017 let mut len = 0;
11018 if !self.databases.is_empty() {
11019 len += 1;
11020 }
11021 if !self.schemas.is_empty() {
11022 len += 1;
11023 }
11024 if !self.sources.is_empty() {
11025 len += 1;
11026 }
11027 if !self.sinks.is_empty() {
11028 len += 1;
11029 }
11030 if !self.tables.is_empty() {
11031 len += 1;
11032 }
11033 if !self.indexes.is_empty() {
11034 len += 1;
11035 }
11036 if !self.views.is_empty() {
11037 len += 1;
11038 }
11039 if !self.functions.is_empty() {
11040 len += 1;
11041 }
11042 if !self.connections.is_empty() {
11043 len += 1;
11044 }
11045 if !self.subscriptions.is_empty() {
11046 len += 1;
11047 }
11048 if !self.users.is_empty() {
11049 len += 1;
11050 }
11051 if self.session_params.is_some() {
11052 len += 1;
11053 }
11054 if !self.secrets.is_empty() {
11055 len += 1;
11056 }
11057 if self.compute_node_total_cpu_count != 0 {
11058 len += 1;
11059 }
11060 if !self.nodes.is_empty() {
11061 len += 1;
11062 }
11063 if self.hummock_version.is_some() {
11064 len += 1;
11065 }
11066 if self.meta_backup_manifest_id.is_some() {
11067 len += 1;
11068 }
11069 if self.hummock_write_limits.is_some() {
11070 len += 1;
11071 }
11072 if !self.streaming_worker_slot_mappings.is_empty() {
11073 len += 1;
11074 }
11075 if !self.serving_worker_slot_mappings.is_empty() {
11076 len += 1;
11077 }
11078 if self.version.is_some() {
11079 len += 1;
11080 }
11081 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11082 if !self.databases.is_empty() {
11083 struct_ser.serialize_field("databases", &self.databases)?;
11084 }
11085 if !self.schemas.is_empty() {
11086 struct_ser.serialize_field("schemas", &self.schemas)?;
11087 }
11088 if !self.sources.is_empty() {
11089 struct_ser.serialize_field("sources", &self.sources)?;
11090 }
11091 if !self.sinks.is_empty() {
11092 struct_ser.serialize_field("sinks", &self.sinks)?;
11093 }
11094 if !self.tables.is_empty() {
11095 struct_ser.serialize_field("tables", &self.tables)?;
11096 }
11097 if !self.indexes.is_empty() {
11098 struct_ser.serialize_field("indexes", &self.indexes)?;
11099 }
11100 if !self.views.is_empty() {
11101 struct_ser.serialize_field("views", &self.views)?;
11102 }
11103 if !self.functions.is_empty() {
11104 struct_ser.serialize_field("functions", &self.functions)?;
11105 }
11106 if !self.connections.is_empty() {
11107 struct_ser.serialize_field("connections", &self.connections)?;
11108 }
11109 if !self.subscriptions.is_empty() {
11110 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11111 }
11112 if !self.users.is_empty() {
11113 struct_ser.serialize_field("users", &self.users)?;
11114 }
11115 if let Some(v) = self.session_params.as_ref() {
11116 struct_ser.serialize_field("sessionParams", v)?;
11117 }
11118 if !self.secrets.is_empty() {
11119 struct_ser.serialize_field("secrets", &self.secrets)?;
11120 }
11121 if self.compute_node_total_cpu_count != 0 {
11122 #[allow(clippy::needless_borrow)]
11123 #[allow(clippy::needless_borrows_for_generic_args)]
11124 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11125 }
11126 if !self.nodes.is_empty() {
11127 struct_ser.serialize_field("nodes", &self.nodes)?;
11128 }
11129 if let Some(v) = self.hummock_version.as_ref() {
11130 struct_ser.serialize_field("hummockVersion", v)?;
11131 }
11132 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11133 struct_ser.serialize_field("metaBackupManifestId", v)?;
11134 }
11135 if let Some(v) = self.hummock_write_limits.as_ref() {
11136 struct_ser.serialize_field("hummockWriteLimits", v)?;
11137 }
11138 if !self.streaming_worker_slot_mappings.is_empty() {
11139 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11140 }
11141 if !self.serving_worker_slot_mappings.is_empty() {
11142 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11143 }
11144 if let Some(v) = self.version.as_ref() {
11145 struct_ser.serialize_field("version", v)?;
11146 }
11147 struct_ser.end()
11148 }
11149}
11150impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11151 #[allow(deprecated)]
11152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11153 where
11154 D: serde::Deserializer<'de>,
11155 {
11156 const FIELDS: &[&str] = &[
11157 "databases",
11158 "schemas",
11159 "sources",
11160 "sinks",
11161 "tables",
11162 "indexes",
11163 "views",
11164 "functions",
11165 "connections",
11166 "subscriptions",
11167 "users",
11168 "session_params",
11169 "sessionParams",
11170 "secrets",
11171 "compute_node_total_cpu_count",
11172 "computeNodeTotalCpuCount",
11173 "nodes",
11174 "hummock_version",
11175 "hummockVersion",
11176 "meta_backup_manifest_id",
11177 "metaBackupManifestId",
11178 "hummock_write_limits",
11179 "hummockWriteLimits",
11180 "streaming_worker_slot_mappings",
11181 "streamingWorkerSlotMappings",
11182 "serving_worker_slot_mappings",
11183 "servingWorkerSlotMappings",
11184 "version",
11185 ];
11186
11187 #[allow(clippy::enum_variant_names)]
11188 enum GeneratedField {
11189 Databases,
11190 Schemas,
11191 Sources,
11192 Sinks,
11193 Tables,
11194 Indexes,
11195 Views,
11196 Functions,
11197 Connections,
11198 Subscriptions,
11199 Users,
11200 SessionParams,
11201 Secrets,
11202 ComputeNodeTotalCpuCount,
11203 Nodes,
11204 HummockVersion,
11205 MetaBackupManifestId,
11206 HummockWriteLimits,
11207 StreamingWorkerSlotMappings,
11208 ServingWorkerSlotMappings,
11209 Version,
11210 }
11211 impl<'de> serde::Deserialize<'de> for GeneratedField {
11212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11213 where
11214 D: serde::Deserializer<'de>,
11215 {
11216 struct GeneratedVisitor;
11217
11218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11219 type Value = GeneratedField;
11220
11221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11222 write!(formatter, "expected one of: {:?}", &FIELDS)
11223 }
11224
11225 #[allow(unused_variables)]
11226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11227 where
11228 E: serde::de::Error,
11229 {
11230 match value {
11231 "databases" => Ok(GeneratedField::Databases),
11232 "schemas" => Ok(GeneratedField::Schemas),
11233 "sources" => Ok(GeneratedField::Sources),
11234 "sinks" => Ok(GeneratedField::Sinks),
11235 "tables" => Ok(GeneratedField::Tables),
11236 "indexes" => Ok(GeneratedField::Indexes),
11237 "views" => Ok(GeneratedField::Views),
11238 "functions" => Ok(GeneratedField::Functions),
11239 "connections" => Ok(GeneratedField::Connections),
11240 "subscriptions" => Ok(GeneratedField::Subscriptions),
11241 "users" => Ok(GeneratedField::Users),
11242 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11243 "secrets" => Ok(GeneratedField::Secrets),
11244 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11245 "nodes" => Ok(GeneratedField::Nodes),
11246 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11247 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11248 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11249 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11250 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11251 "version" => Ok(GeneratedField::Version),
11252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11253 }
11254 }
11255 }
11256 deserializer.deserialize_identifier(GeneratedVisitor)
11257 }
11258 }
11259 struct GeneratedVisitor;
11260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11261 type Value = MetaSnapshot;
11262
11263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11264 formatter.write_str("struct meta.MetaSnapshot")
11265 }
11266
11267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11268 where
11269 V: serde::de::MapAccess<'de>,
11270 {
11271 let mut databases__ = None;
11272 let mut schemas__ = None;
11273 let mut sources__ = None;
11274 let mut sinks__ = None;
11275 let mut tables__ = None;
11276 let mut indexes__ = None;
11277 let mut views__ = None;
11278 let mut functions__ = None;
11279 let mut connections__ = None;
11280 let mut subscriptions__ = None;
11281 let mut users__ = None;
11282 let mut session_params__ = None;
11283 let mut secrets__ = None;
11284 let mut compute_node_total_cpu_count__ = None;
11285 let mut nodes__ = None;
11286 let mut hummock_version__ = None;
11287 let mut meta_backup_manifest_id__ = None;
11288 let mut hummock_write_limits__ = None;
11289 let mut streaming_worker_slot_mappings__ = None;
11290 let mut serving_worker_slot_mappings__ = None;
11291 let mut version__ = None;
11292 while let Some(k) = map_.next_key()? {
11293 match k {
11294 GeneratedField::Databases => {
11295 if databases__.is_some() {
11296 return Err(serde::de::Error::duplicate_field("databases"));
11297 }
11298 databases__ = Some(map_.next_value()?);
11299 }
11300 GeneratedField::Schemas => {
11301 if schemas__.is_some() {
11302 return Err(serde::de::Error::duplicate_field("schemas"));
11303 }
11304 schemas__ = Some(map_.next_value()?);
11305 }
11306 GeneratedField::Sources => {
11307 if sources__.is_some() {
11308 return Err(serde::de::Error::duplicate_field("sources"));
11309 }
11310 sources__ = Some(map_.next_value()?);
11311 }
11312 GeneratedField::Sinks => {
11313 if sinks__.is_some() {
11314 return Err(serde::de::Error::duplicate_field("sinks"));
11315 }
11316 sinks__ = Some(map_.next_value()?);
11317 }
11318 GeneratedField::Tables => {
11319 if tables__.is_some() {
11320 return Err(serde::de::Error::duplicate_field("tables"));
11321 }
11322 tables__ = Some(map_.next_value()?);
11323 }
11324 GeneratedField::Indexes => {
11325 if indexes__.is_some() {
11326 return Err(serde::de::Error::duplicate_field("indexes"));
11327 }
11328 indexes__ = Some(map_.next_value()?);
11329 }
11330 GeneratedField::Views => {
11331 if views__.is_some() {
11332 return Err(serde::de::Error::duplicate_field("views"));
11333 }
11334 views__ = Some(map_.next_value()?);
11335 }
11336 GeneratedField::Functions => {
11337 if functions__.is_some() {
11338 return Err(serde::de::Error::duplicate_field("functions"));
11339 }
11340 functions__ = Some(map_.next_value()?);
11341 }
11342 GeneratedField::Connections => {
11343 if connections__.is_some() {
11344 return Err(serde::de::Error::duplicate_field("connections"));
11345 }
11346 connections__ = Some(map_.next_value()?);
11347 }
11348 GeneratedField::Subscriptions => {
11349 if subscriptions__.is_some() {
11350 return Err(serde::de::Error::duplicate_field("subscriptions"));
11351 }
11352 subscriptions__ = Some(map_.next_value()?);
11353 }
11354 GeneratedField::Users => {
11355 if users__.is_some() {
11356 return Err(serde::de::Error::duplicate_field("users"));
11357 }
11358 users__ = Some(map_.next_value()?);
11359 }
11360 GeneratedField::SessionParams => {
11361 if session_params__.is_some() {
11362 return Err(serde::de::Error::duplicate_field("sessionParams"));
11363 }
11364 session_params__ = map_.next_value()?;
11365 }
11366 GeneratedField::Secrets => {
11367 if secrets__.is_some() {
11368 return Err(serde::de::Error::duplicate_field("secrets"));
11369 }
11370 secrets__ = Some(map_.next_value()?);
11371 }
11372 GeneratedField::ComputeNodeTotalCpuCount => {
11373 if compute_node_total_cpu_count__.is_some() {
11374 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
11375 }
11376 compute_node_total_cpu_count__ =
11377 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11378 ;
11379 }
11380 GeneratedField::Nodes => {
11381 if nodes__.is_some() {
11382 return Err(serde::de::Error::duplicate_field("nodes"));
11383 }
11384 nodes__ = Some(map_.next_value()?);
11385 }
11386 GeneratedField::HummockVersion => {
11387 if hummock_version__.is_some() {
11388 return Err(serde::de::Error::duplicate_field("hummockVersion"));
11389 }
11390 hummock_version__ = map_.next_value()?;
11391 }
11392 GeneratedField::MetaBackupManifestId => {
11393 if meta_backup_manifest_id__.is_some() {
11394 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
11395 }
11396 meta_backup_manifest_id__ = map_.next_value()?;
11397 }
11398 GeneratedField::HummockWriteLimits => {
11399 if hummock_write_limits__.is_some() {
11400 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
11401 }
11402 hummock_write_limits__ = map_.next_value()?;
11403 }
11404 GeneratedField::StreamingWorkerSlotMappings => {
11405 if streaming_worker_slot_mappings__.is_some() {
11406 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
11407 }
11408 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
11409 }
11410 GeneratedField::ServingWorkerSlotMappings => {
11411 if serving_worker_slot_mappings__.is_some() {
11412 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
11413 }
11414 serving_worker_slot_mappings__ = Some(map_.next_value()?);
11415 }
11416 GeneratedField::Version => {
11417 if version__.is_some() {
11418 return Err(serde::de::Error::duplicate_field("version"));
11419 }
11420 version__ = map_.next_value()?;
11421 }
11422 }
11423 }
11424 Ok(MetaSnapshot {
11425 databases: databases__.unwrap_or_default(),
11426 schemas: schemas__.unwrap_or_default(),
11427 sources: sources__.unwrap_or_default(),
11428 sinks: sinks__.unwrap_or_default(),
11429 tables: tables__.unwrap_or_default(),
11430 indexes: indexes__.unwrap_or_default(),
11431 views: views__.unwrap_or_default(),
11432 functions: functions__.unwrap_or_default(),
11433 connections: connections__.unwrap_or_default(),
11434 subscriptions: subscriptions__.unwrap_or_default(),
11435 users: users__.unwrap_or_default(),
11436 session_params: session_params__,
11437 secrets: secrets__.unwrap_or_default(),
11438 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
11439 nodes: nodes__.unwrap_or_default(),
11440 hummock_version: hummock_version__,
11441 meta_backup_manifest_id: meta_backup_manifest_id__,
11442 hummock_write_limits: hummock_write_limits__,
11443 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
11444 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
11445 version: version__,
11446 })
11447 }
11448 }
11449 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
11450 }
11451}
11452impl serde::Serialize for meta_snapshot::SnapshotVersion {
11453 #[allow(deprecated)]
11454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11455 where
11456 S: serde::Serializer,
11457 {
11458 use serde::ser::SerializeStruct;
11459 let mut len = 0;
11460 if self.catalog_version != 0 {
11461 len += 1;
11462 }
11463 if self.worker_node_version != 0 {
11464 len += 1;
11465 }
11466 if self.streaming_worker_slot_mapping_version != 0 {
11467 len += 1;
11468 }
11469 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
11470 if self.catalog_version != 0 {
11471 #[allow(clippy::needless_borrow)]
11472 #[allow(clippy::needless_borrows_for_generic_args)]
11473 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11474 }
11475 if self.worker_node_version != 0 {
11476 #[allow(clippy::needless_borrow)]
11477 #[allow(clippy::needless_borrows_for_generic_args)]
11478 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
11479 }
11480 if self.streaming_worker_slot_mapping_version != 0 {
11481 #[allow(clippy::needless_borrow)]
11482 #[allow(clippy::needless_borrows_for_generic_args)]
11483 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
11484 }
11485 struct_ser.end()
11486 }
11487}
11488impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
11489 #[allow(deprecated)]
11490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11491 where
11492 D: serde::Deserializer<'de>,
11493 {
11494 const FIELDS: &[&str] = &[
11495 "catalog_version",
11496 "catalogVersion",
11497 "worker_node_version",
11498 "workerNodeVersion",
11499 "streaming_worker_slot_mapping_version",
11500 "streamingWorkerSlotMappingVersion",
11501 ];
11502
11503 #[allow(clippy::enum_variant_names)]
11504 enum GeneratedField {
11505 CatalogVersion,
11506 WorkerNodeVersion,
11507 StreamingWorkerSlotMappingVersion,
11508 }
11509 impl<'de> serde::Deserialize<'de> for GeneratedField {
11510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11511 where
11512 D: serde::Deserializer<'de>,
11513 {
11514 struct GeneratedVisitor;
11515
11516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11517 type Value = GeneratedField;
11518
11519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11520 write!(formatter, "expected one of: {:?}", &FIELDS)
11521 }
11522
11523 #[allow(unused_variables)]
11524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11525 where
11526 E: serde::de::Error,
11527 {
11528 match value {
11529 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
11530 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
11531 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
11532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11533 }
11534 }
11535 }
11536 deserializer.deserialize_identifier(GeneratedVisitor)
11537 }
11538 }
11539 struct GeneratedVisitor;
11540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11541 type Value = meta_snapshot::SnapshotVersion;
11542
11543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11544 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
11545 }
11546
11547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
11548 where
11549 V: serde::de::MapAccess<'de>,
11550 {
11551 let mut catalog_version__ = None;
11552 let mut worker_node_version__ = None;
11553 let mut streaming_worker_slot_mapping_version__ = None;
11554 while let Some(k) = map_.next_key()? {
11555 match k {
11556 GeneratedField::CatalogVersion => {
11557 if catalog_version__.is_some() {
11558 return Err(serde::de::Error::duplicate_field("catalogVersion"));
11559 }
11560 catalog_version__ =
11561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11562 ;
11563 }
11564 GeneratedField::WorkerNodeVersion => {
11565 if worker_node_version__.is_some() {
11566 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
11567 }
11568 worker_node_version__ =
11569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11570 ;
11571 }
11572 GeneratedField::StreamingWorkerSlotMappingVersion => {
11573 if streaming_worker_slot_mapping_version__.is_some() {
11574 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
11575 }
11576 streaming_worker_slot_mapping_version__ =
11577 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11578 ;
11579 }
11580 }
11581 }
11582 Ok(meta_snapshot::SnapshotVersion {
11583 catalog_version: catalog_version__.unwrap_or_default(),
11584 worker_node_version: worker_node_version__.unwrap_or_default(),
11585 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
11586 })
11587 }
11588 }
11589 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
11590 }
11591}
11592impl serde::Serialize for MigrationPlan {
11593 #[allow(deprecated)]
11594 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11595 where
11596 S: serde::Serializer,
11597 {
11598 use serde::ser::SerializeStruct;
11599 let mut len = 0;
11600 if !self.worker_slot_migration_plan.is_empty() {
11601 len += 1;
11602 }
11603 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
11604 if !self.worker_slot_migration_plan.is_empty() {
11605 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
11606 .map(|(k, v)| (k, v.to_string())).collect();
11607 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
11608 }
11609 struct_ser.end()
11610 }
11611}
11612impl<'de> serde::Deserialize<'de> for MigrationPlan {
11613 #[allow(deprecated)]
11614 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11615 where
11616 D: serde::Deserializer<'de>,
11617 {
11618 const FIELDS: &[&str] = &[
11619 "worker_slot_migration_plan",
11620 "workerSlotMigrationPlan",
11621 ];
11622
11623 #[allow(clippy::enum_variant_names)]
11624 enum GeneratedField {
11625 WorkerSlotMigrationPlan,
11626 }
11627 impl<'de> serde::Deserialize<'de> for GeneratedField {
11628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11629 where
11630 D: serde::Deserializer<'de>,
11631 {
11632 struct GeneratedVisitor;
11633
11634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11635 type Value = GeneratedField;
11636
11637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11638 write!(formatter, "expected one of: {:?}", &FIELDS)
11639 }
11640
11641 #[allow(unused_variables)]
11642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11643 where
11644 E: serde::de::Error,
11645 {
11646 match value {
11647 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
11648 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11649 }
11650 }
11651 }
11652 deserializer.deserialize_identifier(GeneratedVisitor)
11653 }
11654 }
11655 struct GeneratedVisitor;
11656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11657 type Value = MigrationPlan;
11658
11659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11660 formatter.write_str("struct meta.MigrationPlan")
11661 }
11662
11663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
11664 where
11665 V: serde::de::MapAccess<'de>,
11666 {
11667 let mut worker_slot_migration_plan__ = None;
11668 while let Some(k) = map_.next_key()? {
11669 match k {
11670 GeneratedField::WorkerSlotMigrationPlan => {
11671 if worker_slot_migration_plan__.is_some() {
11672 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
11673 }
11674 worker_slot_migration_plan__ = Some(
11675 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11676 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
11677 );
11678 }
11679 }
11680 }
11681 Ok(MigrationPlan {
11682 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
11683 })
11684 }
11685 }
11686 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
11687 }
11688}
11689impl serde::Serialize for Object {
11690 #[allow(deprecated)]
11691 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11692 where
11693 S: serde::Serializer,
11694 {
11695 use serde::ser::SerializeStruct;
11696 let mut len = 0;
11697 if self.object_info.is_some() {
11698 len += 1;
11699 }
11700 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
11701 if let Some(v) = self.object_info.as_ref() {
11702 match v {
11703 object::ObjectInfo::Database(v) => {
11704 struct_ser.serialize_field("database", v)?;
11705 }
11706 object::ObjectInfo::Schema(v) => {
11707 struct_ser.serialize_field("schema", v)?;
11708 }
11709 object::ObjectInfo::Table(v) => {
11710 struct_ser.serialize_field("table", v)?;
11711 }
11712 object::ObjectInfo::Index(v) => {
11713 struct_ser.serialize_field("index", v)?;
11714 }
11715 object::ObjectInfo::Source(v) => {
11716 struct_ser.serialize_field("source", v)?;
11717 }
11718 object::ObjectInfo::Sink(v) => {
11719 struct_ser.serialize_field("sink", v)?;
11720 }
11721 object::ObjectInfo::View(v) => {
11722 struct_ser.serialize_field("view", v)?;
11723 }
11724 object::ObjectInfo::Function(v) => {
11725 struct_ser.serialize_field("function", v)?;
11726 }
11727 object::ObjectInfo::Connection(v) => {
11728 struct_ser.serialize_field("connection", v)?;
11729 }
11730 object::ObjectInfo::Subscription(v) => {
11731 struct_ser.serialize_field("subscription", v)?;
11732 }
11733 object::ObjectInfo::Secret(v) => {
11734 struct_ser.serialize_field("secret", v)?;
11735 }
11736 }
11737 }
11738 struct_ser.end()
11739 }
11740}
11741impl<'de> serde::Deserialize<'de> for Object {
11742 #[allow(deprecated)]
11743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11744 where
11745 D: serde::Deserializer<'de>,
11746 {
11747 const FIELDS: &[&str] = &[
11748 "database",
11749 "schema",
11750 "table",
11751 "index",
11752 "source",
11753 "sink",
11754 "view",
11755 "function",
11756 "connection",
11757 "subscription",
11758 "secret",
11759 ];
11760
11761 #[allow(clippy::enum_variant_names)]
11762 enum GeneratedField {
11763 Database,
11764 Schema,
11765 Table,
11766 Index,
11767 Source,
11768 Sink,
11769 View,
11770 Function,
11771 Connection,
11772 Subscription,
11773 Secret,
11774 }
11775 impl<'de> serde::Deserialize<'de> for GeneratedField {
11776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11777 where
11778 D: serde::Deserializer<'de>,
11779 {
11780 struct GeneratedVisitor;
11781
11782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11783 type Value = GeneratedField;
11784
11785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11786 write!(formatter, "expected one of: {:?}", &FIELDS)
11787 }
11788
11789 #[allow(unused_variables)]
11790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11791 where
11792 E: serde::de::Error,
11793 {
11794 match value {
11795 "database" => Ok(GeneratedField::Database),
11796 "schema" => Ok(GeneratedField::Schema),
11797 "table" => Ok(GeneratedField::Table),
11798 "index" => Ok(GeneratedField::Index),
11799 "source" => Ok(GeneratedField::Source),
11800 "sink" => Ok(GeneratedField::Sink),
11801 "view" => Ok(GeneratedField::View),
11802 "function" => Ok(GeneratedField::Function),
11803 "connection" => Ok(GeneratedField::Connection),
11804 "subscription" => Ok(GeneratedField::Subscription),
11805 "secret" => Ok(GeneratedField::Secret),
11806 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11807 }
11808 }
11809 }
11810 deserializer.deserialize_identifier(GeneratedVisitor)
11811 }
11812 }
11813 struct GeneratedVisitor;
11814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11815 type Value = Object;
11816
11817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11818 formatter.write_str("struct meta.Object")
11819 }
11820
11821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
11822 where
11823 V: serde::de::MapAccess<'de>,
11824 {
11825 let mut object_info__ = None;
11826 while let Some(k) = map_.next_key()? {
11827 match k {
11828 GeneratedField::Database => {
11829 if object_info__.is_some() {
11830 return Err(serde::de::Error::duplicate_field("database"));
11831 }
11832 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
11833;
11834 }
11835 GeneratedField::Schema => {
11836 if object_info__.is_some() {
11837 return Err(serde::de::Error::duplicate_field("schema"));
11838 }
11839 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
11840;
11841 }
11842 GeneratedField::Table => {
11843 if object_info__.is_some() {
11844 return Err(serde::de::Error::duplicate_field("table"));
11845 }
11846 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
11847;
11848 }
11849 GeneratedField::Index => {
11850 if object_info__.is_some() {
11851 return Err(serde::de::Error::duplicate_field("index"));
11852 }
11853 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
11854;
11855 }
11856 GeneratedField::Source => {
11857 if object_info__.is_some() {
11858 return Err(serde::de::Error::duplicate_field("source"));
11859 }
11860 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
11861;
11862 }
11863 GeneratedField::Sink => {
11864 if object_info__.is_some() {
11865 return Err(serde::de::Error::duplicate_field("sink"));
11866 }
11867 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
11868;
11869 }
11870 GeneratedField::View => {
11871 if object_info__.is_some() {
11872 return Err(serde::de::Error::duplicate_field("view"));
11873 }
11874 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
11875;
11876 }
11877 GeneratedField::Function => {
11878 if object_info__.is_some() {
11879 return Err(serde::de::Error::duplicate_field("function"));
11880 }
11881 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
11882;
11883 }
11884 GeneratedField::Connection => {
11885 if object_info__.is_some() {
11886 return Err(serde::de::Error::duplicate_field("connection"));
11887 }
11888 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
11889;
11890 }
11891 GeneratedField::Subscription => {
11892 if object_info__.is_some() {
11893 return Err(serde::de::Error::duplicate_field("subscription"));
11894 }
11895 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
11896;
11897 }
11898 GeneratedField::Secret => {
11899 if object_info__.is_some() {
11900 return Err(serde::de::Error::duplicate_field("secret"));
11901 }
11902 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
11903;
11904 }
11905 }
11906 }
11907 Ok(Object {
11908 object_info: object_info__,
11909 })
11910 }
11911 }
11912 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
11913 }
11914}
11915impl serde::Serialize for ObjectGroup {
11916 #[allow(deprecated)]
11917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11918 where
11919 S: serde::Serializer,
11920 {
11921 use serde::ser::SerializeStruct;
11922 let mut len = 0;
11923 if !self.objects.is_empty() {
11924 len += 1;
11925 }
11926 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
11927 if !self.objects.is_empty() {
11928 struct_ser.serialize_field("objects", &self.objects)?;
11929 }
11930 struct_ser.end()
11931 }
11932}
11933impl<'de> serde::Deserialize<'de> for ObjectGroup {
11934 #[allow(deprecated)]
11935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11936 where
11937 D: serde::Deserializer<'de>,
11938 {
11939 const FIELDS: &[&str] = &[
11940 "objects",
11941 ];
11942
11943 #[allow(clippy::enum_variant_names)]
11944 enum GeneratedField {
11945 Objects,
11946 }
11947 impl<'de> serde::Deserialize<'de> for GeneratedField {
11948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11949 where
11950 D: serde::Deserializer<'de>,
11951 {
11952 struct GeneratedVisitor;
11953
11954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11955 type Value = GeneratedField;
11956
11957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11958 write!(formatter, "expected one of: {:?}", &FIELDS)
11959 }
11960
11961 #[allow(unused_variables)]
11962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11963 where
11964 E: serde::de::Error,
11965 {
11966 match value {
11967 "objects" => Ok(GeneratedField::Objects),
11968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11969 }
11970 }
11971 }
11972 deserializer.deserialize_identifier(GeneratedVisitor)
11973 }
11974 }
11975 struct GeneratedVisitor;
11976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11977 type Value = ObjectGroup;
11978
11979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11980 formatter.write_str("struct meta.ObjectGroup")
11981 }
11982
11983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
11984 where
11985 V: serde::de::MapAccess<'de>,
11986 {
11987 let mut objects__ = None;
11988 while let Some(k) = map_.next_key()? {
11989 match k {
11990 GeneratedField::Objects => {
11991 if objects__.is_some() {
11992 return Err(serde::de::Error::duplicate_field("objects"));
11993 }
11994 objects__ = Some(map_.next_value()?);
11995 }
11996 }
11997 }
11998 Ok(ObjectGroup {
11999 objects: objects__.unwrap_or_default(),
12000 })
12001 }
12002 }
12003 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12004 }
12005}
12006impl serde::Serialize for PauseRequest {
12007 #[allow(deprecated)]
12008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12009 where
12010 S: serde::Serializer,
12011 {
12012 use serde::ser::SerializeStruct;
12013 let len = 0;
12014 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12015 struct_ser.end()
12016 }
12017}
12018impl<'de> serde::Deserialize<'de> for PauseRequest {
12019 #[allow(deprecated)]
12020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12021 where
12022 D: serde::Deserializer<'de>,
12023 {
12024 const FIELDS: &[&str] = &[
12025 ];
12026
12027 #[allow(clippy::enum_variant_names)]
12028 enum GeneratedField {
12029 }
12030 impl<'de> serde::Deserialize<'de> for GeneratedField {
12031 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12032 where
12033 D: serde::Deserializer<'de>,
12034 {
12035 struct GeneratedVisitor;
12036
12037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12038 type Value = GeneratedField;
12039
12040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12041 write!(formatter, "expected one of: {:?}", &FIELDS)
12042 }
12043
12044 #[allow(unused_variables)]
12045 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12046 where
12047 E: serde::de::Error,
12048 {
12049 Err(serde::de::Error::unknown_field(value, FIELDS))
12050 }
12051 }
12052 deserializer.deserialize_identifier(GeneratedVisitor)
12053 }
12054 }
12055 struct GeneratedVisitor;
12056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12057 type Value = PauseRequest;
12058
12059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12060 formatter.write_str("struct meta.PauseRequest")
12061 }
12062
12063 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12064 where
12065 V: serde::de::MapAccess<'de>,
12066 {
12067 while map_.next_key::<GeneratedField>()?.is_some() {
12068 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12069 }
12070 Ok(PauseRequest {
12071 })
12072 }
12073 }
12074 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12075 }
12076}
12077impl serde::Serialize for PauseResponse {
12078 #[allow(deprecated)]
12079 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12080 where
12081 S: serde::Serializer,
12082 {
12083 use serde::ser::SerializeStruct;
12084 let len = 0;
12085 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12086 struct_ser.end()
12087 }
12088}
12089impl<'de> serde::Deserialize<'de> for PauseResponse {
12090 #[allow(deprecated)]
12091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12092 where
12093 D: serde::Deserializer<'de>,
12094 {
12095 const FIELDS: &[&str] = &[
12096 ];
12097
12098 #[allow(clippy::enum_variant_names)]
12099 enum GeneratedField {
12100 }
12101 impl<'de> serde::Deserialize<'de> for GeneratedField {
12102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12103 where
12104 D: serde::Deserializer<'de>,
12105 {
12106 struct GeneratedVisitor;
12107
12108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12109 type Value = GeneratedField;
12110
12111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12112 write!(formatter, "expected one of: {:?}", &FIELDS)
12113 }
12114
12115 #[allow(unused_variables)]
12116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12117 where
12118 E: serde::de::Error,
12119 {
12120 Err(serde::de::Error::unknown_field(value, FIELDS))
12121 }
12122 }
12123 deserializer.deserialize_identifier(GeneratedVisitor)
12124 }
12125 }
12126 struct GeneratedVisitor;
12127 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12128 type Value = PauseResponse;
12129
12130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12131 formatter.write_str("struct meta.PauseResponse")
12132 }
12133
12134 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12135 where
12136 V: serde::de::MapAccess<'de>,
12137 {
12138 while map_.next_key::<GeneratedField>()?.is_some() {
12139 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12140 }
12141 Ok(PauseResponse {
12142 })
12143 }
12144 }
12145 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12146 }
12147}
12148impl serde::Serialize for RecoverRequest {
12149 #[allow(deprecated)]
12150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12151 where
12152 S: serde::Serializer,
12153 {
12154 use serde::ser::SerializeStruct;
12155 let len = 0;
12156 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12157 struct_ser.end()
12158 }
12159}
12160impl<'de> serde::Deserialize<'de> for RecoverRequest {
12161 #[allow(deprecated)]
12162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12163 where
12164 D: serde::Deserializer<'de>,
12165 {
12166 const FIELDS: &[&str] = &[
12167 ];
12168
12169 #[allow(clippy::enum_variant_names)]
12170 enum GeneratedField {
12171 }
12172 impl<'de> serde::Deserialize<'de> for GeneratedField {
12173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12174 where
12175 D: serde::Deserializer<'de>,
12176 {
12177 struct GeneratedVisitor;
12178
12179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12180 type Value = GeneratedField;
12181
12182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12183 write!(formatter, "expected one of: {:?}", &FIELDS)
12184 }
12185
12186 #[allow(unused_variables)]
12187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12188 where
12189 E: serde::de::Error,
12190 {
12191 Err(serde::de::Error::unknown_field(value, FIELDS))
12192 }
12193 }
12194 deserializer.deserialize_identifier(GeneratedVisitor)
12195 }
12196 }
12197 struct GeneratedVisitor;
12198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12199 type Value = RecoverRequest;
12200
12201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12202 formatter.write_str("struct meta.RecoverRequest")
12203 }
12204
12205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12206 where
12207 V: serde::de::MapAccess<'de>,
12208 {
12209 while map_.next_key::<GeneratedField>()?.is_some() {
12210 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12211 }
12212 Ok(RecoverRequest {
12213 })
12214 }
12215 }
12216 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12217 }
12218}
12219impl serde::Serialize for RecoverResponse {
12220 #[allow(deprecated)]
12221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12222 where
12223 S: serde::Serializer,
12224 {
12225 use serde::ser::SerializeStruct;
12226 let len = 0;
12227 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12228 struct_ser.end()
12229 }
12230}
12231impl<'de> serde::Deserialize<'de> for RecoverResponse {
12232 #[allow(deprecated)]
12233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12234 where
12235 D: serde::Deserializer<'de>,
12236 {
12237 const FIELDS: &[&str] = &[
12238 ];
12239
12240 #[allow(clippy::enum_variant_names)]
12241 enum GeneratedField {
12242 }
12243 impl<'de> serde::Deserialize<'de> for GeneratedField {
12244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12245 where
12246 D: serde::Deserializer<'de>,
12247 {
12248 struct GeneratedVisitor;
12249
12250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12251 type Value = GeneratedField;
12252
12253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12254 write!(formatter, "expected one of: {:?}", &FIELDS)
12255 }
12256
12257 #[allow(unused_variables)]
12258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12259 where
12260 E: serde::de::Error,
12261 {
12262 Err(serde::de::Error::unknown_field(value, FIELDS))
12263 }
12264 }
12265 deserializer.deserialize_identifier(GeneratedVisitor)
12266 }
12267 }
12268 struct GeneratedVisitor;
12269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12270 type Value = RecoverResponse;
12271
12272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12273 formatter.write_str("struct meta.RecoverResponse")
12274 }
12275
12276 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12277 where
12278 V: serde::de::MapAccess<'de>,
12279 {
12280 while map_.next_key::<GeneratedField>()?.is_some() {
12281 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12282 }
12283 Ok(RecoverResponse {
12284 })
12285 }
12286 }
12287 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12288 }
12289}
12290impl serde::Serialize for Recovery {
12291 #[allow(deprecated)]
12292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12293 where
12294 S: serde::Serializer,
12295 {
12296 use serde::ser::SerializeStruct;
12297 let len = 0;
12298 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12299 struct_ser.end()
12300 }
12301}
12302impl<'de> serde::Deserialize<'de> for Recovery {
12303 #[allow(deprecated)]
12304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12305 where
12306 D: serde::Deserializer<'de>,
12307 {
12308 const FIELDS: &[&str] = &[
12309 ];
12310
12311 #[allow(clippy::enum_variant_names)]
12312 enum GeneratedField {
12313 }
12314 impl<'de> serde::Deserialize<'de> for GeneratedField {
12315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12316 where
12317 D: serde::Deserializer<'de>,
12318 {
12319 struct GeneratedVisitor;
12320
12321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12322 type Value = GeneratedField;
12323
12324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12325 write!(formatter, "expected one of: {:?}", &FIELDS)
12326 }
12327
12328 #[allow(unused_variables)]
12329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12330 where
12331 E: serde::de::Error,
12332 {
12333 Err(serde::de::Error::unknown_field(value, FIELDS))
12334 }
12335 }
12336 deserializer.deserialize_identifier(GeneratedVisitor)
12337 }
12338 }
12339 struct GeneratedVisitor;
12340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12341 type Value = Recovery;
12342
12343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12344 formatter.write_str("struct meta.Recovery")
12345 }
12346
12347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
12348 where
12349 V: serde::de::MapAccess<'de>,
12350 {
12351 while map_.next_key::<GeneratedField>()?.is_some() {
12352 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12353 }
12354 Ok(Recovery {
12355 })
12356 }
12357 }
12358 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
12359 }
12360}
12361impl serde::Serialize for RecoveryStatus {
12362 #[allow(deprecated)]
12363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12364 where
12365 S: serde::Serializer,
12366 {
12367 let variant = match self {
12368 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
12369 Self::StatusStarting => "STATUS_STARTING",
12370 Self::StatusRecovering => "STATUS_RECOVERING",
12371 Self::StatusRunning => "STATUS_RUNNING",
12372 };
12373 serializer.serialize_str(variant)
12374 }
12375}
12376impl<'de> serde::Deserialize<'de> for RecoveryStatus {
12377 #[allow(deprecated)]
12378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12379 where
12380 D: serde::Deserializer<'de>,
12381 {
12382 const FIELDS: &[&str] = &[
12383 "STATUS_UNSPECIFIED",
12384 "STATUS_STARTING",
12385 "STATUS_RECOVERING",
12386 "STATUS_RUNNING",
12387 ];
12388
12389 struct GeneratedVisitor;
12390
12391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12392 type Value = RecoveryStatus;
12393
12394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12395 write!(formatter, "expected one of: {:?}", &FIELDS)
12396 }
12397
12398 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12399 where
12400 E: serde::de::Error,
12401 {
12402 i32::try_from(v)
12403 .ok()
12404 .and_then(|x| x.try_into().ok())
12405 .ok_or_else(|| {
12406 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12407 })
12408 }
12409
12410 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12411 where
12412 E: serde::de::Error,
12413 {
12414 i32::try_from(v)
12415 .ok()
12416 .and_then(|x| x.try_into().ok())
12417 .ok_or_else(|| {
12418 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12419 })
12420 }
12421
12422 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12423 where
12424 E: serde::de::Error,
12425 {
12426 match value {
12427 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
12428 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
12429 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
12430 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
12431 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12432 }
12433 }
12434 }
12435 deserializer.deserialize_any(GeneratedVisitor)
12436 }
12437}
12438impl serde::Serialize for RelationIdInfos {
12439 #[allow(deprecated)]
12440 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12441 where
12442 S: serde::Serializer,
12443 {
12444 use serde::ser::SerializeStruct;
12445 let mut len = 0;
12446 if !self.map.is_empty() {
12447 len += 1;
12448 }
12449 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
12450 if !self.map.is_empty() {
12451 struct_ser.serialize_field("map", &self.map)?;
12452 }
12453 struct_ser.end()
12454 }
12455}
12456impl<'de> serde::Deserialize<'de> for RelationIdInfos {
12457 #[allow(deprecated)]
12458 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12459 where
12460 D: serde::Deserializer<'de>,
12461 {
12462 const FIELDS: &[&str] = &[
12463 "map",
12464 ];
12465
12466 #[allow(clippy::enum_variant_names)]
12467 enum GeneratedField {
12468 Map,
12469 }
12470 impl<'de> serde::Deserialize<'de> for GeneratedField {
12471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12472 where
12473 D: serde::Deserializer<'de>,
12474 {
12475 struct GeneratedVisitor;
12476
12477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12478 type Value = GeneratedField;
12479
12480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12481 write!(formatter, "expected one of: {:?}", &FIELDS)
12482 }
12483
12484 #[allow(unused_variables)]
12485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12486 where
12487 E: serde::de::Error,
12488 {
12489 match value {
12490 "map" => Ok(GeneratedField::Map),
12491 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12492 }
12493 }
12494 }
12495 deserializer.deserialize_identifier(GeneratedVisitor)
12496 }
12497 }
12498 struct GeneratedVisitor;
12499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12500 type Value = RelationIdInfos;
12501
12502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12503 formatter.write_str("struct meta.RelationIdInfos")
12504 }
12505
12506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
12507 where
12508 V: serde::de::MapAccess<'de>,
12509 {
12510 let mut map__ = None;
12511 while let Some(k) = map_.next_key()? {
12512 match k {
12513 GeneratedField::Map => {
12514 if map__.is_some() {
12515 return Err(serde::de::Error::duplicate_field("map"));
12516 }
12517 map__ = Some(
12518 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12519 .into_iter().map(|(k,v)| (k.0, v)).collect()
12520 );
12521 }
12522 }
12523 }
12524 Ok(RelationIdInfos {
12525 map: map__.unwrap_or_default(),
12526 })
12527 }
12528 }
12529 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
12530 }
12531}
12532impl serde::Serialize for RescheduleRequest {
12533 #[allow(deprecated)]
12534 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12535 where
12536 S: serde::Serializer,
12537 {
12538 use serde::ser::SerializeStruct;
12539 let mut len = 0;
12540 if self.revision != 0 {
12541 len += 1;
12542 }
12543 if self.resolve_no_shuffle_upstream {
12544 len += 1;
12545 }
12546 if !self.worker_reschedules.is_empty() {
12547 len += 1;
12548 }
12549 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
12550 if self.revision != 0 {
12551 #[allow(clippy::needless_borrow)]
12552 #[allow(clippy::needless_borrows_for_generic_args)]
12553 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12554 }
12555 if self.resolve_no_shuffle_upstream {
12556 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
12557 }
12558 if !self.worker_reschedules.is_empty() {
12559 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
12560 }
12561 struct_ser.end()
12562 }
12563}
12564impl<'de> serde::Deserialize<'de> for RescheduleRequest {
12565 #[allow(deprecated)]
12566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12567 where
12568 D: serde::Deserializer<'de>,
12569 {
12570 const FIELDS: &[&str] = &[
12571 "revision",
12572 "resolve_no_shuffle_upstream",
12573 "resolveNoShuffleUpstream",
12574 "worker_reschedules",
12575 "workerReschedules",
12576 ];
12577
12578 #[allow(clippy::enum_variant_names)]
12579 enum GeneratedField {
12580 Revision,
12581 ResolveNoShuffleUpstream,
12582 WorkerReschedules,
12583 }
12584 impl<'de> serde::Deserialize<'de> for GeneratedField {
12585 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12586 where
12587 D: serde::Deserializer<'de>,
12588 {
12589 struct GeneratedVisitor;
12590
12591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12592 type Value = GeneratedField;
12593
12594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12595 write!(formatter, "expected one of: {:?}", &FIELDS)
12596 }
12597
12598 #[allow(unused_variables)]
12599 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12600 where
12601 E: serde::de::Error,
12602 {
12603 match value {
12604 "revision" => Ok(GeneratedField::Revision),
12605 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
12606 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
12607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12608 }
12609 }
12610 }
12611 deserializer.deserialize_identifier(GeneratedVisitor)
12612 }
12613 }
12614 struct GeneratedVisitor;
12615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12616 type Value = RescheduleRequest;
12617
12618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12619 formatter.write_str("struct meta.RescheduleRequest")
12620 }
12621
12622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
12623 where
12624 V: serde::de::MapAccess<'de>,
12625 {
12626 let mut revision__ = None;
12627 let mut resolve_no_shuffle_upstream__ = None;
12628 let mut worker_reschedules__ = None;
12629 while let Some(k) = map_.next_key()? {
12630 match k {
12631 GeneratedField::Revision => {
12632 if revision__.is_some() {
12633 return Err(serde::de::Error::duplicate_field("revision"));
12634 }
12635 revision__ =
12636 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12637 ;
12638 }
12639 GeneratedField::ResolveNoShuffleUpstream => {
12640 if resolve_no_shuffle_upstream__.is_some() {
12641 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
12642 }
12643 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
12644 }
12645 GeneratedField::WorkerReschedules => {
12646 if worker_reschedules__.is_some() {
12647 return Err(serde::de::Error::duplicate_field("workerReschedules"));
12648 }
12649 worker_reschedules__ = Some(
12650 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12651 .into_iter().map(|(k,v)| (k.0, v)).collect()
12652 );
12653 }
12654 }
12655 }
12656 Ok(RescheduleRequest {
12657 revision: revision__.unwrap_or_default(),
12658 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
12659 worker_reschedules: worker_reschedules__.unwrap_or_default(),
12660 })
12661 }
12662 }
12663 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
12664 }
12665}
12666impl serde::Serialize for RescheduleResponse {
12667 #[allow(deprecated)]
12668 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12669 where
12670 S: serde::Serializer,
12671 {
12672 use serde::ser::SerializeStruct;
12673 let mut len = 0;
12674 if self.success {
12675 len += 1;
12676 }
12677 if self.revision != 0 {
12678 len += 1;
12679 }
12680 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
12681 if self.success {
12682 struct_ser.serialize_field("success", &self.success)?;
12683 }
12684 if self.revision != 0 {
12685 #[allow(clippy::needless_borrow)]
12686 #[allow(clippy::needless_borrows_for_generic_args)]
12687 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12688 }
12689 struct_ser.end()
12690 }
12691}
12692impl<'de> serde::Deserialize<'de> for RescheduleResponse {
12693 #[allow(deprecated)]
12694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12695 where
12696 D: serde::Deserializer<'de>,
12697 {
12698 const FIELDS: &[&str] = &[
12699 "success",
12700 "revision",
12701 ];
12702
12703 #[allow(clippy::enum_variant_names)]
12704 enum GeneratedField {
12705 Success,
12706 Revision,
12707 }
12708 impl<'de> serde::Deserialize<'de> for GeneratedField {
12709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12710 where
12711 D: serde::Deserializer<'de>,
12712 {
12713 struct GeneratedVisitor;
12714
12715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12716 type Value = GeneratedField;
12717
12718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12719 write!(formatter, "expected one of: {:?}", &FIELDS)
12720 }
12721
12722 #[allow(unused_variables)]
12723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12724 where
12725 E: serde::de::Error,
12726 {
12727 match value {
12728 "success" => Ok(GeneratedField::Success),
12729 "revision" => Ok(GeneratedField::Revision),
12730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12731 }
12732 }
12733 }
12734 deserializer.deserialize_identifier(GeneratedVisitor)
12735 }
12736 }
12737 struct GeneratedVisitor;
12738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12739 type Value = RescheduleResponse;
12740
12741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12742 formatter.write_str("struct meta.RescheduleResponse")
12743 }
12744
12745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
12746 where
12747 V: serde::de::MapAccess<'de>,
12748 {
12749 let mut success__ = None;
12750 let mut revision__ = None;
12751 while let Some(k) = map_.next_key()? {
12752 match k {
12753 GeneratedField::Success => {
12754 if success__.is_some() {
12755 return Err(serde::de::Error::duplicate_field("success"));
12756 }
12757 success__ = Some(map_.next_value()?);
12758 }
12759 GeneratedField::Revision => {
12760 if revision__.is_some() {
12761 return Err(serde::de::Error::duplicate_field("revision"));
12762 }
12763 revision__ =
12764 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12765 ;
12766 }
12767 }
12768 }
12769 Ok(RescheduleResponse {
12770 success: success__.unwrap_or_default(),
12771 revision: revision__.unwrap_or_default(),
12772 })
12773 }
12774 }
12775 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
12776 }
12777}
12778impl serde::Serialize for ResumeRequest {
12779 #[allow(deprecated)]
12780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12781 where
12782 S: serde::Serializer,
12783 {
12784 use serde::ser::SerializeStruct;
12785 let len = 0;
12786 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
12787 struct_ser.end()
12788 }
12789}
12790impl<'de> serde::Deserialize<'de> for ResumeRequest {
12791 #[allow(deprecated)]
12792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12793 where
12794 D: serde::Deserializer<'de>,
12795 {
12796 const FIELDS: &[&str] = &[
12797 ];
12798
12799 #[allow(clippy::enum_variant_names)]
12800 enum GeneratedField {
12801 }
12802 impl<'de> serde::Deserialize<'de> for GeneratedField {
12803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12804 where
12805 D: serde::Deserializer<'de>,
12806 {
12807 struct GeneratedVisitor;
12808
12809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12810 type Value = GeneratedField;
12811
12812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12813 write!(formatter, "expected one of: {:?}", &FIELDS)
12814 }
12815
12816 #[allow(unused_variables)]
12817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12818 where
12819 E: serde::de::Error,
12820 {
12821 Err(serde::de::Error::unknown_field(value, FIELDS))
12822 }
12823 }
12824 deserializer.deserialize_identifier(GeneratedVisitor)
12825 }
12826 }
12827 struct GeneratedVisitor;
12828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12829 type Value = ResumeRequest;
12830
12831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12832 formatter.write_str("struct meta.ResumeRequest")
12833 }
12834
12835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
12836 where
12837 V: serde::de::MapAccess<'de>,
12838 {
12839 while map_.next_key::<GeneratedField>()?.is_some() {
12840 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12841 }
12842 Ok(ResumeRequest {
12843 })
12844 }
12845 }
12846 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
12847 }
12848}
12849impl serde::Serialize for ResumeResponse {
12850 #[allow(deprecated)]
12851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12852 where
12853 S: serde::Serializer,
12854 {
12855 use serde::ser::SerializeStruct;
12856 let len = 0;
12857 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
12858 struct_ser.end()
12859 }
12860}
12861impl<'de> serde::Deserialize<'de> for ResumeResponse {
12862 #[allow(deprecated)]
12863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12864 where
12865 D: serde::Deserializer<'de>,
12866 {
12867 const FIELDS: &[&str] = &[
12868 ];
12869
12870 #[allow(clippy::enum_variant_names)]
12871 enum GeneratedField {
12872 }
12873 impl<'de> serde::Deserialize<'de> for GeneratedField {
12874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12875 where
12876 D: serde::Deserializer<'de>,
12877 {
12878 struct GeneratedVisitor;
12879
12880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12881 type Value = GeneratedField;
12882
12883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12884 write!(formatter, "expected one of: {:?}", &FIELDS)
12885 }
12886
12887 #[allow(unused_variables)]
12888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12889 where
12890 E: serde::de::Error,
12891 {
12892 Err(serde::de::Error::unknown_field(value, FIELDS))
12893 }
12894 }
12895 deserializer.deserialize_identifier(GeneratedVisitor)
12896 }
12897 }
12898 struct GeneratedVisitor;
12899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12900 type Value = ResumeResponse;
12901
12902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12903 formatter.write_str("struct meta.ResumeResponse")
12904 }
12905
12906 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
12907 where
12908 V: serde::de::MapAccess<'de>,
12909 {
12910 while map_.next_key::<GeneratedField>()?.is_some() {
12911 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12912 }
12913 Ok(ResumeResponse {
12914 })
12915 }
12916 }
12917 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
12918 }
12919}
12920impl serde::Serialize for SetSessionParamRequest {
12921 #[allow(deprecated)]
12922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12923 where
12924 S: serde::Serializer,
12925 {
12926 use serde::ser::SerializeStruct;
12927 let mut len = 0;
12928 if !self.param.is_empty() {
12929 len += 1;
12930 }
12931 if self.value.is_some() {
12932 len += 1;
12933 }
12934 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
12935 if !self.param.is_empty() {
12936 struct_ser.serialize_field("param", &self.param)?;
12937 }
12938 if let Some(v) = self.value.as_ref() {
12939 struct_ser.serialize_field("value", v)?;
12940 }
12941 struct_ser.end()
12942 }
12943}
12944impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
12945 #[allow(deprecated)]
12946 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12947 where
12948 D: serde::Deserializer<'de>,
12949 {
12950 const FIELDS: &[&str] = &[
12951 "param",
12952 "value",
12953 ];
12954
12955 #[allow(clippy::enum_variant_names)]
12956 enum GeneratedField {
12957 Param,
12958 Value,
12959 }
12960 impl<'de> serde::Deserialize<'de> for GeneratedField {
12961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12962 where
12963 D: serde::Deserializer<'de>,
12964 {
12965 struct GeneratedVisitor;
12966
12967 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12968 type Value = GeneratedField;
12969
12970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12971 write!(formatter, "expected one of: {:?}", &FIELDS)
12972 }
12973
12974 #[allow(unused_variables)]
12975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12976 where
12977 E: serde::de::Error,
12978 {
12979 match value {
12980 "param" => Ok(GeneratedField::Param),
12981 "value" => Ok(GeneratedField::Value),
12982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12983 }
12984 }
12985 }
12986 deserializer.deserialize_identifier(GeneratedVisitor)
12987 }
12988 }
12989 struct GeneratedVisitor;
12990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12991 type Value = SetSessionParamRequest;
12992
12993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12994 formatter.write_str("struct meta.SetSessionParamRequest")
12995 }
12996
12997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
12998 where
12999 V: serde::de::MapAccess<'de>,
13000 {
13001 let mut param__ = None;
13002 let mut value__ = None;
13003 while let Some(k) = map_.next_key()? {
13004 match k {
13005 GeneratedField::Param => {
13006 if param__.is_some() {
13007 return Err(serde::de::Error::duplicate_field("param"));
13008 }
13009 param__ = Some(map_.next_value()?);
13010 }
13011 GeneratedField::Value => {
13012 if value__.is_some() {
13013 return Err(serde::de::Error::duplicate_field("value"));
13014 }
13015 value__ = map_.next_value()?;
13016 }
13017 }
13018 }
13019 Ok(SetSessionParamRequest {
13020 param: param__.unwrap_or_default(),
13021 value: value__,
13022 })
13023 }
13024 }
13025 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13026 }
13027}
13028impl serde::Serialize for SetSessionParamResponse {
13029 #[allow(deprecated)]
13030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13031 where
13032 S: serde::Serializer,
13033 {
13034 use serde::ser::SerializeStruct;
13035 let mut len = 0;
13036 if !self.param.is_empty() {
13037 len += 1;
13038 }
13039 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13040 if !self.param.is_empty() {
13041 struct_ser.serialize_field("param", &self.param)?;
13042 }
13043 struct_ser.end()
13044 }
13045}
13046impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13047 #[allow(deprecated)]
13048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13049 where
13050 D: serde::Deserializer<'de>,
13051 {
13052 const FIELDS: &[&str] = &[
13053 "param",
13054 ];
13055
13056 #[allow(clippy::enum_variant_names)]
13057 enum GeneratedField {
13058 Param,
13059 }
13060 impl<'de> serde::Deserialize<'de> for GeneratedField {
13061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13062 where
13063 D: serde::Deserializer<'de>,
13064 {
13065 struct GeneratedVisitor;
13066
13067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13068 type Value = GeneratedField;
13069
13070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13071 write!(formatter, "expected one of: {:?}", &FIELDS)
13072 }
13073
13074 #[allow(unused_variables)]
13075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13076 where
13077 E: serde::de::Error,
13078 {
13079 match value {
13080 "param" => Ok(GeneratedField::Param),
13081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13082 }
13083 }
13084 }
13085 deserializer.deserialize_identifier(GeneratedVisitor)
13086 }
13087 }
13088 struct GeneratedVisitor;
13089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13090 type Value = SetSessionParamResponse;
13091
13092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13093 formatter.write_str("struct meta.SetSessionParamResponse")
13094 }
13095
13096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13097 where
13098 V: serde::de::MapAccess<'de>,
13099 {
13100 let mut param__ = None;
13101 while let Some(k) = map_.next_key()? {
13102 match k {
13103 GeneratedField::Param => {
13104 if param__.is_some() {
13105 return Err(serde::de::Error::duplicate_field("param"));
13106 }
13107 param__ = Some(map_.next_value()?);
13108 }
13109 }
13110 }
13111 Ok(SetSessionParamResponse {
13112 param: param__.unwrap_or_default(),
13113 })
13114 }
13115 }
13116 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13117 }
13118}
13119impl serde::Serialize for SetSystemParamRequest {
13120 #[allow(deprecated)]
13121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13122 where
13123 S: serde::Serializer,
13124 {
13125 use serde::ser::SerializeStruct;
13126 let mut len = 0;
13127 if !self.param.is_empty() {
13128 len += 1;
13129 }
13130 if self.value.is_some() {
13131 len += 1;
13132 }
13133 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
13134 if !self.param.is_empty() {
13135 struct_ser.serialize_field("param", &self.param)?;
13136 }
13137 if let Some(v) = self.value.as_ref() {
13138 struct_ser.serialize_field("value", v)?;
13139 }
13140 struct_ser.end()
13141 }
13142}
13143impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
13144 #[allow(deprecated)]
13145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13146 where
13147 D: serde::Deserializer<'de>,
13148 {
13149 const FIELDS: &[&str] = &[
13150 "param",
13151 "value",
13152 ];
13153
13154 #[allow(clippy::enum_variant_names)]
13155 enum GeneratedField {
13156 Param,
13157 Value,
13158 }
13159 impl<'de> serde::Deserialize<'de> for GeneratedField {
13160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13161 where
13162 D: serde::Deserializer<'de>,
13163 {
13164 struct GeneratedVisitor;
13165
13166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13167 type Value = GeneratedField;
13168
13169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13170 write!(formatter, "expected one of: {:?}", &FIELDS)
13171 }
13172
13173 #[allow(unused_variables)]
13174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13175 where
13176 E: serde::de::Error,
13177 {
13178 match value {
13179 "param" => Ok(GeneratedField::Param),
13180 "value" => Ok(GeneratedField::Value),
13181 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13182 }
13183 }
13184 }
13185 deserializer.deserialize_identifier(GeneratedVisitor)
13186 }
13187 }
13188 struct GeneratedVisitor;
13189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13190 type Value = SetSystemParamRequest;
13191
13192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13193 formatter.write_str("struct meta.SetSystemParamRequest")
13194 }
13195
13196 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
13197 where
13198 V: serde::de::MapAccess<'de>,
13199 {
13200 let mut param__ = None;
13201 let mut value__ = None;
13202 while let Some(k) = map_.next_key()? {
13203 match k {
13204 GeneratedField::Param => {
13205 if param__.is_some() {
13206 return Err(serde::de::Error::duplicate_field("param"));
13207 }
13208 param__ = Some(map_.next_value()?);
13209 }
13210 GeneratedField::Value => {
13211 if value__.is_some() {
13212 return Err(serde::de::Error::duplicate_field("value"));
13213 }
13214 value__ = map_.next_value()?;
13215 }
13216 }
13217 }
13218 Ok(SetSystemParamRequest {
13219 param: param__.unwrap_or_default(),
13220 value: value__,
13221 })
13222 }
13223 }
13224 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
13225 }
13226}
13227impl serde::Serialize for SetSystemParamResponse {
13228 #[allow(deprecated)]
13229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13230 where
13231 S: serde::Serializer,
13232 {
13233 use serde::ser::SerializeStruct;
13234 let mut len = 0;
13235 if self.params.is_some() {
13236 len += 1;
13237 }
13238 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
13239 if let Some(v) = self.params.as_ref() {
13240 struct_ser.serialize_field("params", v)?;
13241 }
13242 struct_ser.end()
13243 }
13244}
13245impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
13246 #[allow(deprecated)]
13247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13248 where
13249 D: serde::Deserializer<'de>,
13250 {
13251 const FIELDS: &[&str] = &[
13252 "params",
13253 ];
13254
13255 #[allow(clippy::enum_variant_names)]
13256 enum GeneratedField {
13257 Params,
13258 }
13259 impl<'de> serde::Deserialize<'de> for GeneratedField {
13260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13261 where
13262 D: serde::Deserializer<'de>,
13263 {
13264 struct GeneratedVisitor;
13265
13266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13267 type Value = GeneratedField;
13268
13269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13270 write!(formatter, "expected one of: {:?}", &FIELDS)
13271 }
13272
13273 #[allow(unused_variables)]
13274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13275 where
13276 E: serde::de::Error,
13277 {
13278 match value {
13279 "params" => Ok(GeneratedField::Params),
13280 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13281 }
13282 }
13283 }
13284 deserializer.deserialize_identifier(GeneratedVisitor)
13285 }
13286 }
13287 struct GeneratedVisitor;
13288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13289 type Value = SetSystemParamResponse;
13290
13291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13292 formatter.write_str("struct meta.SetSystemParamResponse")
13293 }
13294
13295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
13296 where
13297 V: serde::de::MapAccess<'de>,
13298 {
13299 let mut params__ = None;
13300 while let Some(k) = map_.next_key()? {
13301 match k {
13302 GeneratedField::Params => {
13303 if params__.is_some() {
13304 return Err(serde::de::Error::duplicate_field("params"));
13305 }
13306 params__ = map_.next_value()?;
13307 }
13308 }
13309 }
13310 Ok(SetSystemParamResponse {
13311 params: params__,
13312 })
13313 }
13314 }
13315 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
13316 }
13317}
13318impl serde::Serialize for SubscribeRequest {
13319 #[allow(deprecated)]
13320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13321 where
13322 S: serde::Serializer,
13323 {
13324 use serde::ser::SerializeStruct;
13325 let mut len = 0;
13326 if self.subscribe_type != 0 {
13327 len += 1;
13328 }
13329 if self.host.is_some() {
13330 len += 1;
13331 }
13332 if self.worker_id != 0 {
13333 len += 1;
13334 }
13335 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
13336 if self.subscribe_type != 0 {
13337 let v = SubscribeType::try_from(self.subscribe_type)
13338 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
13339 struct_ser.serialize_field("subscribeType", &v)?;
13340 }
13341 if let Some(v) = self.host.as_ref() {
13342 struct_ser.serialize_field("host", v)?;
13343 }
13344 if self.worker_id != 0 {
13345 struct_ser.serialize_field("workerId", &self.worker_id)?;
13346 }
13347 struct_ser.end()
13348 }
13349}
13350impl<'de> serde::Deserialize<'de> for SubscribeRequest {
13351 #[allow(deprecated)]
13352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13353 where
13354 D: serde::Deserializer<'de>,
13355 {
13356 const FIELDS: &[&str] = &[
13357 "subscribe_type",
13358 "subscribeType",
13359 "host",
13360 "worker_id",
13361 "workerId",
13362 ];
13363
13364 #[allow(clippy::enum_variant_names)]
13365 enum GeneratedField {
13366 SubscribeType,
13367 Host,
13368 WorkerId,
13369 }
13370 impl<'de> serde::Deserialize<'de> for GeneratedField {
13371 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13372 where
13373 D: serde::Deserializer<'de>,
13374 {
13375 struct GeneratedVisitor;
13376
13377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13378 type Value = GeneratedField;
13379
13380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13381 write!(formatter, "expected one of: {:?}", &FIELDS)
13382 }
13383
13384 #[allow(unused_variables)]
13385 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13386 where
13387 E: serde::de::Error,
13388 {
13389 match value {
13390 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
13391 "host" => Ok(GeneratedField::Host),
13392 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
13393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13394 }
13395 }
13396 }
13397 deserializer.deserialize_identifier(GeneratedVisitor)
13398 }
13399 }
13400 struct GeneratedVisitor;
13401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13402 type Value = SubscribeRequest;
13403
13404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13405 formatter.write_str("struct meta.SubscribeRequest")
13406 }
13407
13408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
13409 where
13410 V: serde::de::MapAccess<'de>,
13411 {
13412 let mut subscribe_type__ = None;
13413 let mut host__ = None;
13414 let mut worker_id__ = None;
13415 while let Some(k) = map_.next_key()? {
13416 match k {
13417 GeneratedField::SubscribeType => {
13418 if subscribe_type__.is_some() {
13419 return Err(serde::de::Error::duplicate_field("subscribeType"));
13420 }
13421 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
13422 }
13423 GeneratedField::Host => {
13424 if host__.is_some() {
13425 return Err(serde::de::Error::duplicate_field("host"));
13426 }
13427 host__ = map_.next_value()?;
13428 }
13429 GeneratedField::WorkerId => {
13430 if worker_id__.is_some() {
13431 return Err(serde::de::Error::duplicate_field("workerId"));
13432 }
13433 worker_id__ =
13434 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13435 ;
13436 }
13437 }
13438 }
13439 Ok(SubscribeRequest {
13440 subscribe_type: subscribe_type__.unwrap_or_default(),
13441 host: host__,
13442 worker_id: worker_id__.unwrap_or_default(),
13443 })
13444 }
13445 }
13446 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
13447 }
13448}
13449impl serde::Serialize for SubscribeResponse {
13450 #[allow(deprecated)]
13451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13452 where
13453 S: serde::Serializer,
13454 {
13455 use serde::ser::SerializeStruct;
13456 let mut len = 0;
13457 if self.status.is_some() {
13458 len += 1;
13459 }
13460 if self.operation != 0 {
13461 len += 1;
13462 }
13463 if self.version != 0 {
13464 len += 1;
13465 }
13466 if self.info.is_some() {
13467 len += 1;
13468 }
13469 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
13470 if let Some(v) = self.status.as_ref() {
13471 struct_ser.serialize_field("status", v)?;
13472 }
13473 if self.operation != 0 {
13474 let v = subscribe_response::Operation::try_from(self.operation)
13475 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
13476 struct_ser.serialize_field("operation", &v)?;
13477 }
13478 if self.version != 0 {
13479 #[allow(clippy::needless_borrow)]
13480 #[allow(clippy::needless_borrows_for_generic_args)]
13481 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
13482 }
13483 if let Some(v) = self.info.as_ref() {
13484 match v {
13485 subscribe_response::Info::Database(v) => {
13486 struct_ser.serialize_field("database", v)?;
13487 }
13488 subscribe_response::Info::Schema(v) => {
13489 struct_ser.serialize_field("schema", v)?;
13490 }
13491 subscribe_response::Info::Function(v) => {
13492 struct_ser.serialize_field("function", v)?;
13493 }
13494 subscribe_response::Info::User(v) => {
13495 struct_ser.serialize_field("user", v)?;
13496 }
13497 subscribe_response::Info::SessionParam(v) => {
13498 struct_ser.serialize_field("sessionParam", v)?;
13499 }
13500 subscribe_response::Info::Node(v) => {
13501 struct_ser.serialize_field("node", v)?;
13502 }
13503 subscribe_response::Info::HummockVersionDeltas(v) => {
13504 struct_ser.serialize_field("hummockVersionDeltas", v)?;
13505 }
13506 subscribe_response::Info::Snapshot(v) => {
13507 struct_ser.serialize_field("snapshot", v)?;
13508 }
13509 subscribe_response::Info::MetaBackupManifestId(v) => {
13510 struct_ser.serialize_field("metaBackupManifestId", v)?;
13511 }
13512 subscribe_response::Info::SystemParams(v) => {
13513 struct_ser.serialize_field("systemParams", v)?;
13514 }
13515 subscribe_response::Info::HummockWriteLimits(v) => {
13516 struct_ser.serialize_field("hummockWriteLimits", v)?;
13517 }
13518 subscribe_response::Info::ObjectGroup(v) => {
13519 struct_ser.serialize_field("objectGroup", v)?;
13520 }
13521 subscribe_response::Info::Connection(v) => {
13522 struct_ser.serialize_field("connection", v)?;
13523 }
13524 subscribe_response::Info::HummockStats(v) => {
13525 struct_ser.serialize_field("hummockStats", v)?;
13526 }
13527 subscribe_response::Info::Recovery(v) => {
13528 struct_ser.serialize_field("recovery", v)?;
13529 }
13530 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
13531 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
13532 }
13533 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
13534 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
13535 }
13536 subscribe_response::Info::Secret(v) => {
13537 struct_ser.serialize_field("secret", v)?;
13538 }
13539 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
13540 #[allow(clippy::needless_borrow)]
13541 #[allow(clippy::needless_borrows_for_generic_args)]
13542 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
13543 }
13544 }
13545 }
13546 struct_ser.end()
13547 }
13548}
13549impl<'de> serde::Deserialize<'de> for SubscribeResponse {
13550 #[allow(deprecated)]
13551 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13552 where
13553 D: serde::Deserializer<'de>,
13554 {
13555 const FIELDS: &[&str] = &[
13556 "status",
13557 "operation",
13558 "version",
13559 "database",
13560 "schema",
13561 "function",
13562 "user",
13563 "session_param",
13564 "sessionParam",
13565 "node",
13566 "hummock_version_deltas",
13567 "hummockVersionDeltas",
13568 "snapshot",
13569 "meta_backup_manifest_id",
13570 "metaBackupManifestId",
13571 "system_params",
13572 "systemParams",
13573 "hummock_write_limits",
13574 "hummockWriteLimits",
13575 "object_group",
13576 "objectGroup",
13577 "connection",
13578 "hummock_stats",
13579 "hummockStats",
13580 "recovery",
13581 "streaming_worker_slot_mapping",
13582 "streamingWorkerSlotMapping",
13583 "serving_worker_slot_mappings",
13584 "servingWorkerSlotMappings",
13585 "secret",
13586 "compute_node_total_cpu_count",
13587 "computeNodeTotalCpuCount",
13588 ];
13589
13590 #[allow(clippy::enum_variant_names)]
13591 enum GeneratedField {
13592 Status,
13593 Operation,
13594 Version,
13595 Database,
13596 Schema,
13597 Function,
13598 User,
13599 SessionParam,
13600 Node,
13601 HummockVersionDeltas,
13602 Snapshot,
13603 MetaBackupManifestId,
13604 SystemParams,
13605 HummockWriteLimits,
13606 ObjectGroup,
13607 Connection,
13608 HummockStats,
13609 Recovery,
13610 StreamingWorkerSlotMapping,
13611 ServingWorkerSlotMappings,
13612 Secret,
13613 ComputeNodeTotalCpuCount,
13614 }
13615 impl<'de> serde::Deserialize<'de> for GeneratedField {
13616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13617 where
13618 D: serde::Deserializer<'de>,
13619 {
13620 struct GeneratedVisitor;
13621
13622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13623 type Value = GeneratedField;
13624
13625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13626 write!(formatter, "expected one of: {:?}", &FIELDS)
13627 }
13628
13629 #[allow(unused_variables)]
13630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13631 where
13632 E: serde::de::Error,
13633 {
13634 match value {
13635 "status" => Ok(GeneratedField::Status),
13636 "operation" => Ok(GeneratedField::Operation),
13637 "version" => Ok(GeneratedField::Version),
13638 "database" => Ok(GeneratedField::Database),
13639 "schema" => Ok(GeneratedField::Schema),
13640 "function" => Ok(GeneratedField::Function),
13641 "user" => Ok(GeneratedField::User),
13642 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
13643 "node" => Ok(GeneratedField::Node),
13644 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
13645 "snapshot" => Ok(GeneratedField::Snapshot),
13646 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13647 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
13648 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13649 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
13650 "connection" => Ok(GeneratedField::Connection),
13651 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
13652 "recovery" => Ok(GeneratedField::Recovery),
13653 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
13654 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13655 "secret" => Ok(GeneratedField::Secret),
13656 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
13657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13658 }
13659 }
13660 }
13661 deserializer.deserialize_identifier(GeneratedVisitor)
13662 }
13663 }
13664 struct GeneratedVisitor;
13665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13666 type Value = SubscribeResponse;
13667
13668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13669 formatter.write_str("struct meta.SubscribeResponse")
13670 }
13671
13672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
13673 where
13674 V: serde::de::MapAccess<'de>,
13675 {
13676 let mut status__ = None;
13677 let mut operation__ = None;
13678 let mut version__ = None;
13679 let mut info__ = None;
13680 while let Some(k) = map_.next_key()? {
13681 match k {
13682 GeneratedField::Status => {
13683 if status__.is_some() {
13684 return Err(serde::de::Error::duplicate_field("status"));
13685 }
13686 status__ = map_.next_value()?;
13687 }
13688 GeneratedField::Operation => {
13689 if operation__.is_some() {
13690 return Err(serde::de::Error::duplicate_field("operation"));
13691 }
13692 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
13693 }
13694 GeneratedField::Version => {
13695 if version__.is_some() {
13696 return Err(serde::de::Error::duplicate_field("version"));
13697 }
13698 version__ =
13699 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13700 ;
13701 }
13702 GeneratedField::Database => {
13703 if info__.is_some() {
13704 return Err(serde::de::Error::duplicate_field("database"));
13705 }
13706 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
13707;
13708 }
13709 GeneratedField::Schema => {
13710 if info__.is_some() {
13711 return Err(serde::de::Error::duplicate_field("schema"));
13712 }
13713 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
13714;
13715 }
13716 GeneratedField::Function => {
13717 if info__.is_some() {
13718 return Err(serde::de::Error::duplicate_field("function"));
13719 }
13720 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
13721;
13722 }
13723 GeneratedField::User => {
13724 if info__.is_some() {
13725 return Err(serde::de::Error::duplicate_field("user"));
13726 }
13727 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
13728;
13729 }
13730 GeneratedField::SessionParam => {
13731 if info__.is_some() {
13732 return Err(serde::de::Error::duplicate_field("sessionParam"));
13733 }
13734 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
13735;
13736 }
13737 GeneratedField::Node => {
13738 if info__.is_some() {
13739 return Err(serde::de::Error::duplicate_field("node"));
13740 }
13741 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
13742;
13743 }
13744 GeneratedField::HummockVersionDeltas => {
13745 if info__.is_some() {
13746 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
13747 }
13748 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
13749;
13750 }
13751 GeneratedField::Snapshot => {
13752 if info__.is_some() {
13753 return Err(serde::de::Error::duplicate_field("snapshot"));
13754 }
13755 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
13756;
13757 }
13758 GeneratedField::MetaBackupManifestId => {
13759 if info__.is_some() {
13760 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
13761 }
13762 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
13763;
13764 }
13765 GeneratedField::SystemParams => {
13766 if info__.is_some() {
13767 return Err(serde::de::Error::duplicate_field("systemParams"));
13768 }
13769 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
13770;
13771 }
13772 GeneratedField::HummockWriteLimits => {
13773 if info__.is_some() {
13774 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
13775 }
13776 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
13777;
13778 }
13779 GeneratedField::ObjectGroup => {
13780 if info__.is_some() {
13781 return Err(serde::de::Error::duplicate_field("objectGroup"));
13782 }
13783 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
13784;
13785 }
13786 GeneratedField::Connection => {
13787 if info__.is_some() {
13788 return Err(serde::de::Error::duplicate_field("connection"));
13789 }
13790 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
13791;
13792 }
13793 GeneratedField::HummockStats => {
13794 if info__.is_some() {
13795 return Err(serde::de::Error::duplicate_field("hummockStats"));
13796 }
13797 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
13798;
13799 }
13800 GeneratedField::Recovery => {
13801 if info__.is_some() {
13802 return Err(serde::de::Error::duplicate_field("recovery"));
13803 }
13804 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
13805;
13806 }
13807 GeneratedField::StreamingWorkerSlotMapping => {
13808 if info__.is_some() {
13809 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
13810 }
13811 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
13812;
13813 }
13814 GeneratedField::ServingWorkerSlotMappings => {
13815 if info__.is_some() {
13816 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
13817 }
13818 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
13819;
13820 }
13821 GeneratedField::Secret => {
13822 if info__.is_some() {
13823 return Err(serde::de::Error::duplicate_field("secret"));
13824 }
13825 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
13826;
13827 }
13828 GeneratedField::ComputeNodeTotalCpuCount => {
13829 if info__.is_some() {
13830 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
13831 }
13832 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
13833 }
13834 }
13835 }
13836 Ok(SubscribeResponse {
13837 status: status__,
13838 operation: operation__.unwrap_or_default(),
13839 version: version__.unwrap_or_default(),
13840 info: info__,
13841 })
13842 }
13843 }
13844 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
13845 }
13846}
13847impl serde::Serialize for subscribe_response::Operation {
13848 #[allow(deprecated)]
13849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13850 where
13851 S: serde::Serializer,
13852 {
13853 let variant = match self {
13854 Self::Unspecified => "UNSPECIFIED",
13855 Self::Add => "ADD",
13856 Self::Delete => "DELETE",
13857 Self::Update => "UPDATE",
13858 Self::Snapshot => "SNAPSHOT",
13859 };
13860 serializer.serialize_str(variant)
13861 }
13862}
13863impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
13864 #[allow(deprecated)]
13865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13866 where
13867 D: serde::Deserializer<'de>,
13868 {
13869 const FIELDS: &[&str] = &[
13870 "UNSPECIFIED",
13871 "ADD",
13872 "DELETE",
13873 "UPDATE",
13874 "SNAPSHOT",
13875 ];
13876
13877 struct GeneratedVisitor;
13878
13879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13880 type Value = subscribe_response::Operation;
13881
13882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13883 write!(formatter, "expected one of: {:?}", &FIELDS)
13884 }
13885
13886 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13887 where
13888 E: serde::de::Error,
13889 {
13890 i32::try_from(v)
13891 .ok()
13892 .and_then(|x| x.try_into().ok())
13893 .ok_or_else(|| {
13894 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13895 })
13896 }
13897
13898 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13899 where
13900 E: serde::de::Error,
13901 {
13902 i32::try_from(v)
13903 .ok()
13904 .and_then(|x| x.try_into().ok())
13905 .ok_or_else(|| {
13906 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13907 })
13908 }
13909
13910 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13911 where
13912 E: serde::de::Error,
13913 {
13914 match value {
13915 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
13916 "ADD" => Ok(subscribe_response::Operation::Add),
13917 "DELETE" => Ok(subscribe_response::Operation::Delete),
13918 "UPDATE" => Ok(subscribe_response::Operation::Update),
13919 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
13920 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13921 }
13922 }
13923 }
13924 deserializer.deserialize_any(GeneratedVisitor)
13925 }
13926}
13927impl serde::Serialize for SubscribeType {
13928 #[allow(deprecated)]
13929 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13930 where
13931 S: serde::Serializer,
13932 {
13933 let variant = match self {
13934 Self::Unspecified => "UNSPECIFIED",
13935 Self::Frontend => "FRONTEND",
13936 Self::Hummock => "HUMMOCK",
13937 Self::Compactor => "COMPACTOR",
13938 Self::Compute => "COMPUTE",
13939 };
13940 serializer.serialize_str(variant)
13941 }
13942}
13943impl<'de> serde::Deserialize<'de> for SubscribeType {
13944 #[allow(deprecated)]
13945 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13946 where
13947 D: serde::Deserializer<'de>,
13948 {
13949 const FIELDS: &[&str] = &[
13950 "UNSPECIFIED",
13951 "FRONTEND",
13952 "HUMMOCK",
13953 "COMPACTOR",
13954 "COMPUTE",
13955 ];
13956
13957 struct GeneratedVisitor;
13958
13959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13960 type Value = SubscribeType;
13961
13962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13963 write!(formatter, "expected one of: {:?}", &FIELDS)
13964 }
13965
13966 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13967 where
13968 E: serde::de::Error,
13969 {
13970 i32::try_from(v)
13971 .ok()
13972 .and_then(|x| x.try_into().ok())
13973 .ok_or_else(|| {
13974 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13975 })
13976 }
13977
13978 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13979 where
13980 E: serde::de::Error,
13981 {
13982 i32::try_from(v)
13983 .ok()
13984 .and_then(|x| x.try_into().ok())
13985 .ok_or_else(|| {
13986 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13987 })
13988 }
13989
13990 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13991 where
13992 E: serde::de::Error,
13993 {
13994 match value {
13995 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
13996 "FRONTEND" => Ok(SubscribeType::Frontend),
13997 "HUMMOCK" => Ok(SubscribeType::Hummock),
13998 "COMPACTOR" => Ok(SubscribeType::Compactor),
13999 "COMPUTE" => Ok(SubscribeType::Compute),
14000 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14001 }
14002 }
14003 }
14004 deserializer.deserialize_any(GeneratedVisitor)
14005 }
14006}
14007impl serde::Serialize for SystemParams {
14008 #[allow(deprecated)]
14009 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14010 where
14011 S: serde::Serializer,
14012 {
14013 use serde::ser::SerializeStruct;
14014 let mut len = 0;
14015 if self.barrier_interval_ms.is_some() {
14016 len += 1;
14017 }
14018 if self.checkpoint_frequency.is_some() {
14019 len += 1;
14020 }
14021 if self.sstable_size_mb.is_some() {
14022 len += 1;
14023 }
14024 if self.block_size_kb.is_some() {
14025 len += 1;
14026 }
14027 if self.bloom_false_positive.is_some() {
14028 len += 1;
14029 }
14030 if self.state_store.is_some() {
14031 len += 1;
14032 }
14033 if self.data_directory.is_some() {
14034 len += 1;
14035 }
14036 if self.backup_storage_url.is_some() {
14037 len += 1;
14038 }
14039 if self.backup_storage_directory.is_some() {
14040 len += 1;
14041 }
14042 if self.telemetry_enabled.is_some() {
14043 len += 1;
14044 }
14045 if self.parallel_compact_size_mb.is_some() {
14046 len += 1;
14047 }
14048 if self.max_concurrent_creating_streaming_jobs.is_some() {
14049 len += 1;
14050 }
14051 if self.pause_on_next_bootstrap.is_some() {
14052 len += 1;
14053 }
14054 if self.wasm_storage_url.is_some() {
14055 len += 1;
14056 }
14057 if self.enable_tracing.is_some() {
14058 len += 1;
14059 }
14060 if self.use_new_object_prefix_strategy.is_some() {
14061 len += 1;
14062 }
14063 if self.license_key.is_some() {
14064 len += 1;
14065 }
14066 if self.time_travel_retention_ms.is_some() {
14067 len += 1;
14068 }
14069 if self.adaptive_parallelism_strategy.is_some() {
14070 len += 1;
14071 }
14072 if self.per_database_isolation.is_some() {
14073 len += 1;
14074 }
14075 if self.enforce_secret.is_some() {
14076 len += 1;
14077 }
14078 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
14079 if let Some(v) = self.barrier_interval_ms.as_ref() {
14080 struct_ser.serialize_field("barrierIntervalMs", v)?;
14081 }
14082 if let Some(v) = self.checkpoint_frequency.as_ref() {
14083 #[allow(clippy::needless_borrow)]
14084 #[allow(clippy::needless_borrows_for_generic_args)]
14085 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
14086 }
14087 if let Some(v) = self.sstable_size_mb.as_ref() {
14088 struct_ser.serialize_field("sstableSizeMb", v)?;
14089 }
14090 if let Some(v) = self.block_size_kb.as_ref() {
14091 struct_ser.serialize_field("blockSizeKb", v)?;
14092 }
14093 if let Some(v) = self.bloom_false_positive.as_ref() {
14094 struct_ser.serialize_field("bloomFalsePositive", v)?;
14095 }
14096 if let Some(v) = self.state_store.as_ref() {
14097 struct_ser.serialize_field("stateStore", v)?;
14098 }
14099 if let Some(v) = self.data_directory.as_ref() {
14100 struct_ser.serialize_field("dataDirectory", v)?;
14101 }
14102 if let Some(v) = self.backup_storage_url.as_ref() {
14103 struct_ser.serialize_field("backupStorageUrl", v)?;
14104 }
14105 if let Some(v) = self.backup_storage_directory.as_ref() {
14106 struct_ser.serialize_field("backupStorageDirectory", v)?;
14107 }
14108 if let Some(v) = self.telemetry_enabled.as_ref() {
14109 struct_ser.serialize_field("telemetryEnabled", v)?;
14110 }
14111 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
14112 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
14113 }
14114 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
14115 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
14116 }
14117 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
14118 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
14119 }
14120 if let Some(v) = self.wasm_storage_url.as_ref() {
14121 struct_ser.serialize_field("wasmStorageUrl", v)?;
14122 }
14123 if let Some(v) = self.enable_tracing.as_ref() {
14124 struct_ser.serialize_field("enableTracing", v)?;
14125 }
14126 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
14127 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
14128 }
14129 if let Some(v) = self.license_key.as_ref() {
14130 struct_ser.serialize_field("licenseKey", v)?;
14131 }
14132 if let Some(v) = self.time_travel_retention_ms.as_ref() {
14133 #[allow(clippy::needless_borrow)]
14134 #[allow(clippy::needless_borrows_for_generic_args)]
14135 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
14136 }
14137 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
14138 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
14139 }
14140 if let Some(v) = self.per_database_isolation.as_ref() {
14141 struct_ser.serialize_field("perDatabaseIsolation", v)?;
14142 }
14143 if let Some(v) = self.enforce_secret.as_ref() {
14144 struct_ser.serialize_field("enforceSecret", v)?;
14145 }
14146 struct_ser.end()
14147 }
14148}
14149impl<'de> serde::Deserialize<'de> for SystemParams {
14150 #[allow(deprecated)]
14151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14152 where
14153 D: serde::Deserializer<'de>,
14154 {
14155 const FIELDS: &[&str] = &[
14156 "barrier_interval_ms",
14157 "barrierIntervalMs",
14158 "checkpoint_frequency",
14159 "checkpointFrequency",
14160 "sstable_size_mb",
14161 "sstableSizeMb",
14162 "block_size_kb",
14163 "blockSizeKb",
14164 "bloom_false_positive",
14165 "bloomFalsePositive",
14166 "state_store",
14167 "stateStore",
14168 "data_directory",
14169 "dataDirectory",
14170 "backup_storage_url",
14171 "backupStorageUrl",
14172 "backup_storage_directory",
14173 "backupStorageDirectory",
14174 "telemetry_enabled",
14175 "telemetryEnabled",
14176 "parallel_compact_size_mb",
14177 "parallelCompactSizeMb",
14178 "max_concurrent_creating_streaming_jobs",
14179 "maxConcurrentCreatingStreamingJobs",
14180 "pause_on_next_bootstrap",
14181 "pauseOnNextBootstrap",
14182 "wasm_storage_url",
14183 "wasmStorageUrl",
14184 "enable_tracing",
14185 "enableTracing",
14186 "use_new_object_prefix_strategy",
14187 "useNewObjectPrefixStrategy",
14188 "license_key",
14189 "licenseKey",
14190 "time_travel_retention_ms",
14191 "timeTravelRetentionMs",
14192 "adaptive_parallelism_strategy",
14193 "adaptiveParallelismStrategy",
14194 "per_database_isolation",
14195 "perDatabaseIsolation",
14196 "enforce_secret",
14197 "enforceSecret",
14198 ];
14199
14200 #[allow(clippy::enum_variant_names)]
14201 enum GeneratedField {
14202 BarrierIntervalMs,
14203 CheckpointFrequency,
14204 SstableSizeMb,
14205 BlockSizeKb,
14206 BloomFalsePositive,
14207 StateStore,
14208 DataDirectory,
14209 BackupStorageUrl,
14210 BackupStorageDirectory,
14211 TelemetryEnabled,
14212 ParallelCompactSizeMb,
14213 MaxConcurrentCreatingStreamingJobs,
14214 PauseOnNextBootstrap,
14215 WasmStorageUrl,
14216 EnableTracing,
14217 UseNewObjectPrefixStrategy,
14218 LicenseKey,
14219 TimeTravelRetentionMs,
14220 AdaptiveParallelismStrategy,
14221 PerDatabaseIsolation,
14222 EnforceSecret,
14223 }
14224 impl<'de> serde::Deserialize<'de> for GeneratedField {
14225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14226 where
14227 D: serde::Deserializer<'de>,
14228 {
14229 struct GeneratedVisitor;
14230
14231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14232 type Value = GeneratedField;
14233
14234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14235 write!(formatter, "expected one of: {:?}", &FIELDS)
14236 }
14237
14238 #[allow(unused_variables)]
14239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14240 where
14241 E: serde::de::Error,
14242 {
14243 match value {
14244 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
14245 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
14246 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
14247 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
14248 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
14249 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
14250 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
14251 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
14252 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
14253 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
14254 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
14255 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
14256 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
14257 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
14258 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
14259 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
14260 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
14261 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
14262 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
14263 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
14264 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
14265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14266 }
14267 }
14268 }
14269 deserializer.deserialize_identifier(GeneratedVisitor)
14270 }
14271 }
14272 struct GeneratedVisitor;
14273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14274 type Value = SystemParams;
14275
14276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14277 formatter.write_str("struct meta.SystemParams")
14278 }
14279
14280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
14281 where
14282 V: serde::de::MapAccess<'de>,
14283 {
14284 let mut barrier_interval_ms__ = None;
14285 let mut checkpoint_frequency__ = None;
14286 let mut sstable_size_mb__ = None;
14287 let mut block_size_kb__ = None;
14288 let mut bloom_false_positive__ = None;
14289 let mut state_store__ = None;
14290 let mut data_directory__ = None;
14291 let mut backup_storage_url__ = None;
14292 let mut backup_storage_directory__ = None;
14293 let mut telemetry_enabled__ = None;
14294 let mut parallel_compact_size_mb__ = None;
14295 let mut max_concurrent_creating_streaming_jobs__ = None;
14296 let mut pause_on_next_bootstrap__ = None;
14297 let mut wasm_storage_url__ = None;
14298 let mut enable_tracing__ = None;
14299 let mut use_new_object_prefix_strategy__ = None;
14300 let mut license_key__ = None;
14301 let mut time_travel_retention_ms__ = None;
14302 let mut adaptive_parallelism_strategy__ = None;
14303 let mut per_database_isolation__ = None;
14304 let mut enforce_secret__ = None;
14305 while let Some(k) = map_.next_key()? {
14306 match k {
14307 GeneratedField::BarrierIntervalMs => {
14308 if barrier_interval_ms__.is_some() {
14309 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
14310 }
14311 barrier_interval_ms__ =
14312 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14313 ;
14314 }
14315 GeneratedField::CheckpointFrequency => {
14316 if checkpoint_frequency__.is_some() {
14317 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
14318 }
14319 checkpoint_frequency__ =
14320 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14321 ;
14322 }
14323 GeneratedField::SstableSizeMb => {
14324 if sstable_size_mb__.is_some() {
14325 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
14326 }
14327 sstable_size_mb__ =
14328 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14329 ;
14330 }
14331 GeneratedField::BlockSizeKb => {
14332 if block_size_kb__.is_some() {
14333 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
14334 }
14335 block_size_kb__ =
14336 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14337 ;
14338 }
14339 GeneratedField::BloomFalsePositive => {
14340 if bloom_false_positive__.is_some() {
14341 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
14342 }
14343 bloom_false_positive__ =
14344 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14345 ;
14346 }
14347 GeneratedField::StateStore => {
14348 if state_store__.is_some() {
14349 return Err(serde::de::Error::duplicate_field("stateStore"));
14350 }
14351 state_store__ = map_.next_value()?;
14352 }
14353 GeneratedField::DataDirectory => {
14354 if data_directory__.is_some() {
14355 return Err(serde::de::Error::duplicate_field("dataDirectory"));
14356 }
14357 data_directory__ = map_.next_value()?;
14358 }
14359 GeneratedField::BackupStorageUrl => {
14360 if backup_storage_url__.is_some() {
14361 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
14362 }
14363 backup_storage_url__ = map_.next_value()?;
14364 }
14365 GeneratedField::BackupStorageDirectory => {
14366 if backup_storage_directory__.is_some() {
14367 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
14368 }
14369 backup_storage_directory__ = map_.next_value()?;
14370 }
14371 GeneratedField::TelemetryEnabled => {
14372 if telemetry_enabled__.is_some() {
14373 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
14374 }
14375 telemetry_enabled__ = map_.next_value()?;
14376 }
14377 GeneratedField::ParallelCompactSizeMb => {
14378 if parallel_compact_size_mb__.is_some() {
14379 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
14380 }
14381 parallel_compact_size_mb__ =
14382 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14383 ;
14384 }
14385 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
14386 if max_concurrent_creating_streaming_jobs__.is_some() {
14387 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
14388 }
14389 max_concurrent_creating_streaming_jobs__ =
14390 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14391 ;
14392 }
14393 GeneratedField::PauseOnNextBootstrap => {
14394 if pause_on_next_bootstrap__.is_some() {
14395 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
14396 }
14397 pause_on_next_bootstrap__ = map_.next_value()?;
14398 }
14399 GeneratedField::WasmStorageUrl => {
14400 if wasm_storage_url__.is_some() {
14401 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
14402 }
14403 wasm_storage_url__ = map_.next_value()?;
14404 }
14405 GeneratedField::EnableTracing => {
14406 if enable_tracing__.is_some() {
14407 return Err(serde::de::Error::duplicate_field("enableTracing"));
14408 }
14409 enable_tracing__ = map_.next_value()?;
14410 }
14411 GeneratedField::UseNewObjectPrefixStrategy => {
14412 if use_new_object_prefix_strategy__.is_some() {
14413 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
14414 }
14415 use_new_object_prefix_strategy__ = map_.next_value()?;
14416 }
14417 GeneratedField::LicenseKey => {
14418 if license_key__.is_some() {
14419 return Err(serde::de::Error::duplicate_field("licenseKey"));
14420 }
14421 license_key__ = map_.next_value()?;
14422 }
14423 GeneratedField::TimeTravelRetentionMs => {
14424 if time_travel_retention_ms__.is_some() {
14425 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
14426 }
14427 time_travel_retention_ms__ =
14428 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14429 ;
14430 }
14431 GeneratedField::AdaptiveParallelismStrategy => {
14432 if adaptive_parallelism_strategy__.is_some() {
14433 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
14434 }
14435 adaptive_parallelism_strategy__ = map_.next_value()?;
14436 }
14437 GeneratedField::PerDatabaseIsolation => {
14438 if per_database_isolation__.is_some() {
14439 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
14440 }
14441 per_database_isolation__ = map_.next_value()?;
14442 }
14443 GeneratedField::EnforceSecret => {
14444 if enforce_secret__.is_some() {
14445 return Err(serde::de::Error::duplicate_field("enforceSecret"));
14446 }
14447 enforce_secret__ = map_.next_value()?;
14448 }
14449 }
14450 }
14451 Ok(SystemParams {
14452 barrier_interval_ms: barrier_interval_ms__,
14453 checkpoint_frequency: checkpoint_frequency__,
14454 sstable_size_mb: sstable_size_mb__,
14455 block_size_kb: block_size_kb__,
14456 bloom_false_positive: bloom_false_positive__,
14457 state_store: state_store__,
14458 data_directory: data_directory__,
14459 backup_storage_url: backup_storage_url__,
14460 backup_storage_directory: backup_storage_directory__,
14461 telemetry_enabled: telemetry_enabled__,
14462 parallel_compact_size_mb: parallel_compact_size_mb__,
14463 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
14464 pause_on_next_bootstrap: pause_on_next_bootstrap__,
14465 wasm_storage_url: wasm_storage_url__,
14466 enable_tracing: enable_tracing__,
14467 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
14468 license_key: license_key__,
14469 time_travel_retention_ms: time_travel_retention_ms__,
14470 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
14471 per_database_isolation: per_database_isolation__,
14472 enforce_secret: enforce_secret__,
14473 })
14474 }
14475 }
14476 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
14477 }
14478}
14479impl serde::Serialize for TableFragments {
14480 #[allow(deprecated)]
14481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14482 where
14483 S: serde::Serializer,
14484 {
14485 use serde::ser::SerializeStruct;
14486 let mut len = 0;
14487 if self.table_id != 0 {
14488 len += 1;
14489 }
14490 if self.state != 0 {
14491 len += 1;
14492 }
14493 if !self.fragments.is_empty() {
14494 len += 1;
14495 }
14496 if !self.actor_status.is_empty() {
14497 len += 1;
14498 }
14499 if !self.actor_splits.is_empty() {
14500 len += 1;
14501 }
14502 if self.ctx.is_some() {
14503 len += 1;
14504 }
14505 if self.parallelism.is_some() {
14506 len += 1;
14507 }
14508 if self.max_parallelism.is_some() {
14509 len += 1;
14510 }
14511 if !self.node_label.is_empty() {
14512 len += 1;
14513 }
14514 if self.backfill_done {
14515 len += 1;
14516 }
14517 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
14518 if self.table_id != 0 {
14519 struct_ser.serialize_field("tableId", &self.table_id)?;
14520 }
14521 if self.state != 0 {
14522 let v = table_fragments::State::try_from(self.state)
14523 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
14524 struct_ser.serialize_field("state", &v)?;
14525 }
14526 if !self.fragments.is_empty() {
14527 struct_ser.serialize_field("fragments", &self.fragments)?;
14528 }
14529 if !self.actor_status.is_empty() {
14530 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
14531 }
14532 if !self.actor_splits.is_empty() {
14533 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14534 }
14535 if let Some(v) = self.ctx.as_ref() {
14536 struct_ser.serialize_field("ctx", v)?;
14537 }
14538 if let Some(v) = self.parallelism.as_ref() {
14539 struct_ser.serialize_field("parallelism", v)?;
14540 }
14541 if let Some(v) = self.max_parallelism.as_ref() {
14542 struct_ser.serialize_field("maxParallelism", v)?;
14543 }
14544 if !self.node_label.is_empty() {
14545 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
14546 }
14547 if self.backfill_done {
14548 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
14549 }
14550 struct_ser.end()
14551 }
14552}
14553impl<'de> serde::Deserialize<'de> for TableFragments {
14554 #[allow(deprecated)]
14555 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14556 where
14557 D: serde::Deserializer<'de>,
14558 {
14559 const FIELDS: &[&str] = &[
14560 "table_id",
14561 "tableId",
14562 "state",
14563 "fragments",
14564 "actor_status",
14565 "actorStatus",
14566 "actor_splits",
14567 "actorSplits",
14568 "ctx",
14569 "parallelism",
14570 "max_parallelism",
14571 "maxParallelism",
14572 "node_label",
14573 "nodeLabel",
14574 "backfill_done",
14575 "backfillDone",
14576 ];
14577
14578 #[allow(clippy::enum_variant_names)]
14579 enum GeneratedField {
14580 TableId,
14581 State,
14582 Fragments,
14583 ActorStatus,
14584 ActorSplits,
14585 Ctx,
14586 Parallelism,
14587 MaxParallelism,
14588 NodeLabel,
14589 BackfillDone,
14590 }
14591 impl<'de> serde::Deserialize<'de> for GeneratedField {
14592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14593 where
14594 D: serde::Deserializer<'de>,
14595 {
14596 struct GeneratedVisitor;
14597
14598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14599 type Value = GeneratedField;
14600
14601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14602 write!(formatter, "expected one of: {:?}", &FIELDS)
14603 }
14604
14605 #[allow(unused_variables)]
14606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14607 where
14608 E: serde::de::Error,
14609 {
14610 match value {
14611 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14612 "state" => Ok(GeneratedField::State),
14613 "fragments" => Ok(GeneratedField::Fragments),
14614 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
14615 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14616 "ctx" => Ok(GeneratedField::Ctx),
14617 "parallelism" => Ok(GeneratedField::Parallelism),
14618 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
14619 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
14620 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
14621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14622 }
14623 }
14624 }
14625 deserializer.deserialize_identifier(GeneratedVisitor)
14626 }
14627 }
14628 struct GeneratedVisitor;
14629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14630 type Value = TableFragments;
14631
14632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14633 formatter.write_str("struct meta.TableFragments")
14634 }
14635
14636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
14637 where
14638 V: serde::de::MapAccess<'de>,
14639 {
14640 let mut table_id__ = None;
14641 let mut state__ = None;
14642 let mut fragments__ = None;
14643 let mut actor_status__ = None;
14644 let mut actor_splits__ = None;
14645 let mut ctx__ = None;
14646 let mut parallelism__ = None;
14647 let mut max_parallelism__ = None;
14648 let mut node_label__ = None;
14649 let mut backfill_done__ = None;
14650 while let Some(k) = map_.next_key()? {
14651 match k {
14652 GeneratedField::TableId => {
14653 if table_id__.is_some() {
14654 return Err(serde::de::Error::duplicate_field("tableId"));
14655 }
14656 table_id__ =
14657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14658 ;
14659 }
14660 GeneratedField::State => {
14661 if state__.is_some() {
14662 return Err(serde::de::Error::duplicate_field("state"));
14663 }
14664 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
14665 }
14666 GeneratedField::Fragments => {
14667 if fragments__.is_some() {
14668 return Err(serde::de::Error::duplicate_field("fragments"));
14669 }
14670 fragments__ = Some(
14671 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14672 .into_iter().map(|(k,v)| (k.0, v)).collect()
14673 );
14674 }
14675 GeneratedField::ActorStatus => {
14676 if actor_status__.is_some() {
14677 return Err(serde::de::Error::duplicate_field("actorStatus"));
14678 }
14679 actor_status__ = Some(
14680 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14681 .into_iter().map(|(k,v)| (k.0, v)).collect()
14682 );
14683 }
14684 GeneratedField::ActorSplits => {
14685 if actor_splits__.is_some() {
14686 return Err(serde::de::Error::duplicate_field("actorSplits"));
14687 }
14688 actor_splits__ = Some(
14689 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14690 .into_iter().map(|(k,v)| (k.0, v)).collect()
14691 );
14692 }
14693 GeneratedField::Ctx => {
14694 if ctx__.is_some() {
14695 return Err(serde::de::Error::duplicate_field("ctx"));
14696 }
14697 ctx__ = map_.next_value()?;
14698 }
14699 GeneratedField::Parallelism => {
14700 if parallelism__.is_some() {
14701 return Err(serde::de::Error::duplicate_field("parallelism"));
14702 }
14703 parallelism__ = map_.next_value()?;
14704 }
14705 GeneratedField::MaxParallelism => {
14706 if max_parallelism__.is_some() {
14707 return Err(serde::de::Error::duplicate_field("maxParallelism"));
14708 }
14709 max_parallelism__ =
14710 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14711 ;
14712 }
14713 GeneratedField::NodeLabel => {
14714 if node_label__.is_some() {
14715 return Err(serde::de::Error::duplicate_field("nodeLabel"));
14716 }
14717 node_label__ = Some(map_.next_value()?);
14718 }
14719 GeneratedField::BackfillDone => {
14720 if backfill_done__.is_some() {
14721 return Err(serde::de::Error::duplicate_field("backfillDone"));
14722 }
14723 backfill_done__ = Some(map_.next_value()?);
14724 }
14725 }
14726 }
14727 Ok(TableFragments {
14728 table_id: table_id__.unwrap_or_default(),
14729 state: state__.unwrap_or_default(),
14730 fragments: fragments__.unwrap_or_default(),
14731 actor_status: actor_status__.unwrap_or_default(),
14732 actor_splits: actor_splits__.unwrap_or_default(),
14733 ctx: ctx__,
14734 parallelism: parallelism__,
14735 max_parallelism: max_parallelism__,
14736 node_label: node_label__.unwrap_or_default(),
14737 backfill_done: backfill_done__.unwrap_or_default(),
14738 })
14739 }
14740 }
14741 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
14742 }
14743}
14744impl serde::Serialize for table_fragments::ActorStatus {
14745 #[allow(deprecated)]
14746 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14747 where
14748 S: serde::Serializer,
14749 {
14750 use serde::ser::SerializeStruct;
14751 let mut len = 0;
14752 if self.location.is_some() {
14753 len += 1;
14754 }
14755 if self.state != 0 {
14756 len += 1;
14757 }
14758 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
14759 if let Some(v) = self.location.as_ref() {
14760 struct_ser.serialize_field("location", v)?;
14761 }
14762 if self.state != 0 {
14763 let v = table_fragments::actor_status::ActorState::try_from(self.state)
14764 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
14765 struct_ser.serialize_field("state", &v)?;
14766 }
14767 struct_ser.end()
14768 }
14769}
14770impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
14771 #[allow(deprecated)]
14772 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14773 where
14774 D: serde::Deserializer<'de>,
14775 {
14776 const FIELDS: &[&str] = &[
14777 "location",
14778 "state",
14779 ];
14780
14781 #[allow(clippy::enum_variant_names)]
14782 enum GeneratedField {
14783 Location,
14784 State,
14785 }
14786 impl<'de> serde::Deserialize<'de> for GeneratedField {
14787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14788 where
14789 D: serde::Deserializer<'de>,
14790 {
14791 struct GeneratedVisitor;
14792
14793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14794 type Value = GeneratedField;
14795
14796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14797 write!(formatter, "expected one of: {:?}", &FIELDS)
14798 }
14799
14800 #[allow(unused_variables)]
14801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14802 where
14803 E: serde::de::Error,
14804 {
14805 match value {
14806 "location" => Ok(GeneratedField::Location),
14807 "state" => Ok(GeneratedField::State),
14808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14809 }
14810 }
14811 }
14812 deserializer.deserialize_identifier(GeneratedVisitor)
14813 }
14814 }
14815 struct GeneratedVisitor;
14816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14817 type Value = table_fragments::ActorStatus;
14818
14819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14820 formatter.write_str("struct meta.TableFragments.ActorStatus")
14821 }
14822
14823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
14824 where
14825 V: serde::de::MapAccess<'de>,
14826 {
14827 let mut location__ = None;
14828 let mut state__ = None;
14829 while let Some(k) = map_.next_key()? {
14830 match k {
14831 GeneratedField::Location => {
14832 if location__.is_some() {
14833 return Err(serde::de::Error::duplicate_field("location"));
14834 }
14835 location__ = map_.next_value()?;
14836 }
14837 GeneratedField::State => {
14838 if state__.is_some() {
14839 return Err(serde::de::Error::duplicate_field("state"));
14840 }
14841 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
14842 }
14843 }
14844 }
14845 Ok(table_fragments::ActorStatus {
14846 location: location__,
14847 state: state__.unwrap_or_default(),
14848 })
14849 }
14850 }
14851 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
14852 }
14853}
14854impl serde::Serialize for table_fragments::actor_status::ActorState {
14855 #[allow(deprecated)]
14856 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14857 where
14858 S: serde::Serializer,
14859 {
14860 let variant = match self {
14861 Self::Unspecified => "UNSPECIFIED",
14862 Self::Inactive => "INACTIVE",
14863 Self::Running => "RUNNING",
14864 };
14865 serializer.serialize_str(variant)
14866 }
14867}
14868impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
14869 #[allow(deprecated)]
14870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14871 where
14872 D: serde::Deserializer<'de>,
14873 {
14874 const FIELDS: &[&str] = &[
14875 "UNSPECIFIED",
14876 "INACTIVE",
14877 "RUNNING",
14878 ];
14879
14880 struct GeneratedVisitor;
14881
14882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14883 type Value = table_fragments::actor_status::ActorState;
14884
14885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14886 write!(formatter, "expected one of: {:?}", &FIELDS)
14887 }
14888
14889 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14890 where
14891 E: serde::de::Error,
14892 {
14893 i32::try_from(v)
14894 .ok()
14895 .and_then(|x| x.try_into().ok())
14896 .ok_or_else(|| {
14897 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14898 })
14899 }
14900
14901 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14902 where
14903 E: serde::de::Error,
14904 {
14905 i32::try_from(v)
14906 .ok()
14907 .and_then(|x| x.try_into().ok())
14908 .ok_or_else(|| {
14909 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14910 })
14911 }
14912
14913 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14914 where
14915 E: serde::de::Error,
14916 {
14917 match value {
14918 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
14919 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
14920 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
14921 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14922 }
14923 }
14924 }
14925 deserializer.deserialize_any(GeneratedVisitor)
14926 }
14927}
14928impl serde::Serialize for table_fragments::Fragment {
14929 #[allow(deprecated)]
14930 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14931 where
14932 S: serde::Serializer,
14933 {
14934 use serde::ser::SerializeStruct;
14935 let mut len = 0;
14936 if self.fragment_id != 0 {
14937 len += 1;
14938 }
14939 if self.fragment_type_mask != 0 {
14940 len += 1;
14941 }
14942 if self.distribution_type != 0 {
14943 len += 1;
14944 }
14945 if !self.actors.is_empty() {
14946 len += 1;
14947 }
14948 if !self.state_table_ids.is_empty() {
14949 len += 1;
14950 }
14951 if !self.upstream_fragment_ids.is_empty() {
14952 len += 1;
14953 }
14954 if self.maybe_vnode_count.is_some() {
14955 len += 1;
14956 }
14957 if self.nodes.is_some() {
14958 len += 1;
14959 }
14960 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
14961 if self.fragment_id != 0 {
14962 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
14963 }
14964 if self.fragment_type_mask != 0 {
14965 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
14966 }
14967 if self.distribution_type != 0 {
14968 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
14969 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
14970 struct_ser.serialize_field("distributionType", &v)?;
14971 }
14972 if !self.actors.is_empty() {
14973 struct_ser.serialize_field("actors", &self.actors)?;
14974 }
14975 if !self.state_table_ids.is_empty() {
14976 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
14977 }
14978 if !self.upstream_fragment_ids.is_empty() {
14979 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
14980 }
14981 if let Some(v) = self.maybe_vnode_count.as_ref() {
14982 struct_ser.serialize_field("maybeVnodeCount", v)?;
14983 }
14984 if let Some(v) = self.nodes.as_ref() {
14985 struct_ser.serialize_field("nodes", v)?;
14986 }
14987 struct_ser.end()
14988 }
14989}
14990impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
14991 #[allow(deprecated)]
14992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14993 where
14994 D: serde::Deserializer<'de>,
14995 {
14996 const FIELDS: &[&str] = &[
14997 "fragment_id",
14998 "fragmentId",
14999 "fragment_type_mask",
15000 "fragmentTypeMask",
15001 "distribution_type",
15002 "distributionType",
15003 "actors",
15004 "state_table_ids",
15005 "stateTableIds",
15006 "upstream_fragment_ids",
15007 "upstreamFragmentIds",
15008 "maybe_vnode_count",
15009 "maybeVnodeCount",
15010 "nodes",
15011 ];
15012
15013 #[allow(clippy::enum_variant_names)]
15014 enum GeneratedField {
15015 FragmentId,
15016 FragmentTypeMask,
15017 DistributionType,
15018 Actors,
15019 StateTableIds,
15020 UpstreamFragmentIds,
15021 MaybeVnodeCount,
15022 Nodes,
15023 }
15024 impl<'de> serde::Deserialize<'de> for GeneratedField {
15025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15026 where
15027 D: serde::Deserializer<'de>,
15028 {
15029 struct GeneratedVisitor;
15030
15031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15032 type Value = GeneratedField;
15033
15034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15035 write!(formatter, "expected one of: {:?}", &FIELDS)
15036 }
15037
15038 #[allow(unused_variables)]
15039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15040 where
15041 E: serde::de::Error,
15042 {
15043 match value {
15044 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15045 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15046 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15047 "actors" => Ok(GeneratedField::Actors),
15048 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15049 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15050 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15051 "nodes" => Ok(GeneratedField::Nodes),
15052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15053 }
15054 }
15055 }
15056 deserializer.deserialize_identifier(GeneratedVisitor)
15057 }
15058 }
15059 struct GeneratedVisitor;
15060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15061 type Value = table_fragments::Fragment;
15062
15063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15064 formatter.write_str("struct meta.TableFragments.Fragment")
15065 }
15066
15067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15068 where
15069 V: serde::de::MapAccess<'de>,
15070 {
15071 let mut fragment_id__ = None;
15072 let mut fragment_type_mask__ = None;
15073 let mut distribution_type__ = None;
15074 let mut actors__ = None;
15075 let mut state_table_ids__ = None;
15076 let mut upstream_fragment_ids__ = None;
15077 let mut maybe_vnode_count__ = None;
15078 let mut nodes__ = None;
15079 while let Some(k) = map_.next_key()? {
15080 match k {
15081 GeneratedField::FragmentId => {
15082 if fragment_id__.is_some() {
15083 return Err(serde::de::Error::duplicate_field("fragmentId"));
15084 }
15085 fragment_id__ =
15086 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15087 ;
15088 }
15089 GeneratedField::FragmentTypeMask => {
15090 if fragment_type_mask__.is_some() {
15091 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15092 }
15093 fragment_type_mask__ =
15094 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15095 ;
15096 }
15097 GeneratedField::DistributionType => {
15098 if distribution_type__.is_some() {
15099 return Err(serde::de::Error::duplicate_field("distributionType"));
15100 }
15101 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
15102 }
15103 GeneratedField::Actors => {
15104 if actors__.is_some() {
15105 return Err(serde::de::Error::duplicate_field("actors"));
15106 }
15107 actors__ = Some(map_.next_value()?);
15108 }
15109 GeneratedField::StateTableIds => {
15110 if state_table_ids__.is_some() {
15111 return Err(serde::de::Error::duplicate_field("stateTableIds"));
15112 }
15113 state_table_ids__ =
15114 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15115 .into_iter().map(|x| x.0).collect())
15116 ;
15117 }
15118 GeneratedField::UpstreamFragmentIds => {
15119 if upstream_fragment_ids__.is_some() {
15120 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
15121 }
15122 upstream_fragment_ids__ =
15123 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15124 .into_iter().map(|x| x.0).collect())
15125 ;
15126 }
15127 GeneratedField::MaybeVnodeCount => {
15128 if maybe_vnode_count__.is_some() {
15129 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
15130 }
15131 maybe_vnode_count__ =
15132 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15133 ;
15134 }
15135 GeneratedField::Nodes => {
15136 if nodes__.is_some() {
15137 return Err(serde::de::Error::duplicate_field("nodes"));
15138 }
15139 nodes__ = map_.next_value()?;
15140 }
15141 }
15142 }
15143 Ok(table_fragments::Fragment {
15144 fragment_id: fragment_id__.unwrap_or_default(),
15145 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
15146 distribution_type: distribution_type__.unwrap_or_default(),
15147 actors: actors__.unwrap_or_default(),
15148 state_table_ids: state_table_ids__.unwrap_or_default(),
15149 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
15150 maybe_vnode_count: maybe_vnode_count__,
15151 nodes: nodes__,
15152 })
15153 }
15154 }
15155 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
15156 }
15157}
15158impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
15159 #[allow(deprecated)]
15160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15161 where
15162 S: serde::Serializer,
15163 {
15164 let variant = match self {
15165 Self::Unspecified => "UNSPECIFIED",
15166 Self::Single => "SINGLE",
15167 Self::Hash => "HASH",
15168 };
15169 serializer.serialize_str(variant)
15170 }
15171}
15172impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
15173 #[allow(deprecated)]
15174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15175 where
15176 D: serde::Deserializer<'de>,
15177 {
15178 const FIELDS: &[&str] = &[
15179 "UNSPECIFIED",
15180 "SINGLE",
15181 "HASH",
15182 ];
15183
15184 struct GeneratedVisitor;
15185
15186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15187 type Value = table_fragments::fragment::FragmentDistributionType;
15188
15189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15190 write!(formatter, "expected one of: {:?}", &FIELDS)
15191 }
15192
15193 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15194 where
15195 E: serde::de::Error,
15196 {
15197 i32::try_from(v)
15198 .ok()
15199 .and_then(|x| x.try_into().ok())
15200 .ok_or_else(|| {
15201 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15202 })
15203 }
15204
15205 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15206 where
15207 E: serde::de::Error,
15208 {
15209 i32::try_from(v)
15210 .ok()
15211 .and_then(|x| x.try_into().ok())
15212 .ok_or_else(|| {
15213 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15214 })
15215 }
15216
15217 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15218 where
15219 E: serde::de::Error,
15220 {
15221 match value {
15222 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
15223 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
15224 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
15225 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15226 }
15227 }
15228 }
15229 deserializer.deserialize_any(GeneratedVisitor)
15230 }
15231}
15232impl serde::Serialize for table_fragments::State {
15233 #[allow(deprecated)]
15234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15235 where
15236 S: serde::Serializer,
15237 {
15238 let variant = match self {
15239 Self::Unspecified => "UNSPECIFIED",
15240 Self::Initial => "INITIAL",
15241 Self::Creating => "CREATING",
15242 Self::Created => "CREATED",
15243 };
15244 serializer.serialize_str(variant)
15245 }
15246}
15247impl<'de> serde::Deserialize<'de> for table_fragments::State {
15248 #[allow(deprecated)]
15249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15250 where
15251 D: serde::Deserializer<'de>,
15252 {
15253 const FIELDS: &[&str] = &[
15254 "UNSPECIFIED",
15255 "INITIAL",
15256 "CREATING",
15257 "CREATED",
15258 ];
15259
15260 struct GeneratedVisitor;
15261
15262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15263 type Value = table_fragments::State;
15264
15265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15266 write!(formatter, "expected one of: {:?}", &FIELDS)
15267 }
15268
15269 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15270 where
15271 E: serde::de::Error,
15272 {
15273 i32::try_from(v)
15274 .ok()
15275 .and_then(|x| x.try_into().ok())
15276 .ok_or_else(|| {
15277 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15278 })
15279 }
15280
15281 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15282 where
15283 E: serde::de::Error,
15284 {
15285 i32::try_from(v)
15286 .ok()
15287 .and_then(|x| x.try_into().ok())
15288 .ok_or_else(|| {
15289 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15290 })
15291 }
15292
15293 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15294 where
15295 E: serde::de::Error,
15296 {
15297 match value {
15298 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
15299 "INITIAL" => Ok(table_fragments::State::Initial),
15300 "CREATING" => Ok(table_fragments::State::Creating),
15301 "CREATED" => Ok(table_fragments::State::Created),
15302 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15303 }
15304 }
15305 }
15306 deserializer.deserialize_any(GeneratedVisitor)
15307 }
15308}
15309impl serde::Serialize for TableParallelism {
15310 #[allow(deprecated)]
15311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15312 where
15313 S: serde::Serializer,
15314 {
15315 use serde::ser::SerializeStruct;
15316 let mut len = 0;
15317 if self.parallelism.is_some() {
15318 len += 1;
15319 }
15320 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
15321 if let Some(v) = self.parallelism.as_ref() {
15322 match v {
15323 table_parallelism::Parallelism::Fixed(v) => {
15324 struct_ser.serialize_field("fixed", v)?;
15325 }
15326 table_parallelism::Parallelism::Auto(v) => {
15327 struct_ser.serialize_field("auto", v)?;
15328 }
15329 table_parallelism::Parallelism::Custom(v) => {
15330 struct_ser.serialize_field("custom", v)?;
15331 }
15332 table_parallelism::Parallelism::Adaptive(v) => {
15333 struct_ser.serialize_field("adaptive", v)?;
15334 }
15335 }
15336 }
15337 struct_ser.end()
15338 }
15339}
15340impl<'de> serde::Deserialize<'de> for TableParallelism {
15341 #[allow(deprecated)]
15342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15343 where
15344 D: serde::Deserializer<'de>,
15345 {
15346 const FIELDS: &[&str] = &[
15347 "fixed",
15348 "auto",
15349 "custom",
15350 "adaptive",
15351 ];
15352
15353 #[allow(clippy::enum_variant_names)]
15354 enum GeneratedField {
15355 Fixed,
15356 Auto,
15357 Custom,
15358 Adaptive,
15359 }
15360 impl<'de> serde::Deserialize<'de> for GeneratedField {
15361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15362 where
15363 D: serde::Deserializer<'de>,
15364 {
15365 struct GeneratedVisitor;
15366
15367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15368 type Value = GeneratedField;
15369
15370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15371 write!(formatter, "expected one of: {:?}", &FIELDS)
15372 }
15373
15374 #[allow(unused_variables)]
15375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15376 where
15377 E: serde::de::Error,
15378 {
15379 match value {
15380 "fixed" => Ok(GeneratedField::Fixed),
15381 "auto" => Ok(GeneratedField::Auto),
15382 "custom" => Ok(GeneratedField::Custom),
15383 "adaptive" => Ok(GeneratedField::Adaptive),
15384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15385 }
15386 }
15387 }
15388 deserializer.deserialize_identifier(GeneratedVisitor)
15389 }
15390 }
15391 struct GeneratedVisitor;
15392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15393 type Value = TableParallelism;
15394
15395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15396 formatter.write_str("struct meta.TableParallelism")
15397 }
15398
15399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
15400 where
15401 V: serde::de::MapAccess<'de>,
15402 {
15403 let mut parallelism__ = None;
15404 while let Some(k) = map_.next_key()? {
15405 match k {
15406 GeneratedField::Fixed => {
15407 if parallelism__.is_some() {
15408 return Err(serde::de::Error::duplicate_field("fixed"));
15409 }
15410 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
15411;
15412 }
15413 GeneratedField::Auto => {
15414 if parallelism__.is_some() {
15415 return Err(serde::de::Error::duplicate_field("auto"));
15416 }
15417 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
15418;
15419 }
15420 GeneratedField::Custom => {
15421 if parallelism__.is_some() {
15422 return Err(serde::de::Error::duplicate_field("custom"));
15423 }
15424 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
15425;
15426 }
15427 GeneratedField::Adaptive => {
15428 if parallelism__.is_some() {
15429 return Err(serde::de::Error::duplicate_field("adaptive"));
15430 }
15431 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
15432;
15433 }
15434 }
15435 }
15436 Ok(TableParallelism {
15437 parallelism: parallelism__,
15438 })
15439 }
15440 }
15441 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
15442 }
15443}
15444impl serde::Serialize for table_parallelism::AdaptiveParallelism {
15445 #[allow(deprecated)]
15446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15447 where
15448 S: serde::Serializer,
15449 {
15450 use serde::ser::SerializeStruct;
15451 let len = 0;
15452 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
15453 struct_ser.end()
15454 }
15455}
15456impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
15457 #[allow(deprecated)]
15458 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15459 where
15460 D: serde::Deserializer<'de>,
15461 {
15462 const FIELDS: &[&str] = &[
15463 ];
15464
15465 #[allow(clippy::enum_variant_names)]
15466 enum GeneratedField {
15467 }
15468 impl<'de> serde::Deserialize<'de> for GeneratedField {
15469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15470 where
15471 D: serde::Deserializer<'de>,
15472 {
15473 struct GeneratedVisitor;
15474
15475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15476 type Value = GeneratedField;
15477
15478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15479 write!(formatter, "expected one of: {:?}", &FIELDS)
15480 }
15481
15482 #[allow(unused_variables)]
15483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15484 where
15485 E: serde::de::Error,
15486 {
15487 Err(serde::de::Error::unknown_field(value, FIELDS))
15488 }
15489 }
15490 deserializer.deserialize_identifier(GeneratedVisitor)
15491 }
15492 }
15493 struct GeneratedVisitor;
15494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15495 type Value = table_parallelism::AdaptiveParallelism;
15496
15497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15498 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
15499 }
15500
15501 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
15502 where
15503 V: serde::de::MapAccess<'de>,
15504 {
15505 while map_.next_key::<GeneratedField>()?.is_some() {
15506 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15507 }
15508 Ok(table_parallelism::AdaptiveParallelism {
15509 })
15510 }
15511 }
15512 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
15513 }
15514}
15515impl serde::Serialize for table_parallelism::AutoParallelism {
15516 #[allow(deprecated)]
15517 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15518 where
15519 S: serde::Serializer,
15520 {
15521 use serde::ser::SerializeStruct;
15522 let len = 0;
15523 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
15524 struct_ser.end()
15525 }
15526}
15527impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
15528 #[allow(deprecated)]
15529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15530 where
15531 D: serde::Deserializer<'de>,
15532 {
15533 const FIELDS: &[&str] = &[
15534 ];
15535
15536 #[allow(clippy::enum_variant_names)]
15537 enum GeneratedField {
15538 }
15539 impl<'de> serde::Deserialize<'de> for GeneratedField {
15540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15541 where
15542 D: serde::Deserializer<'de>,
15543 {
15544 struct GeneratedVisitor;
15545
15546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15547 type Value = GeneratedField;
15548
15549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15550 write!(formatter, "expected one of: {:?}", &FIELDS)
15551 }
15552
15553 #[allow(unused_variables)]
15554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15555 where
15556 E: serde::de::Error,
15557 {
15558 Err(serde::de::Error::unknown_field(value, FIELDS))
15559 }
15560 }
15561 deserializer.deserialize_identifier(GeneratedVisitor)
15562 }
15563 }
15564 struct GeneratedVisitor;
15565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15566 type Value = table_parallelism::AutoParallelism;
15567
15568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15569 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
15570 }
15571
15572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
15573 where
15574 V: serde::de::MapAccess<'de>,
15575 {
15576 while map_.next_key::<GeneratedField>()?.is_some() {
15577 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15578 }
15579 Ok(table_parallelism::AutoParallelism {
15580 })
15581 }
15582 }
15583 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
15584 }
15585}
15586impl serde::Serialize for table_parallelism::CustomParallelism {
15587 #[allow(deprecated)]
15588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15589 where
15590 S: serde::Serializer,
15591 {
15592 use serde::ser::SerializeStruct;
15593 let len = 0;
15594 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
15595 struct_ser.end()
15596 }
15597}
15598impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
15599 #[allow(deprecated)]
15600 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15601 where
15602 D: serde::Deserializer<'de>,
15603 {
15604 const FIELDS: &[&str] = &[
15605 ];
15606
15607 #[allow(clippy::enum_variant_names)]
15608 enum GeneratedField {
15609 }
15610 impl<'de> serde::Deserialize<'de> for GeneratedField {
15611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15612 where
15613 D: serde::Deserializer<'de>,
15614 {
15615 struct GeneratedVisitor;
15616
15617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15618 type Value = GeneratedField;
15619
15620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15621 write!(formatter, "expected one of: {:?}", &FIELDS)
15622 }
15623
15624 #[allow(unused_variables)]
15625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15626 where
15627 E: serde::de::Error,
15628 {
15629 Err(serde::de::Error::unknown_field(value, FIELDS))
15630 }
15631 }
15632 deserializer.deserialize_identifier(GeneratedVisitor)
15633 }
15634 }
15635 struct GeneratedVisitor;
15636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15637 type Value = table_parallelism::CustomParallelism;
15638
15639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15640 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
15641 }
15642
15643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
15644 where
15645 V: serde::de::MapAccess<'de>,
15646 {
15647 while map_.next_key::<GeneratedField>()?.is_some() {
15648 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15649 }
15650 Ok(table_parallelism::CustomParallelism {
15651 })
15652 }
15653 }
15654 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
15655 }
15656}
15657impl serde::Serialize for table_parallelism::FixedParallelism {
15658 #[allow(deprecated)]
15659 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15660 where
15661 S: serde::Serializer,
15662 {
15663 use serde::ser::SerializeStruct;
15664 let mut len = 0;
15665 if self.parallelism != 0 {
15666 len += 1;
15667 }
15668 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
15669 if self.parallelism != 0 {
15670 struct_ser.serialize_field("parallelism", &self.parallelism)?;
15671 }
15672 struct_ser.end()
15673 }
15674}
15675impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
15676 #[allow(deprecated)]
15677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15678 where
15679 D: serde::Deserializer<'de>,
15680 {
15681 const FIELDS: &[&str] = &[
15682 "parallelism",
15683 ];
15684
15685 #[allow(clippy::enum_variant_names)]
15686 enum GeneratedField {
15687 Parallelism,
15688 }
15689 impl<'de> serde::Deserialize<'de> for GeneratedField {
15690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15691 where
15692 D: serde::Deserializer<'de>,
15693 {
15694 struct GeneratedVisitor;
15695
15696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15697 type Value = GeneratedField;
15698
15699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15700 write!(formatter, "expected one of: {:?}", &FIELDS)
15701 }
15702
15703 #[allow(unused_variables)]
15704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15705 where
15706 E: serde::de::Error,
15707 {
15708 match value {
15709 "parallelism" => Ok(GeneratedField::Parallelism),
15710 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15711 }
15712 }
15713 }
15714 deserializer.deserialize_identifier(GeneratedVisitor)
15715 }
15716 }
15717 struct GeneratedVisitor;
15718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15719 type Value = table_parallelism::FixedParallelism;
15720
15721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15722 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
15723 }
15724
15725 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
15726 where
15727 V: serde::de::MapAccess<'de>,
15728 {
15729 let mut parallelism__ = None;
15730 while let Some(k) = map_.next_key()? {
15731 match k {
15732 GeneratedField::Parallelism => {
15733 if parallelism__.is_some() {
15734 return Err(serde::de::Error::duplicate_field("parallelism"));
15735 }
15736 parallelism__ =
15737 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15738 ;
15739 }
15740 }
15741 }
15742 Ok(table_parallelism::FixedParallelism {
15743 parallelism: parallelism__.unwrap_or_default(),
15744 })
15745 }
15746 }
15747 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
15748 }
15749}
15750impl serde::Serialize for TelemetryInfoResponse {
15751 #[allow(deprecated)]
15752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15753 where
15754 S: serde::Serializer,
15755 {
15756 use serde::ser::SerializeStruct;
15757 let mut len = 0;
15758 if self.tracking_id.is_some() {
15759 len += 1;
15760 }
15761 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
15762 if let Some(v) = self.tracking_id.as_ref() {
15763 struct_ser.serialize_field("trackingId", v)?;
15764 }
15765 struct_ser.end()
15766 }
15767}
15768impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
15769 #[allow(deprecated)]
15770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15771 where
15772 D: serde::Deserializer<'de>,
15773 {
15774 const FIELDS: &[&str] = &[
15775 "tracking_id",
15776 "trackingId",
15777 ];
15778
15779 #[allow(clippy::enum_variant_names)]
15780 enum GeneratedField {
15781 TrackingId,
15782 }
15783 impl<'de> serde::Deserialize<'de> for GeneratedField {
15784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15785 where
15786 D: serde::Deserializer<'de>,
15787 {
15788 struct GeneratedVisitor;
15789
15790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15791 type Value = GeneratedField;
15792
15793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15794 write!(formatter, "expected one of: {:?}", &FIELDS)
15795 }
15796
15797 #[allow(unused_variables)]
15798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15799 where
15800 E: serde::de::Error,
15801 {
15802 match value {
15803 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
15804 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15805 }
15806 }
15807 }
15808 deserializer.deserialize_identifier(GeneratedVisitor)
15809 }
15810 }
15811 struct GeneratedVisitor;
15812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15813 type Value = TelemetryInfoResponse;
15814
15815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15816 formatter.write_str("struct meta.TelemetryInfoResponse")
15817 }
15818
15819 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
15820 where
15821 V: serde::de::MapAccess<'de>,
15822 {
15823 let mut tracking_id__ = None;
15824 while let Some(k) = map_.next_key()? {
15825 match k {
15826 GeneratedField::TrackingId => {
15827 if tracking_id__.is_some() {
15828 return Err(serde::de::Error::duplicate_field("trackingId"));
15829 }
15830 tracking_id__ = map_.next_value()?;
15831 }
15832 }
15833 }
15834 Ok(TelemetryInfoResponse {
15835 tracking_id: tracking_id__,
15836 })
15837 }
15838 }
15839 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
15840 }
15841}
15842impl serde::Serialize for ThrottleTarget {
15843 #[allow(deprecated)]
15844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15845 where
15846 S: serde::Serializer,
15847 {
15848 let variant = match self {
15849 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
15850 Self::Source => "SOURCE",
15851 Self::Mv => "MV",
15852 Self::TableWithSource => "TABLE_WITH_SOURCE",
15853 Self::CdcTable => "CDC_TABLE",
15854 Self::TableDml => "TABLE_DML",
15855 Self::Sink => "SINK",
15856 Self::Fragment => "FRAGMENT",
15857 };
15858 serializer.serialize_str(variant)
15859 }
15860}
15861impl<'de> serde::Deserialize<'de> for ThrottleTarget {
15862 #[allow(deprecated)]
15863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15864 where
15865 D: serde::Deserializer<'de>,
15866 {
15867 const FIELDS: &[&str] = &[
15868 "THROTTLE_TARGET_UNSPECIFIED",
15869 "SOURCE",
15870 "MV",
15871 "TABLE_WITH_SOURCE",
15872 "CDC_TABLE",
15873 "TABLE_DML",
15874 "SINK",
15875 "FRAGMENT",
15876 ];
15877
15878 struct GeneratedVisitor;
15879
15880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15881 type Value = ThrottleTarget;
15882
15883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15884 write!(formatter, "expected one of: {:?}", &FIELDS)
15885 }
15886
15887 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15888 where
15889 E: serde::de::Error,
15890 {
15891 i32::try_from(v)
15892 .ok()
15893 .and_then(|x| x.try_into().ok())
15894 .ok_or_else(|| {
15895 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15896 })
15897 }
15898
15899 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15900 where
15901 E: serde::de::Error,
15902 {
15903 i32::try_from(v)
15904 .ok()
15905 .and_then(|x| x.try_into().ok())
15906 .ok_or_else(|| {
15907 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15908 })
15909 }
15910
15911 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15912 where
15913 E: serde::de::Error,
15914 {
15915 match value {
15916 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
15917 "SOURCE" => Ok(ThrottleTarget::Source),
15918 "MV" => Ok(ThrottleTarget::Mv),
15919 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
15920 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
15921 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
15922 "SINK" => Ok(ThrottleTarget::Sink),
15923 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
15924 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15925 }
15926 }
15927 }
15928 deserializer.deserialize_any(GeneratedVisitor)
15929 }
15930}
15931impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
15932 #[allow(deprecated)]
15933 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15934 where
15935 S: serde::Serializer,
15936 {
15937 use serde::ser::SerializeStruct;
15938 let mut len = 0;
15939 if self.id != 0 {
15940 len += 1;
15941 }
15942 if !self.node_label.is_empty() {
15943 len += 1;
15944 }
15945 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
15946 if self.id != 0 {
15947 struct_ser.serialize_field("id", &self.id)?;
15948 }
15949 if !self.node_label.is_empty() {
15950 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15951 }
15952 struct_ser.end()
15953 }
15954}
15955impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
15956 #[allow(deprecated)]
15957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15958 where
15959 D: serde::Deserializer<'de>,
15960 {
15961 const FIELDS: &[&str] = &[
15962 "id",
15963 "node_label",
15964 "nodeLabel",
15965 ];
15966
15967 #[allow(clippy::enum_variant_names)]
15968 enum GeneratedField {
15969 Id,
15970 NodeLabel,
15971 }
15972 impl<'de> serde::Deserialize<'de> for GeneratedField {
15973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15974 where
15975 D: serde::Deserializer<'de>,
15976 {
15977 struct GeneratedVisitor;
15978
15979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15980 type Value = GeneratedField;
15981
15982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15983 write!(formatter, "expected one of: {:?}", &FIELDS)
15984 }
15985
15986 #[allow(unused_variables)]
15987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15988 where
15989 E: serde::de::Error,
15990 {
15991 match value {
15992 "id" => Ok(GeneratedField::Id),
15993 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15995 }
15996 }
15997 }
15998 deserializer.deserialize_identifier(GeneratedVisitor)
15999 }
16000 }
16001 struct GeneratedVisitor;
16002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16003 type Value = UpdateStreamingJobNodeLabelsRequest;
16004
16005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16006 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16007 }
16008
16009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16010 where
16011 V: serde::de::MapAccess<'de>,
16012 {
16013 let mut id__ = None;
16014 let mut node_label__ = None;
16015 while let Some(k) = map_.next_key()? {
16016 match k {
16017 GeneratedField::Id => {
16018 if id__.is_some() {
16019 return Err(serde::de::Error::duplicate_field("id"));
16020 }
16021 id__ =
16022 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16023 ;
16024 }
16025 GeneratedField::NodeLabel => {
16026 if node_label__.is_some() {
16027 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16028 }
16029 node_label__ = Some(map_.next_value()?);
16030 }
16031 }
16032 }
16033 Ok(UpdateStreamingJobNodeLabelsRequest {
16034 id: id__.unwrap_or_default(),
16035 node_label: node_label__.unwrap_or_default(),
16036 })
16037 }
16038 }
16039 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16040 }
16041}
16042impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16043 #[allow(deprecated)]
16044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16045 where
16046 S: serde::Serializer,
16047 {
16048 use serde::ser::SerializeStruct;
16049 let len = 0;
16050 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16051 struct_ser.end()
16052 }
16053}
16054impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16055 #[allow(deprecated)]
16056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16057 where
16058 D: serde::Deserializer<'de>,
16059 {
16060 const FIELDS: &[&str] = &[
16061 ];
16062
16063 #[allow(clippy::enum_variant_names)]
16064 enum GeneratedField {
16065 }
16066 impl<'de> serde::Deserialize<'de> for GeneratedField {
16067 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16068 where
16069 D: serde::Deserializer<'de>,
16070 {
16071 struct GeneratedVisitor;
16072
16073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16074 type Value = GeneratedField;
16075
16076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16077 write!(formatter, "expected one of: {:?}", &FIELDS)
16078 }
16079
16080 #[allow(unused_variables)]
16081 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16082 where
16083 E: serde::de::Error,
16084 {
16085 Err(serde::de::Error::unknown_field(value, FIELDS))
16086 }
16087 }
16088 deserializer.deserialize_identifier(GeneratedVisitor)
16089 }
16090 }
16091 struct GeneratedVisitor;
16092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16093 type Value = UpdateStreamingJobNodeLabelsResponse;
16094
16095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16096 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
16097 }
16098
16099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
16100 where
16101 V: serde::de::MapAccess<'de>,
16102 {
16103 while map_.next_key::<GeneratedField>()?.is_some() {
16104 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16105 }
16106 Ok(UpdateStreamingJobNodeLabelsResponse {
16107 })
16108 }
16109 }
16110 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
16111 }
16112}
16113impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
16114 #[allow(deprecated)]
16115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16116 where
16117 S: serde::Serializer,
16118 {
16119 use serde::ser::SerializeStruct;
16120 let mut len = 0;
16121 if !self.worker_ids.is_empty() {
16122 len += 1;
16123 }
16124 if self.schedulability != 0 {
16125 len += 1;
16126 }
16127 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
16128 if !self.worker_ids.is_empty() {
16129 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
16130 }
16131 if self.schedulability != 0 {
16132 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
16133 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
16134 struct_ser.serialize_field("schedulability", &v)?;
16135 }
16136 struct_ser.end()
16137 }
16138}
16139impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
16140 #[allow(deprecated)]
16141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16142 where
16143 D: serde::Deserializer<'de>,
16144 {
16145 const FIELDS: &[&str] = &[
16146 "worker_ids",
16147 "workerIds",
16148 "schedulability",
16149 ];
16150
16151 #[allow(clippy::enum_variant_names)]
16152 enum GeneratedField {
16153 WorkerIds,
16154 Schedulability,
16155 }
16156 impl<'de> serde::Deserialize<'de> for GeneratedField {
16157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16158 where
16159 D: serde::Deserializer<'de>,
16160 {
16161 struct GeneratedVisitor;
16162
16163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16164 type Value = GeneratedField;
16165
16166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16167 write!(formatter, "expected one of: {:?}", &FIELDS)
16168 }
16169
16170 #[allow(unused_variables)]
16171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16172 where
16173 E: serde::de::Error,
16174 {
16175 match value {
16176 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
16177 "schedulability" => Ok(GeneratedField::Schedulability),
16178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16179 }
16180 }
16181 }
16182 deserializer.deserialize_identifier(GeneratedVisitor)
16183 }
16184 }
16185 struct GeneratedVisitor;
16186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16187 type Value = UpdateWorkerNodeSchedulabilityRequest;
16188
16189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16190 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
16191 }
16192
16193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
16194 where
16195 V: serde::de::MapAccess<'de>,
16196 {
16197 let mut worker_ids__ = None;
16198 let mut schedulability__ = None;
16199 while let Some(k) = map_.next_key()? {
16200 match k {
16201 GeneratedField::WorkerIds => {
16202 if worker_ids__.is_some() {
16203 return Err(serde::de::Error::duplicate_field("workerIds"));
16204 }
16205 worker_ids__ =
16206 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16207 .into_iter().map(|x| x.0).collect())
16208 ;
16209 }
16210 GeneratedField::Schedulability => {
16211 if schedulability__.is_some() {
16212 return Err(serde::de::Error::duplicate_field("schedulability"));
16213 }
16214 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
16215 }
16216 }
16217 }
16218 Ok(UpdateWorkerNodeSchedulabilityRequest {
16219 worker_ids: worker_ids__.unwrap_or_default(),
16220 schedulability: schedulability__.unwrap_or_default(),
16221 })
16222 }
16223 }
16224 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
16225 }
16226}
16227impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
16228 #[allow(deprecated)]
16229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16230 where
16231 S: serde::Serializer,
16232 {
16233 let variant = match self {
16234 Self::Unspecified => "UNSPECIFIED",
16235 Self::Schedulable => "SCHEDULABLE",
16236 Self::Unschedulable => "UNSCHEDULABLE",
16237 };
16238 serializer.serialize_str(variant)
16239 }
16240}
16241impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
16242 #[allow(deprecated)]
16243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16244 where
16245 D: serde::Deserializer<'de>,
16246 {
16247 const FIELDS: &[&str] = &[
16248 "UNSPECIFIED",
16249 "SCHEDULABLE",
16250 "UNSCHEDULABLE",
16251 ];
16252
16253 struct GeneratedVisitor;
16254
16255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16256 type Value = update_worker_node_schedulability_request::Schedulability;
16257
16258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16259 write!(formatter, "expected one of: {:?}", &FIELDS)
16260 }
16261
16262 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16263 where
16264 E: serde::de::Error,
16265 {
16266 i32::try_from(v)
16267 .ok()
16268 .and_then(|x| x.try_into().ok())
16269 .ok_or_else(|| {
16270 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16271 })
16272 }
16273
16274 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16275 where
16276 E: serde::de::Error,
16277 {
16278 i32::try_from(v)
16279 .ok()
16280 .and_then(|x| x.try_into().ok())
16281 .ok_or_else(|| {
16282 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16283 })
16284 }
16285
16286 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16287 where
16288 E: serde::de::Error,
16289 {
16290 match value {
16291 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
16292 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
16293 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
16294 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16295 }
16296 }
16297 }
16298 deserializer.deserialize_any(GeneratedVisitor)
16299 }
16300}
16301impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
16302 #[allow(deprecated)]
16303 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16304 where
16305 S: serde::Serializer,
16306 {
16307 use serde::ser::SerializeStruct;
16308 let mut len = 0;
16309 if self.status.is_some() {
16310 len += 1;
16311 }
16312 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
16313 if let Some(v) = self.status.as_ref() {
16314 struct_ser.serialize_field("status", v)?;
16315 }
16316 struct_ser.end()
16317 }
16318}
16319impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
16320 #[allow(deprecated)]
16321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16322 where
16323 D: serde::Deserializer<'de>,
16324 {
16325 const FIELDS: &[&str] = &[
16326 "status",
16327 ];
16328
16329 #[allow(clippy::enum_variant_names)]
16330 enum GeneratedField {
16331 Status,
16332 }
16333 impl<'de> serde::Deserialize<'de> for GeneratedField {
16334 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16335 where
16336 D: serde::Deserializer<'de>,
16337 {
16338 struct GeneratedVisitor;
16339
16340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16341 type Value = GeneratedField;
16342
16343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16344 write!(formatter, "expected one of: {:?}", &FIELDS)
16345 }
16346
16347 #[allow(unused_variables)]
16348 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16349 where
16350 E: serde::de::Error,
16351 {
16352 match value {
16353 "status" => Ok(GeneratedField::Status),
16354 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16355 }
16356 }
16357 }
16358 deserializer.deserialize_identifier(GeneratedVisitor)
16359 }
16360 }
16361 struct GeneratedVisitor;
16362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16363 type Value = UpdateWorkerNodeSchedulabilityResponse;
16364
16365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16366 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
16367 }
16368
16369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
16370 where
16371 V: serde::de::MapAccess<'de>,
16372 {
16373 let mut status__ = None;
16374 while let Some(k) = map_.next_key()? {
16375 match k {
16376 GeneratedField::Status => {
16377 if status__.is_some() {
16378 return Err(serde::de::Error::duplicate_field("status"));
16379 }
16380 status__ = map_.next_value()?;
16381 }
16382 }
16383 }
16384 Ok(UpdateWorkerNodeSchedulabilityResponse {
16385 status: status__,
16386 })
16387 }
16388 }
16389 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
16390 }
16391}
16392impl serde::Serialize for WorkerReschedule {
16393 #[allow(deprecated)]
16394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16395 where
16396 S: serde::Serializer,
16397 {
16398 use serde::ser::SerializeStruct;
16399 let mut len = 0;
16400 if !self.worker_actor_diff.is_empty() {
16401 len += 1;
16402 }
16403 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
16404 if !self.worker_actor_diff.is_empty() {
16405 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
16406 }
16407 struct_ser.end()
16408 }
16409}
16410impl<'de> serde::Deserialize<'de> for WorkerReschedule {
16411 #[allow(deprecated)]
16412 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16413 where
16414 D: serde::Deserializer<'de>,
16415 {
16416 const FIELDS: &[&str] = &[
16417 "worker_actor_diff",
16418 "workerActorDiff",
16419 ];
16420
16421 #[allow(clippy::enum_variant_names)]
16422 enum GeneratedField {
16423 WorkerActorDiff,
16424 }
16425 impl<'de> serde::Deserialize<'de> for GeneratedField {
16426 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16427 where
16428 D: serde::Deserializer<'de>,
16429 {
16430 struct GeneratedVisitor;
16431
16432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16433 type Value = GeneratedField;
16434
16435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16436 write!(formatter, "expected one of: {:?}", &FIELDS)
16437 }
16438
16439 #[allow(unused_variables)]
16440 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16441 where
16442 E: serde::de::Error,
16443 {
16444 match value {
16445 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
16446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16447 }
16448 }
16449 }
16450 deserializer.deserialize_identifier(GeneratedVisitor)
16451 }
16452 }
16453 struct GeneratedVisitor;
16454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16455 type Value = WorkerReschedule;
16456
16457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16458 formatter.write_str("struct meta.WorkerReschedule")
16459 }
16460
16461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
16462 where
16463 V: serde::de::MapAccess<'de>,
16464 {
16465 let mut worker_actor_diff__ = None;
16466 while let Some(k) = map_.next_key()? {
16467 match k {
16468 GeneratedField::WorkerActorDiff => {
16469 if worker_actor_diff__.is_some() {
16470 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
16471 }
16472 worker_actor_diff__ = Some(
16473 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
16474 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16475 );
16476 }
16477 }
16478 }
16479 Ok(WorkerReschedule {
16480 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
16481 })
16482 }
16483 }
16484 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
16485 }
16486}