1#![allow(clippy::useless_conversion)]
2use crate::meta::*;
3impl serde::Serialize for ActivateWorkerNodeRequest {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.host.is_some() {
12 len += 1;
13 }
14 if self.node_id != 0 {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
18 if let Some(v) = self.host.as_ref() {
19 struct_ser.serialize_field("host", v)?;
20 }
21 if self.node_id != 0 {
22 struct_ser.serialize_field("nodeId", &self.node_id)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "host",
35 "node_id",
36 "nodeId",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 Host,
42 NodeId,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl serde::de::Visitor<'_> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "host" => Ok(GeneratedField::Host),
65 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActivateWorkerNodeRequest;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut host__ = None;
86 let mut node_id__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::Host => {
90 if host__.is_some() {
91 return Err(serde::de::Error::duplicate_field("host"));
92 }
93 host__ = map_.next_value()?;
94 }
95 GeneratedField::NodeId => {
96 if node_id__.is_some() {
97 return Err(serde::de::Error::duplicate_field("nodeId"));
98 }
99 node_id__ =
100 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
101 ;
102 }
103 }
104 }
105 Ok(ActivateWorkerNodeRequest {
106 host: host__,
107 node_id: node_id__.unwrap_or_default(),
108 })
109 }
110 }
111 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
112 }
113}
114impl serde::Serialize for ActivateWorkerNodeResponse {
115 #[allow(deprecated)]
116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
117 where
118 S: serde::Serializer,
119 {
120 use serde::ser::SerializeStruct;
121 let mut len = 0;
122 if self.status.is_some() {
123 len += 1;
124 }
125 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
126 if let Some(v) = self.status.as_ref() {
127 struct_ser.serialize_field("status", v)?;
128 }
129 struct_ser.end()
130 }
131}
132impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
133 #[allow(deprecated)]
134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
135 where
136 D: serde::Deserializer<'de>,
137 {
138 const FIELDS: &[&str] = &[
139 "status",
140 ];
141
142 #[allow(clippy::enum_variant_names)]
143 enum GeneratedField {
144 Status,
145 }
146 impl<'de> serde::Deserialize<'de> for GeneratedField {
147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
148 where
149 D: serde::Deserializer<'de>,
150 {
151 struct GeneratedVisitor;
152
153 impl serde::de::Visitor<'_> for GeneratedVisitor {
154 type Value = GeneratedField;
155
156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
157 write!(formatter, "expected one of: {:?}", &FIELDS)
158 }
159
160 #[allow(unused_variables)]
161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
162 where
163 E: serde::de::Error,
164 {
165 match value {
166 "status" => Ok(GeneratedField::Status),
167 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
168 }
169 }
170 }
171 deserializer.deserialize_identifier(GeneratedVisitor)
172 }
173 }
174 struct GeneratedVisitor;
175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
176 type Value = ActivateWorkerNodeResponse;
177
178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
179 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
180 }
181
182 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
183 where
184 V: serde::de::MapAccess<'de>,
185 {
186 let mut status__ = None;
187 while let Some(k) = map_.next_key()? {
188 match k {
189 GeneratedField::Status => {
190 if status__.is_some() {
191 return Err(serde::de::Error::duplicate_field("status"));
192 }
193 status__ = map_.next_value()?;
194 }
195 }
196 }
197 Ok(ActivateWorkerNodeResponse {
198 status: status__,
199 })
200 }
201 }
202 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
203 }
204}
205impl serde::Serialize for ActorCountPerParallelism {
206 #[allow(deprecated)]
207 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
208 where
209 S: serde::Serializer,
210 {
211 use serde::ser::SerializeStruct;
212 let mut len = 0;
213 if !self.worker_id_to_actor_count.is_empty() {
214 len += 1;
215 }
216 if self.hard_limit != 0 {
217 len += 1;
218 }
219 if self.soft_limit != 0 {
220 len += 1;
221 }
222 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
223 if !self.worker_id_to_actor_count.is_empty() {
224 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
225 }
226 if self.hard_limit != 0 {
227 #[allow(clippy::needless_borrow)]
228 #[allow(clippy::needless_borrows_for_generic_args)]
229 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
230 }
231 if self.soft_limit != 0 {
232 #[allow(clippy::needless_borrow)]
233 #[allow(clippy::needless_borrows_for_generic_args)]
234 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
235 }
236 struct_ser.end()
237 }
238}
239impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
240 #[allow(deprecated)]
241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
242 where
243 D: serde::Deserializer<'de>,
244 {
245 const FIELDS: &[&str] = &[
246 "worker_id_to_actor_count",
247 "workerIdToActorCount",
248 "hard_limit",
249 "hardLimit",
250 "soft_limit",
251 "softLimit",
252 ];
253
254 #[allow(clippy::enum_variant_names)]
255 enum GeneratedField {
256 WorkerIdToActorCount,
257 HardLimit,
258 SoftLimit,
259 }
260 impl<'de> serde::Deserialize<'de> for GeneratedField {
261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
262 where
263 D: serde::Deserializer<'de>,
264 {
265 struct GeneratedVisitor;
266
267 impl serde::de::Visitor<'_> for GeneratedVisitor {
268 type Value = GeneratedField;
269
270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
271 write!(formatter, "expected one of: {:?}", &FIELDS)
272 }
273
274 #[allow(unused_variables)]
275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
276 where
277 E: serde::de::Error,
278 {
279 match value {
280 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
281 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
282 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
284 }
285 }
286 }
287 deserializer.deserialize_identifier(GeneratedVisitor)
288 }
289 }
290 struct GeneratedVisitor;
291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
292 type Value = ActorCountPerParallelism;
293
294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
295 formatter.write_str("struct meta.ActorCountPerParallelism")
296 }
297
298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
299 where
300 V: serde::de::MapAccess<'de>,
301 {
302 let mut worker_id_to_actor_count__ = None;
303 let mut hard_limit__ = None;
304 let mut soft_limit__ = None;
305 while let Some(k) = map_.next_key()? {
306 match k {
307 GeneratedField::WorkerIdToActorCount => {
308 if worker_id_to_actor_count__.is_some() {
309 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
310 }
311 worker_id_to_actor_count__ = Some(
312 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
313 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
314 );
315 }
316 GeneratedField::HardLimit => {
317 if hard_limit__.is_some() {
318 return Err(serde::de::Error::duplicate_field("hardLimit"));
319 }
320 hard_limit__ =
321 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
322 ;
323 }
324 GeneratedField::SoftLimit => {
325 if soft_limit__.is_some() {
326 return Err(serde::de::Error::duplicate_field("softLimit"));
327 }
328 soft_limit__ =
329 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
330 ;
331 }
332 }
333 }
334 Ok(ActorCountPerParallelism {
335 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
336 hard_limit: hard_limit__.unwrap_or_default(),
337 soft_limit: soft_limit__.unwrap_or_default(),
338 })
339 }
340 }
341 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
342 }
343}
344impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
345 #[allow(deprecated)]
346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
347 where
348 S: serde::Serializer,
349 {
350 use serde::ser::SerializeStruct;
351 let mut len = 0;
352 if self.actor_count != 0 {
353 len += 1;
354 }
355 if self.parallelism != 0 {
356 len += 1;
357 }
358 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
359 if self.actor_count != 0 {
360 #[allow(clippy::needless_borrow)]
361 #[allow(clippy::needless_borrows_for_generic_args)]
362 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
363 }
364 if self.parallelism != 0 {
365 #[allow(clippy::needless_borrow)]
366 #[allow(clippy::needless_borrows_for_generic_args)]
367 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
368 }
369 struct_ser.end()
370 }
371}
372impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
373 #[allow(deprecated)]
374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
375 where
376 D: serde::Deserializer<'de>,
377 {
378 const FIELDS: &[&str] = &[
379 "actor_count",
380 "actorCount",
381 "parallelism",
382 ];
383
384 #[allow(clippy::enum_variant_names)]
385 enum GeneratedField {
386 ActorCount,
387 Parallelism,
388 }
389 impl<'de> serde::Deserialize<'de> for GeneratedField {
390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
391 where
392 D: serde::Deserializer<'de>,
393 {
394 struct GeneratedVisitor;
395
396 impl serde::de::Visitor<'_> for GeneratedVisitor {
397 type Value = GeneratedField;
398
399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
400 write!(formatter, "expected one of: {:?}", &FIELDS)
401 }
402
403 #[allow(unused_variables)]
404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
405 where
406 E: serde::de::Error,
407 {
408 match value {
409 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
410 "parallelism" => Ok(GeneratedField::Parallelism),
411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
412 }
413 }
414 }
415 deserializer.deserialize_identifier(GeneratedVisitor)
416 }
417 }
418 struct GeneratedVisitor;
419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
420 type Value = actor_count_per_parallelism::WorkerActorCount;
421
422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
423 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
424 }
425
426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
427 where
428 V: serde::de::MapAccess<'de>,
429 {
430 let mut actor_count__ = None;
431 let mut parallelism__ = None;
432 while let Some(k) = map_.next_key()? {
433 match k {
434 GeneratedField::ActorCount => {
435 if actor_count__.is_some() {
436 return Err(serde::de::Error::duplicate_field("actorCount"));
437 }
438 actor_count__ =
439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
440 ;
441 }
442 GeneratedField::Parallelism => {
443 if parallelism__.is_some() {
444 return Err(serde::de::Error::duplicate_field("parallelism"));
445 }
446 parallelism__ =
447 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
448 ;
449 }
450 }
451 }
452 Ok(actor_count_per_parallelism::WorkerActorCount {
453 actor_count: actor_count__.unwrap_or_default(),
454 parallelism: parallelism__.unwrap_or_default(),
455 })
456 }
457 }
458 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
459 }
460}
461impl serde::Serialize for ActorIds {
462 #[allow(deprecated)]
463 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
464 where
465 S: serde::Serializer,
466 {
467 use serde::ser::SerializeStruct;
468 let mut len = 0;
469 if !self.ids.is_empty() {
470 len += 1;
471 }
472 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
473 if !self.ids.is_empty() {
474 struct_ser.serialize_field("ids", &self.ids)?;
475 }
476 struct_ser.end()
477 }
478}
479impl<'de> serde::Deserialize<'de> for ActorIds {
480 #[allow(deprecated)]
481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
482 where
483 D: serde::Deserializer<'de>,
484 {
485 const FIELDS: &[&str] = &[
486 "ids",
487 ];
488
489 #[allow(clippy::enum_variant_names)]
490 enum GeneratedField {
491 Ids,
492 }
493 impl<'de> serde::Deserialize<'de> for GeneratedField {
494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
495 where
496 D: serde::Deserializer<'de>,
497 {
498 struct GeneratedVisitor;
499
500 impl serde::de::Visitor<'_> for GeneratedVisitor {
501 type Value = GeneratedField;
502
503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
504 write!(formatter, "expected one of: {:?}", &FIELDS)
505 }
506
507 #[allow(unused_variables)]
508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
509 where
510 E: serde::de::Error,
511 {
512 match value {
513 "ids" => Ok(GeneratedField::Ids),
514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
515 }
516 }
517 }
518 deserializer.deserialize_identifier(GeneratedVisitor)
519 }
520 }
521 struct GeneratedVisitor;
522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
523 type Value = ActorIds;
524
525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
526 formatter.write_str("struct meta.ActorIds")
527 }
528
529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
530 where
531 V: serde::de::MapAccess<'de>,
532 {
533 let mut ids__ = None;
534 while let Some(k) = map_.next_key()? {
535 match k {
536 GeneratedField::Ids => {
537 if ids__.is_some() {
538 return Err(serde::de::Error::duplicate_field("ids"));
539 }
540 ids__ =
541 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
542 .into_iter().map(|x| x.0).collect())
543 ;
544 }
545 }
546 }
547 Ok(ActorIds {
548 ids: ids__.unwrap_or_default(),
549 })
550 }
551 }
552 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
553 }
554}
555impl serde::Serialize for ActorLocation {
556 #[allow(deprecated)]
557 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
558 where
559 S: serde::Serializer,
560 {
561 use serde::ser::SerializeStruct;
562 let mut len = 0;
563 if self.node.is_some() {
564 len += 1;
565 }
566 if !self.actors.is_empty() {
567 len += 1;
568 }
569 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
570 if let Some(v) = self.node.as_ref() {
571 struct_ser.serialize_field("node", v)?;
572 }
573 if !self.actors.is_empty() {
574 struct_ser.serialize_field("actors", &self.actors)?;
575 }
576 struct_ser.end()
577 }
578}
579impl<'de> serde::Deserialize<'de> for ActorLocation {
580 #[allow(deprecated)]
581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
582 where
583 D: serde::Deserializer<'de>,
584 {
585 const FIELDS: &[&str] = &[
586 "node",
587 "actors",
588 ];
589
590 #[allow(clippy::enum_variant_names)]
591 enum GeneratedField {
592 Node,
593 Actors,
594 }
595 impl<'de> serde::Deserialize<'de> for GeneratedField {
596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
597 where
598 D: serde::Deserializer<'de>,
599 {
600 struct GeneratedVisitor;
601
602 impl serde::de::Visitor<'_> for GeneratedVisitor {
603 type Value = GeneratedField;
604
605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
606 write!(formatter, "expected one of: {:?}", &FIELDS)
607 }
608
609 #[allow(unused_variables)]
610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
611 where
612 E: serde::de::Error,
613 {
614 match value {
615 "node" => Ok(GeneratedField::Node),
616 "actors" => Ok(GeneratedField::Actors),
617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
618 }
619 }
620 }
621 deserializer.deserialize_identifier(GeneratedVisitor)
622 }
623 }
624 struct GeneratedVisitor;
625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
626 type Value = ActorLocation;
627
628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629 formatter.write_str("struct meta.ActorLocation")
630 }
631
632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
633 where
634 V: serde::de::MapAccess<'de>,
635 {
636 let mut node__ = None;
637 let mut actors__ = None;
638 while let Some(k) = map_.next_key()? {
639 match k {
640 GeneratedField::Node => {
641 if node__.is_some() {
642 return Err(serde::de::Error::duplicate_field("node"));
643 }
644 node__ = map_.next_value()?;
645 }
646 GeneratedField::Actors => {
647 if actors__.is_some() {
648 return Err(serde::de::Error::duplicate_field("actors"));
649 }
650 actors__ = Some(map_.next_value()?);
651 }
652 }
653 }
654 Ok(ActorLocation {
655 node: node__,
656 actors: actors__.unwrap_or_default(),
657 })
658 }
659 }
660 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
661 }
662}
663impl serde::Serialize for AddEventLogRequest {
664 #[allow(deprecated)]
665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
666 where
667 S: serde::Serializer,
668 {
669 use serde::ser::SerializeStruct;
670 let mut len = 0;
671 if self.event.is_some() {
672 len += 1;
673 }
674 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
675 if let Some(v) = self.event.as_ref() {
676 match v {
677 add_event_log_request::Event::WorkerNodePanic(v) => {
678 struct_ser.serialize_field("workerNodePanic", v)?;
679 }
680 add_event_log_request::Event::SinkFail(v) => {
681 struct_ser.serialize_field("sinkFail", v)?;
682 }
683 add_event_log_request::Event::AutoSchemaChangeFail(v) => {
684 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
685 }
686 }
687 }
688 struct_ser.end()
689 }
690}
691impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
692 #[allow(deprecated)]
693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
694 where
695 D: serde::Deserializer<'de>,
696 {
697 const FIELDS: &[&str] = &[
698 "worker_node_panic",
699 "workerNodePanic",
700 "sink_fail",
701 "sinkFail",
702 "auto_schema_change_fail",
703 "autoSchemaChangeFail",
704 ];
705
706 #[allow(clippy::enum_variant_names)]
707 enum GeneratedField {
708 WorkerNodePanic,
709 SinkFail,
710 AutoSchemaChangeFail,
711 }
712 impl<'de> serde::Deserialize<'de> for GeneratedField {
713 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
714 where
715 D: serde::Deserializer<'de>,
716 {
717 struct GeneratedVisitor;
718
719 impl serde::de::Visitor<'_> for GeneratedVisitor {
720 type Value = GeneratedField;
721
722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
723 write!(formatter, "expected one of: {:?}", &FIELDS)
724 }
725
726 #[allow(unused_variables)]
727 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
728 where
729 E: serde::de::Error,
730 {
731 match value {
732 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
733 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
734 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
736 }
737 }
738 }
739 deserializer.deserialize_identifier(GeneratedVisitor)
740 }
741 }
742 struct GeneratedVisitor;
743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
744 type Value = AddEventLogRequest;
745
746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
747 formatter.write_str("struct meta.AddEventLogRequest")
748 }
749
750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
751 where
752 V: serde::de::MapAccess<'de>,
753 {
754 let mut event__ = None;
755 while let Some(k) = map_.next_key()? {
756 match k {
757 GeneratedField::WorkerNodePanic => {
758 if event__.is_some() {
759 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
760 }
761 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
762;
763 }
764 GeneratedField::SinkFail => {
765 if event__.is_some() {
766 return Err(serde::de::Error::duplicate_field("sinkFail"));
767 }
768 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
769;
770 }
771 GeneratedField::AutoSchemaChangeFail => {
772 if event__.is_some() {
773 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
774 }
775 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
776;
777 }
778 }
779 }
780 Ok(AddEventLogRequest {
781 event: event__,
782 })
783 }
784 }
785 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
786 }
787}
788impl serde::Serialize for AddEventLogResponse {
789 #[allow(deprecated)]
790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
791 where
792 S: serde::Serializer,
793 {
794 use serde::ser::SerializeStruct;
795 let len = 0;
796 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
797 struct_ser.end()
798 }
799}
800impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
801 #[allow(deprecated)]
802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
803 where
804 D: serde::Deserializer<'de>,
805 {
806 const FIELDS: &[&str] = &[
807 ];
808
809 #[allow(clippy::enum_variant_names)]
810 enum GeneratedField {
811 }
812 impl<'de> serde::Deserialize<'de> for GeneratedField {
813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
814 where
815 D: serde::Deserializer<'de>,
816 {
817 struct GeneratedVisitor;
818
819 impl serde::de::Visitor<'_> for GeneratedVisitor {
820 type Value = GeneratedField;
821
822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823 write!(formatter, "expected one of: {:?}", &FIELDS)
824 }
825
826 #[allow(unused_variables)]
827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
828 where
829 E: serde::de::Error,
830 {
831 Err(serde::de::Error::unknown_field(value, FIELDS))
832 }
833 }
834 deserializer.deserialize_identifier(GeneratedVisitor)
835 }
836 }
837 struct GeneratedVisitor;
838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
839 type Value = AddEventLogResponse;
840
841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
842 formatter.write_str("struct meta.AddEventLogResponse")
843 }
844
845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
846 where
847 V: serde::de::MapAccess<'de>,
848 {
849 while map_.next_key::<GeneratedField>()?.is_some() {
850 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
851 }
852 Ok(AddEventLogResponse {
853 })
854 }
855 }
856 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
857 }
858}
859impl serde::Serialize for AddWorkerNodeRequest {
860 #[allow(deprecated)]
861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
862 where
863 S: serde::Serializer,
864 {
865 use serde::ser::SerializeStruct;
866 let mut len = 0;
867 if self.worker_type != 0 {
868 len += 1;
869 }
870 if self.host.is_some() {
871 len += 1;
872 }
873 if self.resource.is_some() {
874 len += 1;
875 }
876 if self.property.is_some() {
877 len += 1;
878 }
879 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
880 if self.worker_type != 0 {
881 let v = super::common::WorkerType::try_from(self.worker_type)
882 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
883 struct_ser.serialize_field("workerType", &v)?;
884 }
885 if let Some(v) = self.host.as_ref() {
886 struct_ser.serialize_field("host", v)?;
887 }
888 if let Some(v) = self.resource.as_ref() {
889 struct_ser.serialize_field("resource", v)?;
890 }
891 if let Some(v) = self.property.as_ref() {
892 struct_ser.serialize_field("property", v)?;
893 }
894 struct_ser.end()
895 }
896}
897impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
898 #[allow(deprecated)]
899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
900 where
901 D: serde::Deserializer<'de>,
902 {
903 const FIELDS: &[&str] = &[
904 "worker_type",
905 "workerType",
906 "host",
907 "resource",
908 "property",
909 ];
910
911 #[allow(clippy::enum_variant_names)]
912 enum GeneratedField {
913 WorkerType,
914 Host,
915 Resource,
916 Property,
917 }
918 impl<'de> serde::Deserialize<'de> for GeneratedField {
919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
920 where
921 D: serde::Deserializer<'de>,
922 {
923 struct GeneratedVisitor;
924
925 impl serde::de::Visitor<'_> for GeneratedVisitor {
926 type Value = GeneratedField;
927
928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
929 write!(formatter, "expected one of: {:?}", &FIELDS)
930 }
931
932 #[allow(unused_variables)]
933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
934 where
935 E: serde::de::Error,
936 {
937 match value {
938 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
939 "host" => Ok(GeneratedField::Host),
940 "resource" => Ok(GeneratedField::Resource),
941 "property" => Ok(GeneratedField::Property),
942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
943 }
944 }
945 }
946 deserializer.deserialize_identifier(GeneratedVisitor)
947 }
948 }
949 struct GeneratedVisitor;
950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
951 type Value = AddWorkerNodeRequest;
952
953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
954 formatter.write_str("struct meta.AddWorkerNodeRequest")
955 }
956
957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
958 where
959 V: serde::de::MapAccess<'de>,
960 {
961 let mut worker_type__ = None;
962 let mut host__ = None;
963 let mut resource__ = None;
964 let mut property__ = None;
965 while let Some(k) = map_.next_key()? {
966 match k {
967 GeneratedField::WorkerType => {
968 if worker_type__.is_some() {
969 return Err(serde::de::Error::duplicate_field("workerType"));
970 }
971 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
972 }
973 GeneratedField::Host => {
974 if host__.is_some() {
975 return Err(serde::de::Error::duplicate_field("host"));
976 }
977 host__ = map_.next_value()?;
978 }
979 GeneratedField::Resource => {
980 if resource__.is_some() {
981 return Err(serde::de::Error::duplicate_field("resource"));
982 }
983 resource__ = map_.next_value()?;
984 }
985 GeneratedField::Property => {
986 if property__.is_some() {
987 return Err(serde::de::Error::duplicate_field("property"));
988 }
989 property__ = map_.next_value()?;
990 }
991 }
992 }
993 Ok(AddWorkerNodeRequest {
994 worker_type: worker_type__.unwrap_or_default(),
995 host: host__,
996 resource: resource__,
997 property: property__,
998 })
999 }
1000 }
1001 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1002 }
1003}
1004impl serde::Serialize for AddWorkerNodeResponse {
1005 #[allow(deprecated)]
1006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1007 where
1008 S: serde::Serializer,
1009 {
1010 use serde::ser::SerializeStruct;
1011 let mut len = 0;
1012 if self.node_id.is_some() {
1013 len += 1;
1014 }
1015 if !self.cluster_id.is_empty() {
1016 len += 1;
1017 }
1018 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1019 if let Some(v) = self.node_id.as_ref() {
1020 struct_ser.serialize_field("nodeId", v)?;
1021 }
1022 if !self.cluster_id.is_empty() {
1023 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1024 }
1025 struct_ser.end()
1026 }
1027}
1028impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1029 #[allow(deprecated)]
1030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1031 where
1032 D: serde::Deserializer<'de>,
1033 {
1034 const FIELDS: &[&str] = &[
1035 "node_id",
1036 "nodeId",
1037 "cluster_id",
1038 "clusterId",
1039 ];
1040
1041 #[allow(clippy::enum_variant_names)]
1042 enum GeneratedField {
1043 NodeId,
1044 ClusterId,
1045 }
1046 impl<'de> serde::Deserialize<'de> for GeneratedField {
1047 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1048 where
1049 D: serde::Deserializer<'de>,
1050 {
1051 struct GeneratedVisitor;
1052
1053 impl serde::de::Visitor<'_> for GeneratedVisitor {
1054 type Value = GeneratedField;
1055
1056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1057 write!(formatter, "expected one of: {:?}", &FIELDS)
1058 }
1059
1060 #[allow(unused_variables)]
1061 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1062 where
1063 E: serde::de::Error,
1064 {
1065 match value {
1066 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1067 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1069 }
1070 }
1071 }
1072 deserializer.deserialize_identifier(GeneratedVisitor)
1073 }
1074 }
1075 struct GeneratedVisitor;
1076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1077 type Value = AddWorkerNodeResponse;
1078
1079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1080 formatter.write_str("struct meta.AddWorkerNodeResponse")
1081 }
1082
1083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1084 where
1085 V: serde::de::MapAccess<'de>,
1086 {
1087 let mut node_id__ = None;
1088 let mut cluster_id__ = None;
1089 while let Some(k) = map_.next_key()? {
1090 match k {
1091 GeneratedField::NodeId => {
1092 if node_id__.is_some() {
1093 return Err(serde::de::Error::duplicate_field("nodeId"));
1094 }
1095 node_id__ =
1096 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1097 ;
1098 }
1099 GeneratedField::ClusterId => {
1100 if cluster_id__.is_some() {
1101 return Err(serde::de::Error::duplicate_field("clusterId"));
1102 }
1103 cluster_id__ = Some(map_.next_value()?);
1104 }
1105 }
1106 }
1107 Ok(AddWorkerNodeResponse {
1108 node_id: node_id__,
1109 cluster_id: cluster_id__.unwrap_or_default(),
1110 })
1111 }
1112 }
1113 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1114 }
1115}
1116impl serde::Serialize for AlterConnectorPropsRequest {
1117 #[allow(deprecated)]
1118 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1119 where
1120 S: serde::Serializer,
1121 {
1122 use serde::ser::SerializeStruct;
1123 let mut len = 0;
1124 if self.object_id != 0 {
1125 len += 1;
1126 }
1127 if !self.changed_props.is_empty() {
1128 len += 1;
1129 }
1130 if !self.changed_secret_refs.is_empty() {
1131 len += 1;
1132 }
1133 if self.connector_conn_ref.is_some() {
1134 len += 1;
1135 }
1136 if self.object_type != 0 {
1137 len += 1;
1138 }
1139 if self.extra_options.is_some() {
1140 len += 1;
1141 }
1142 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1143 if self.object_id != 0 {
1144 struct_ser.serialize_field("objectId", &self.object_id)?;
1145 }
1146 if !self.changed_props.is_empty() {
1147 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1148 }
1149 if !self.changed_secret_refs.is_empty() {
1150 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1151 }
1152 if let Some(v) = self.connector_conn_ref.as_ref() {
1153 struct_ser.serialize_field("connectorConnRef", v)?;
1154 }
1155 if self.object_type != 0 {
1156 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1157 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1158 struct_ser.serialize_field("objectType", &v)?;
1159 }
1160 if let Some(v) = self.extra_options.as_ref() {
1161 match v {
1162 alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1163 struct_ser.serialize_field("alterIcebergTableIds", v)?;
1164 }
1165 }
1166 }
1167 struct_ser.end()
1168 }
1169}
1170impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1171 #[allow(deprecated)]
1172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1173 where
1174 D: serde::Deserializer<'de>,
1175 {
1176 const FIELDS: &[&str] = &[
1177 "object_id",
1178 "objectId",
1179 "changed_props",
1180 "changedProps",
1181 "changed_secret_refs",
1182 "changedSecretRefs",
1183 "connector_conn_ref",
1184 "connectorConnRef",
1185 "object_type",
1186 "objectType",
1187 "alter_iceberg_table_ids",
1188 "alterIcebergTableIds",
1189 ];
1190
1191 #[allow(clippy::enum_variant_names)]
1192 enum GeneratedField {
1193 ObjectId,
1194 ChangedProps,
1195 ChangedSecretRefs,
1196 ConnectorConnRef,
1197 ObjectType,
1198 AlterIcebergTableIds,
1199 }
1200 impl<'de> serde::Deserialize<'de> for GeneratedField {
1201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1202 where
1203 D: serde::Deserializer<'de>,
1204 {
1205 struct GeneratedVisitor;
1206
1207 impl serde::de::Visitor<'_> for GeneratedVisitor {
1208 type Value = GeneratedField;
1209
1210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1211 write!(formatter, "expected one of: {:?}", &FIELDS)
1212 }
1213
1214 #[allow(unused_variables)]
1215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1216 where
1217 E: serde::de::Error,
1218 {
1219 match value {
1220 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1221 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1222 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1223 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1224 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1225 "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1226 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1227 }
1228 }
1229 }
1230 deserializer.deserialize_identifier(GeneratedVisitor)
1231 }
1232 }
1233 struct GeneratedVisitor;
1234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1235 type Value = AlterConnectorPropsRequest;
1236
1237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1238 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1239 }
1240
1241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1242 where
1243 V: serde::de::MapAccess<'de>,
1244 {
1245 let mut object_id__ = None;
1246 let mut changed_props__ = None;
1247 let mut changed_secret_refs__ = None;
1248 let mut connector_conn_ref__ = None;
1249 let mut object_type__ = None;
1250 let mut extra_options__ = None;
1251 while let Some(k) = map_.next_key()? {
1252 match k {
1253 GeneratedField::ObjectId => {
1254 if object_id__.is_some() {
1255 return Err(serde::de::Error::duplicate_field("objectId"));
1256 }
1257 object_id__ =
1258 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1259 ;
1260 }
1261 GeneratedField::ChangedProps => {
1262 if changed_props__.is_some() {
1263 return Err(serde::de::Error::duplicate_field("changedProps"));
1264 }
1265 changed_props__ = Some(
1266 map_.next_value::<std::collections::HashMap<_, _>>()?
1267 );
1268 }
1269 GeneratedField::ChangedSecretRefs => {
1270 if changed_secret_refs__.is_some() {
1271 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1272 }
1273 changed_secret_refs__ = Some(
1274 map_.next_value::<std::collections::HashMap<_, _>>()?
1275 );
1276 }
1277 GeneratedField::ConnectorConnRef => {
1278 if connector_conn_ref__.is_some() {
1279 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1280 }
1281 connector_conn_ref__ =
1282 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1283 ;
1284 }
1285 GeneratedField::ObjectType => {
1286 if object_type__.is_some() {
1287 return Err(serde::de::Error::duplicate_field("objectType"));
1288 }
1289 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1290 }
1291 GeneratedField::AlterIcebergTableIds => {
1292 if extra_options__.is_some() {
1293 return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1294 }
1295 extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1296;
1297 }
1298 }
1299 }
1300 Ok(AlterConnectorPropsRequest {
1301 object_id: object_id__.unwrap_or_default(),
1302 changed_props: changed_props__.unwrap_or_default(),
1303 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1304 connector_conn_ref: connector_conn_ref__,
1305 object_type: object_type__.unwrap_or_default(),
1306 extra_options: extra_options__,
1307 })
1308 }
1309 }
1310 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1311 }
1312}
1313impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1314 #[allow(deprecated)]
1315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1316 where
1317 S: serde::Serializer,
1318 {
1319 let variant = match self {
1320 Self::Unspecified => "UNSPECIFIED",
1321 Self::Source => "SOURCE",
1322 Self::Sink => "SINK",
1323 Self::Connection => "CONNECTION",
1324 Self::IcebergTable => "ICEBERG_TABLE",
1325 };
1326 serializer.serialize_str(variant)
1327 }
1328}
1329impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1330 #[allow(deprecated)]
1331 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1332 where
1333 D: serde::Deserializer<'de>,
1334 {
1335 const FIELDS: &[&str] = &[
1336 "UNSPECIFIED",
1337 "SOURCE",
1338 "SINK",
1339 "CONNECTION",
1340 "ICEBERG_TABLE",
1341 ];
1342
1343 struct GeneratedVisitor;
1344
1345 impl serde::de::Visitor<'_> for GeneratedVisitor {
1346 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1347
1348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1349 write!(formatter, "expected one of: {:?}", &FIELDS)
1350 }
1351
1352 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1353 where
1354 E: serde::de::Error,
1355 {
1356 i32::try_from(v)
1357 .ok()
1358 .and_then(|x| x.try_into().ok())
1359 .ok_or_else(|| {
1360 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1361 })
1362 }
1363
1364 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1365 where
1366 E: serde::de::Error,
1367 {
1368 i32::try_from(v)
1369 .ok()
1370 .and_then(|x| x.try_into().ok())
1371 .ok_or_else(|| {
1372 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1373 })
1374 }
1375
1376 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1377 where
1378 E: serde::de::Error,
1379 {
1380 match value {
1381 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1382 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1383 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1384 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1385 "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1386 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1387 }
1388 }
1389 }
1390 deserializer.deserialize_any(GeneratedVisitor)
1391 }
1392}
1393impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1394 #[allow(deprecated)]
1395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1396 where
1397 S: serde::Serializer,
1398 {
1399 use serde::ser::SerializeStruct;
1400 let mut len = 0;
1401 if self.source_id != 0 {
1402 len += 1;
1403 }
1404 if self.sink_id != 0 {
1405 len += 1;
1406 }
1407 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1408 if self.source_id != 0 {
1409 struct_ser.serialize_field("sourceId", &self.source_id)?;
1410 }
1411 if self.sink_id != 0 {
1412 struct_ser.serialize_field("sinkId", &self.sink_id)?;
1413 }
1414 struct_ser.end()
1415 }
1416}
1417impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1418 #[allow(deprecated)]
1419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1420 where
1421 D: serde::Deserializer<'de>,
1422 {
1423 const FIELDS: &[&str] = &[
1424 "source_id",
1425 "sourceId",
1426 "sink_id",
1427 "sinkId",
1428 ];
1429
1430 #[allow(clippy::enum_variant_names)]
1431 enum GeneratedField {
1432 SourceId,
1433 SinkId,
1434 }
1435 impl<'de> serde::Deserialize<'de> for GeneratedField {
1436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1437 where
1438 D: serde::Deserializer<'de>,
1439 {
1440 struct GeneratedVisitor;
1441
1442 impl serde::de::Visitor<'_> for GeneratedVisitor {
1443 type Value = GeneratedField;
1444
1445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1446 write!(formatter, "expected one of: {:?}", &FIELDS)
1447 }
1448
1449 #[allow(unused_variables)]
1450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1451 where
1452 E: serde::de::Error,
1453 {
1454 match value {
1455 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1456 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1457 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1458 }
1459 }
1460 }
1461 deserializer.deserialize_identifier(GeneratedVisitor)
1462 }
1463 }
1464 struct GeneratedVisitor;
1465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1466 type Value = alter_connector_props_request::AlterIcebergTableIds;
1467
1468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1469 formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1470 }
1471
1472 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1473 where
1474 V: serde::de::MapAccess<'de>,
1475 {
1476 let mut source_id__ = None;
1477 let mut sink_id__ = None;
1478 while let Some(k) = map_.next_key()? {
1479 match k {
1480 GeneratedField::SourceId => {
1481 if source_id__.is_some() {
1482 return Err(serde::de::Error::duplicate_field("sourceId"));
1483 }
1484 source_id__ =
1485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1486 ;
1487 }
1488 GeneratedField::SinkId => {
1489 if sink_id__.is_some() {
1490 return Err(serde::de::Error::duplicate_field("sinkId"));
1491 }
1492 sink_id__ =
1493 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1494 ;
1495 }
1496 }
1497 }
1498 Ok(alter_connector_props_request::AlterIcebergTableIds {
1499 source_id: source_id__.unwrap_or_default(),
1500 sink_id: sink_id__.unwrap_or_default(),
1501 })
1502 }
1503 }
1504 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1505 }
1506}
1507impl serde::Serialize for AlterConnectorPropsResponse {
1508 #[allow(deprecated)]
1509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1510 where
1511 S: serde::Serializer,
1512 {
1513 use serde::ser::SerializeStruct;
1514 let len = 0;
1515 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1516 struct_ser.end()
1517 }
1518}
1519impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1520 #[allow(deprecated)]
1521 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1522 where
1523 D: serde::Deserializer<'de>,
1524 {
1525 const FIELDS: &[&str] = &[
1526 ];
1527
1528 #[allow(clippy::enum_variant_names)]
1529 enum GeneratedField {
1530 }
1531 impl<'de> serde::Deserialize<'de> for GeneratedField {
1532 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1533 where
1534 D: serde::Deserializer<'de>,
1535 {
1536 struct GeneratedVisitor;
1537
1538 impl serde::de::Visitor<'_> for GeneratedVisitor {
1539 type Value = GeneratedField;
1540
1541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1542 write!(formatter, "expected one of: {:?}", &FIELDS)
1543 }
1544
1545 #[allow(unused_variables)]
1546 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1547 where
1548 E: serde::de::Error,
1549 {
1550 Err(serde::de::Error::unknown_field(value, FIELDS))
1551 }
1552 }
1553 deserializer.deserialize_identifier(GeneratedVisitor)
1554 }
1555 }
1556 struct GeneratedVisitor;
1557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1558 type Value = AlterConnectorPropsResponse;
1559
1560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1561 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1562 }
1563
1564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1565 where
1566 V: serde::de::MapAccess<'de>,
1567 {
1568 while map_.next_key::<GeneratedField>()?.is_some() {
1569 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1570 }
1571 Ok(AlterConnectorPropsResponse {
1572 })
1573 }
1574 }
1575 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1576 }
1577}
1578impl serde::Serialize for ApplyThrottleRequest {
1579 #[allow(deprecated)]
1580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1581 where
1582 S: serde::Serializer,
1583 {
1584 use serde::ser::SerializeStruct;
1585 let mut len = 0;
1586 if self.throttle_target != 0 {
1587 len += 1;
1588 }
1589 if self.throttle_type != 0 {
1590 len += 1;
1591 }
1592 if self.id != 0 {
1593 len += 1;
1594 }
1595 if self.rate.is_some() {
1596 len += 1;
1597 }
1598 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1599 if self.throttle_target != 0 {
1600 let v = ThrottleTarget::try_from(self.throttle_target)
1601 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_target)))?;
1602 struct_ser.serialize_field("throttleTarget", &v)?;
1603 }
1604 if self.throttle_type != 0 {
1605 let v = super::common::ThrottleType::try_from(self.throttle_type)
1606 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
1607 struct_ser.serialize_field("throttleType", &v)?;
1608 }
1609 if self.id != 0 {
1610 struct_ser.serialize_field("id", &self.id)?;
1611 }
1612 if let Some(v) = self.rate.as_ref() {
1613 struct_ser.serialize_field("rate", v)?;
1614 }
1615 struct_ser.end()
1616 }
1617}
1618impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1619 #[allow(deprecated)]
1620 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1621 where
1622 D: serde::Deserializer<'de>,
1623 {
1624 const FIELDS: &[&str] = &[
1625 "throttle_target",
1626 "throttleTarget",
1627 "throttle_type",
1628 "throttleType",
1629 "id",
1630 "rate",
1631 ];
1632
1633 #[allow(clippy::enum_variant_names)]
1634 enum GeneratedField {
1635 ThrottleTarget,
1636 ThrottleType,
1637 Id,
1638 Rate,
1639 }
1640 impl<'de> serde::Deserialize<'de> for GeneratedField {
1641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1642 where
1643 D: serde::Deserializer<'de>,
1644 {
1645 struct GeneratedVisitor;
1646
1647 impl serde::de::Visitor<'_> for GeneratedVisitor {
1648 type Value = GeneratedField;
1649
1650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1651 write!(formatter, "expected one of: {:?}", &FIELDS)
1652 }
1653
1654 #[allow(unused_variables)]
1655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1656 where
1657 E: serde::de::Error,
1658 {
1659 match value {
1660 "throttleTarget" | "throttle_target" => Ok(GeneratedField::ThrottleTarget),
1661 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
1662 "id" => Ok(GeneratedField::Id),
1663 "rate" => Ok(GeneratedField::Rate),
1664 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1665 }
1666 }
1667 }
1668 deserializer.deserialize_identifier(GeneratedVisitor)
1669 }
1670 }
1671 struct GeneratedVisitor;
1672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1673 type Value = ApplyThrottleRequest;
1674
1675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1676 formatter.write_str("struct meta.ApplyThrottleRequest")
1677 }
1678
1679 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1680 where
1681 V: serde::de::MapAccess<'de>,
1682 {
1683 let mut throttle_target__ = None;
1684 let mut throttle_type__ = None;
1685 let mut id__ = None;
1686 let mut rate__ = None;
1687 while let Some(k) = map_.next_key()? {
1688 match k {
1689 GeneratedField::ThrottleTarget => {
1690 if throttle_target__.is_some() {
1691 return Err(serde::de::Error::duplicate_field("throttleTarget"));
1692 }
1693 throttle_target__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1694 }
1695 GeneratedField::ThrottleType => {
1696 if throttle_type__.is_some() {
1697 return Err(serde::de::Error::duplicate_field("throttleType"));
1698 }
1699 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
1700 }
1701 GeneratedField::Id => {
1702 if id__.is_some() {
1703 return Err(serde::de::Error::duplicate_field("id"));
1704 }
1705 id__ =
1706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1707 ;
1708 }
1709 GeneratedField::Rate => {
1710 if rate__.is_some() {
1711 return Err(serde::de::Error::duplicate_field("rate"));
1712 }
1713 rate__ =
1714 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1715 ;
1716 }
1717 }
1718 }
1719 Ok(ApplyThrottleRequest {
1720 throttle_target: throttle_target__.unwrap_or_default(),
1721 throttle_type: throttle_type__.unwrap_or_default(),
1722 id: id__.unwrap_or_default(),
1723 rate: rate__,
1724 })
1725 }
1726 }
1727 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1728 }
1729}
1730impl serde::Serialize for ApplyThrottleResponse {
1731 #[allow(deprecated)]
1732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1733 where
1734 S: serde::Serializer,
1735 {
1736 use serde::ser::SerializeStruct;
1737 let mut len = 0;
1738 if self.status.is_some() {
1739 len += 1;
1740 }
1741 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1742 if let Some(v) = self.status.as_ref() {
1743 struct_ser.serialize_field("status", v)?;
1744 }
1745 struct_ser.end()
1746 }
1747}
1748impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1749 #[allow(deprecated)]
1750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1751 where
1752 D: serde::Deserializer<'de>,
1753 {
1754 const FIELDS: &[&str] = &[
1755 "status",
1756 ];
1757
1758 #[allow(clippy::enum_variant_names)]
1759 enum GeneratedField {
1760 Status,
1761 }
1762 impl<'de> serde::Deserialize<'de> for GeneratedField {
1763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1764 where
1765 D: serde::Deserializer<'de>,
1766 {
1767 struct GeneratedVisitor;
1768
1769 impl serde::de::Visitor<'_> for GeneratedVisitor {
1770 type Value = GeneratedField;
1771
1772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1773 write!(formatter, "expected one of: {:?}", &FIELDS)
1774 }
1775
1776 #[allow(unused_variables)]
1777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1778 where
1779 E: serde::de::Error,
1780 {
1781 match value {
1782 "status" => Ok(GeneratedField::Status),
1783 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1784 }
1785 }
1786 }
1787 deserializer.deserialize_identifier(GeneratedVisitor)
1788 }
1789 }
1790 struct GeneratedVisitor;
1791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1792 type Value = ApplyThrottleResponse;
1793
1794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1795 formatter.write_str("struct meta.ApplyThrottleResponse")
1796 }
1797
1798 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1799 where
1800 V: serde::de::MapAccess<'de>,
1801 {
1802 let mut status__ = None;
1803 while let Some(k) = map_.next_key()? {
1804 match k {
1805 GeneratedField::Status => {
1806 if status__.is_some() {
1807 return Err(serde::de::Error::duplicate_field("status"));
1808 }
1809 status__ = map_.next_value()?;
1810 }
1811 }
1812 }
1813 Ok(ApplyThrottleResponse {
1814 status: status__,
1815 })
1816 }
1817 }
1818 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1819 }
1820}
1821impl serde::Serialize for CancelCreatingJobsRequest {
1822 #[allow(deprecated)]
1823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1824 where
1825 S: serde::Serializer,
1826 {
1827 use serde::ser::SerializeStruct;
1828 let mut len = 0;
1829 if self.jobs.is_some() {
1830 len += 1;
1831 }
1832 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1833 if let Some(v) = self.jobs.as_ref() {
1834 match v {
1835 cancel_creating_jobs_request::Jobs::Infos(v) => {
1836 struct_ser.serialize_field("infos", v)?;
1837 }
1838 cancel_creating_jobs_request::Jobs::Ids(v) => {
1839 struct_ser.serialize_field("ids", v)?;
1840 }
1841 }
1842 }
1843 struct_ser.end()
1844 }
1845}
1846impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1847 #[allow(deprecated)]
1848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1849 where
1850 D: serde::Deserializer<'de>,
1851 {
1852 const FIELDS: &[&str] = &[
1853 "infos",
1854 "ids",
1855 ];
1856
1857 #[allow(clippy::enum_variant_names)]
1858 enum GeneratedField {
1859 Infos,
1860 Ids,
1861 }
1862 impl<'de> serde::Deserialize<'de> for GeneratedField {
1863 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1864 where
1865 D: serde::Deserializer<'de>,
1866 {
1867 struct GeneratedVisitor;
1868
1869 impl serde::de::Visitor<'_> for GeneratedVisitor {
1870 type Value = GeneratedField;
1871
1872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1873 write!(formatter, "expected one of: {:?}", &FIELDS)
1874 }
1875
1876 #[allow(unused_variables)]
1877 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1878 where
1879 E: serde::de::Error,
1880 {
1881 match value {
1882 "infos" => Ok(GeneratedField::Infos),
1883 "ids" => Ok(GeneratedField::Ids),
1884 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1885 }
1886 }
1887 }
1888 deserializer.deserialize_identifier(GeneratedVisitor)
1889 }
1890 }
1891 struct GeneratedVisitor;
1892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1893 type Value = CancelCreatingJobsRequest;
1894
1895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1896 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1897 }
1898
1899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1900 where
1901 V: serde::de::MapAccess<'de>,
1902 {
1903 let mut jobs__ = None;
1904 while let Some(k) = map_.next_key()? {
1905 match k {
1906 GeneratedField::Infos => {
1907 if jobs__.is_some() {
1908 return Err(serde::de::Error::duplicate_field("infos"));
1909 }
1910 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1911;
1912 }
1913 GeneratedField::Ids => {
1914 if jobs__.is_some() {
1915 return Err(serde::de::Error::duplicate_field("ids"));
1916 }
1917 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1918;
1919 }
1920 }
1921 }
1922 Ok(CancelCreatingJobsRequest {
1923 jobs: jobs__,
1924 })
1925 }
1926 }
1927 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1928 }
1929}
1930impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1931 #[allow(deprecated)]
1932 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1933 where
1934 S: serde::Serializer,
1935 {
1936 use serde::ser::SerializeStruct;
1937 let mut len = 0;
1938 if !self.job_ids.is_empty() {
1939 len += 1;
1940 }
1941 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1942 if !self.job_ids.is_empty() {
1943 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1944 }
1945 struct_ser.end()
1946 }
1947}
1948impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1949 #[allow(deprecated)]
1950 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1951 where
1952 D: serde::Deserializer<'de>,
1953 {
1954 const FIELDS: &[&str] = &[
1955 "job_ids",
1956 "jobIds",
1957 ];
1958
1959 #[allow(clippy::enum_variant_names)]
1960 enum GeneratedField {
1961 JobIds,
1962 }
1963 impl<'de> serde::Deserialize<'de> for GeneratedField {
1964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1965 where
1966 D: serde::Deserializer<'de>,
1967 {
1968 struct GeneratedVisitor;
1969
1970 impl serde::de::Visitor<'_> for GeneratedVisitor {
1971 type Value = GeneratedField;
1972
1973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1974 write!(formatter, "expected one of: {:?}", &FIELDS)
1975 }
1976
1977 #[allow(unused_variables)]
1978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1979 where
1980 E: serde::de::Error,
1981 {
1982 match value {
1983 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1985 }
1986 }
1987 }
1988 deserializer.deserialize_identifier(GeneratedVisitor)
1989 }
1990 }
1991 struct GeneratedVisitor;
1992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1993 type Value = cancel_creating_jobs_request::CreatingJobIds;
1994
1995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1996 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1997 }
1998
1999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
2000 where
2001 V: serde::de::MapAccess<'de>,
2002 {
2003 let mut job_ids__ = None;
2004 while let Some(k) = map_.next_key()? {
2005 match k {
2006 GeneratedField::JobIds => {
2007 if job_ids__.is_some() {
2008 return Err(serde::de::Error::duplicate_field("jobIds"));
2009 }
2010 job_ids__ =
2011 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2012 .into_iter().map(|x| x.0).collect())
2013 ;
2014 }
2015 }
2016 }
2017 Ok(cancel_creating_jobs_request::CreatingJobIds {
2018 job_ids: job_ids__.unwrap_or_default(),
2019 })
2020 }
2021 }
2022 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2023 }
2024}
2025impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2026 #[allow(deprecated)]
2027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2028 where
2029 S: serde::Serializer,
2030 {
2031 use serde::ser::SerializeStruct;
2032 let mut len = 0;
2033 if self.database_id != 0 {
2034 len += 1;
2035 }
2036 if self.schema_id != 0 {
2037 len += 1;
2038 }
2039 if !self.name.is_empty() {
2040 len += 1;
2041 }
2042 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2043 if self.database_id != 0 {
2044 struct_ser.serialize_field("databaseId", &self.database_id)?;
2045 }
2046 if self.schema_id != 0 {
2047 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2048 }
2049 if !self.name.is_empty() {
2050 struct_ser.serialize_field("name", &self.name)?;
2051 }
2052 struct_ser.end()
2053 }
2054}
2055impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2056 #[allow(deprecated)]
2057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2058 where
2059 D: serde::Deserializer<'de>,
2060 {
2061 const FIELDS: &[&str] = &[
2062 "database_id",
2063 "databaseId",
2064 "schema_id",
2065 "schemaId",
2066 "name",
2067 ];
2068
2069 #[allow(clippy::enum_variant_names)]
2070 enum GeneratedField {
2071 DatabaseId,
2072 SchemaId,
2073 Name,
2074 }
2075 impl<'de> serde::Deserialize<'de> for GeneratedField {
2076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2077 where
2078 D: serde::Deserializer<'de>,
2079 {
2080 struct GeneratedVisitor;
2081
2082 impl serde::de::Visitor<'_> for GeneratedVisitor {
2083 type Value = GeneratedField;
2084
2085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2086 write!(formatter, "expected one of: {:?}", &FIELDS)
2087 }
2088
2089 #[allow(unused_variables)]
2090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2091 where
2092 E: serde::de::Error,
2093 {
2094 match value {
2095 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2096 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2097 "name" => Ok(GeneratedField::Name),
2098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2099 }
2100 }
2101 }
2102 deserializer.deserialize_identifier(GeneratedVisitor)
2103 }
2104 }
2105 struct GeneratedVisitor;
2106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2107 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2108
2109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2110 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2111 }
2112
2113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2114 where
2115 V: serde::de::MapAccess<'de>,
2116 {
2117 let mut database_id__ = None;
2118 let mut schema_id__ = None;
2119 let mut name__ = None;
2120 while let Some(k) = map_.next_key()? {
2121 match k {
2122 GeneratedField::DatabaseId => {
2123 if database_id__.is_some() {
2124 return Err(serde::de::Error::duplicate_field("databaseId"));
2125 }
2126 database_id__ =
2127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2128 ;
2129 }
2130 GeneratedField::SchemaId => {
2131 if schema_id__.is_some() {
2132 return Err(serde::de::Error::duplicate_field("schemaId"));
2133 }
2134 schema_id__ =
2135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2136 ;
2137 }
2138 GeneratedField::Name => {
2139 if name__.is_some() {
2140 return Err(serde::de::Error::duplicate_field("name"));
2141 }
2142 name__ = Some(map_.next_value()?);
2143 }
2144 }
2145 }
2146 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2147 database_id: database_id__.unwrap_or_default(),
2148 schema_id: schema_id__.unwrap_or_default(),
2149 name: name__.unwrap_or_default(),
2150 })
2151 }
2152 }
2153 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2154 }
2155}
2156impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2157 #[allow(deprecated)]
2158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2159 where
2160 S: serde::Serializer,
2161 {
2162 use serde::ser::SerializeStruct;
2163 let mut len = 0;
2164 if !self.infos.is_empty() {
2165 len += 1;
2166 }
2167 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2168 if !self.infos.is_empty() {
2169 struct_ser.serialize_field("infos", &self.infos)?;
2170 }
2171 struct_ser.end()
2172 }
2173}
2174impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2175 #[allow(deprecated)]
2176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2177 where
2178 D: serde::Deserializer<'de>,
2179 {
2180 const FIELDS: &[&str] = &[
2181 "infos",
2182 ];
2183
2184 #[allow(clippy::enum_variant_names)]
2185 enum GeneratedField {
2186 Infos,
2187 }
2188 impl<'de> serde::Deserialize<'de> for GeneratedField {
2189 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2190 where
2191 D: serde::Deserializer<'de>,
2192 {
2193 struct GeneratedVisitor;
2194
2195 impl serde::de::Visitor<'_> for GeneratedVisitor {
2196 type Value = GeneratedField;
2197
2198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2199 write!(formatter, "expected one of: {:?}", &FIELDS)
2200 }
2201
2202 #[allow(unused_variables)]
2203 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2204 where
2205 E: serde::de::Error,
2206 {
2207 match value {
2208 "infos" => Ok(GeneratedField::Infos),
2209 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2210 }
2211 }
2212 }
2213 deserializer.deserialize_identifier(GeneratedVisitor)
2214 }
2215 }
2216 struct GeneratedVisitor;
2217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2218 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2219
2220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2221 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2222 }
2223
2224 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2225 where
2226 V: serde::de::MapAccess<'de>,
2227 {
2228 let mut infos__ = None;
2229 while let Some(k) = map_.next_key()? {
2230 match k {
2231 GeneratedField::Infos => {
2232 if infos__.is_some() {
2233 return Err(serde::de::Error::duplicate_field("infos"));
2234 }
2235 infos__ = Some(map_.next_value()?);
2236 }
2237 }
2238 }
2239 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2240 infos: infos__.unwrap_or_default(),
2241 })
2242 }
2243 }
2244 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2245 }
2246}
2247impl serde::Serialize for CancelCreatingJobsResponse {
2248 #[allow(deprecated)]
2249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2250 where
2251 S: serde::Serializer,
2252 {
2253 use serde::ser::SerializeStruct;
2254 let mut len = 0;
2255 if self.status.is_some() {
2256 len += 1;
2257 }
2258 if !self.canceled_jobs.is_empty() {
2259 len += 1;
2260 }
2261 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2262 if let Some(v) = self.status.as_ref() {
2263 struct_ser.serialize_field("status", v)?;
2264 }
2265 if !self.canceled_jobs.is_empty() {
2266 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2267 }
2268 struct_ser.end()
2269 }
2270}
2271impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2272 #[allow(deprecated)]
2273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2274 where
2275 D: serde::Deserializer<'de>,
2276 {
2277 const FIELDS: &[&str] = &[
2278 "status",
2279 "canceled_jobs",
2280 "canceledJobs",
2281 ];
2282
2283 #[allow(clippy::enum_variant_names)]
2284 enum GeneratedField {
2285 Status,
2286 CanceledJobs,
2287 }
2288 impl<'de> serde::Deserialize<'de> for GeneratedField {
2289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2290 where
2291 D: serde::Deserializer<'de>,
2292 {
2293 struct GeneratedVisitor;
2294
2295 impl serde::de::Visitor<'_> for GeneratedVisitor {
2296 type Value = GeneratedField;
2297
2298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2299 write!(formatter, "expected one of: {:?}", &FIELDS)
2300 }
2301
2302 #[allow(unused_variables)]
2303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2304 where
2305 E: serde::de::Error,
2306 {
2307 match value {
2308 "status" => Ok(GeneratedField::Status),
2309 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2310 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2311 }
2312 }
2313 }
2314 deserializer.deserialize_identifier(GeneratedVisitor)
2315 }
2316 }
2317 struct GeneratedVisitor;
2318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2319 type Value = CancelCreatingJobsResponse;
2320
2321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2322 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2323 }
2324
2325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2326 where
2327 V: serde::de::MapAccess<'de>,
2328 {
2329 let mut status__ = None;
2330 let mut canceled_jobs__ = None;
2331 while let Some(k) = map_.next_key()? {
2332 match k {
2333 GeneratedField::Status => {
2334 if status__.is_some() {
2335 return Err(serde::de::Error::duplicate_field("status"));
2336 }
2337 status__ = map_.next_value()?;
2338 }
2339 GeneratedField::CanceledJobs => {
2340 if canceled_jobs__.is_some() {
2341 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2342 }
2343 canceled_jobs__ =
2344 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2345 .into_iter().map(|x| x.0).collect())
2346 ;
2347 }
2348 }
2349 }
2350 Ok(CancelCreatingJobsResponse {
2351 status: status__,
2352 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2353 })
2354 }
2355 }
2356 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2357 }
2358}
2359impl serde::Serialize for ClusterLimit {
2360 #[allow(deprecated)]
2361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2362 where
2363 S: serde::Serializer,
2364 {
2365 use serde::ser::SerializeStruct;
2366 let mut len = 0;
2367 if self.limit.is_some() {
2368 len += 1;
2369 }
2370 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2371 if let Some(v) = self.limit.as_ref() {
2372 match v {
2373 cluster_limit::Limit::ActorCount(v) => {
2374 struct_ser.serialize_field("actorCount", v)?;
2375 }
2376 }
2377 }
2378 struct_ser.end()
2379 }
2380}
2381impl<'de> serde::Deserialize<'de> for ClusterLimit {
2382 #[allow(deprecated)]
2383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2384 where
2385 D: serde::Deserializer<'de>,
2386 {
2387 const FIELDS: &[&str] = &[
2388 "actor_count",
2389 "actorCount",
2390 ];
2391
2392 #[allow(clippy::enum_variant_names)]
2393 enum GeneratedField {
2394 ActorCount,
2395 }
2396 impl<'de> serde::Deserialize<'de> for GeneratedField {
2397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2398 where
2399 D: serde::Deserializer<'de>,
2400 {
2401 struct GeneratedVisitor;
2402
2403 impl serde::de::Visitor<'_> for GeneratedVisitor {
2404 type Value = GeneratedField;
2405
2406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2407 write!(formatter, "expected one of: {:?}", &FIELDS)
2408 }
2409
2410 #[allow(unused_variables)]
2411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2412 where
2413 E: serde::de::Error,
2414 {
2415 match value {
2416 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2418 }
2419 }
2420 }
2421 deserializer.deserialize_identifier(GeneratedVisitor)
2422 }
2423 }
2424 struct GeneratedVisitor;
2425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2426 type Value = ClusterLimit;
2427
2428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2429 formatter.write_str("struct meta.ClusterLimit")
2430 }
2431
2432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2433 where
2434 V: serde::de::MapAccess<'de>,
2435 {
2436 let mut limit__ = None;
2437 while let Some(k) = map_.next_key()? {
2438 match k {
2439 GeneratedField::ActorCount => {
2440 if limit__.is_some() {
2441 return Err(serde::de::Error::duplicate_field("actorCount"));
2442 }
2443 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2444;
2445 }
2446 }
2447 }
2448 Ok(ClusterLimit {
2449 limit: limit__,
2450 })
2451 }
2452 }
2453 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2454 }
2455}
2456impl serde::Serialize for DeleteWorkerNodeRequest {
2457 #[allow(deprecated)]
2458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2459 where
2460 S: serde::Serializer,
2461 {
2462 use serde::ser::SerializeStruct;
2463 let mut len = 0;
2464 if self.host.is_some() {
2465 len += 1;
2466 }
2467 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2468 if let Some(v) = self.host.as_ref() {
2469 struct_ser.serialize_field("host", v)?;
2470 }
2471 struct_ser.end()
2472 }
2473}
2474impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2475 #[allow(deprecated)]
2476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2477 where
2478 D: serde::Deserializer<'de>,
2479 {
2480 const FIELDS: &[&str] = &[
2481 "host",
2482 ];
2483
2484 #[allow(clippy::enum_variant_names)]
2485 enum GeneratedField {
2486 Host,
2487 }
2488 impl<'de> serde::Deserialize<'de> for GeneratedField {
2489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2490 where
2491 D: serde::Deserializer<'de>,
2492 {
2493 struct GeneratedVisitor;
2494
2495 impl serde::de::Visitor<'_> for GeneratedVisitor {
2496 type Value = GeneratedField;
2497
2498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2499 write!(formatter, "expected one of: {:?}", &FIELDS)
2500 }
2501
2502 #[allow(unused_variables)]
2503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2504 where
2505 E: serde::de::Error,
2506 {
2507 match value {
2508 "host" => Ok(GeneratedField::Host),
2509 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2510 }
2511 }
2512 }
2513 deserializer.deserialize_identifier(GeneratedVisitor)
2514 }
2515 }
2516 struct GeneratedVisitor;
2517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2518 type Value = DeleteWorkerNodeRequest;
2519
2520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2521 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2522 }
2523
2524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2525 where
2526 V: serde::de::MapAccess<'de>,
2527 {
2528 let mut host__ = None;
2529 while let Some(k) = map_.next_key()? {
2530 match k {
2531 GeneratedField::Host => {
2532 if host__.is_some() {
2533 return Err(serde::de::Error::duplicate_field("host"));
2534 }
2535 host__ = map_.next_value()?;
2536 }
2537 }
2538 }
2539 Ok(DeleteWorkerNodeRequest {
2540 host: host__,
2541 })
2542 }
2543 }
2544 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2545 }
2546}
2547impl serde::Serialize for DeleteWorkerNodeResponse {
2548 #[allow(deprecated)]
2549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2550 where
2551 S: serde::Serializer,
2552 {
2553 use serde::ser::SerializeStruct;
2554 let mut len = 0;
2555 if self.status.is_some() {
2556 len += 1;
2557 }
2558 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2559 if let Some(v) = self.status.as_ref() {
2560 struct_ser.serialize_field("status", v)?;
2561 }
2562 struct_ser.end()
2563 }
2564}
2565impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2566 #[allow(deprecated)]
2567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2568 where
2569 D: serde::Deserializer<'de>,
2570 {
2571 const FIELDS: &[&str] = &[
2572 "status",
2573 ];
2574
2575 #[allow(clippy::enum_variant_names)]
2576 enum GeneratedField {
2577 Status,
2578 }
2579 impl<'de> serde::Deserialize<'de> for GeneratedField {
2580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2581 where
2582 D: serde::Deserializer<'de>,
2583 {
2584 struct GeneratedVisitor;
2585
2586 impl serde::de::Visitor<'_> for GeneratedVisitor {
2587 type Value = GeneratedField;
2588
2589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2590 write!(formatter, "expected one of: {:?}", &FIELDS)
2591 }
2592
2593 #[allow(unused_variables)]
2594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2595 where
2596 E: serde::de::Error,
2597 {
2598 match value {
2599 "status" => Ok(GeneratedField::Status),
2600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2601 }
2602 }
2603 }
2604 deserializer.deserialize_identifier(GeneratedVisitor)
2605 }
2606 }
2607 struct GeneratedVisitor;
2608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2609 type Value = DeleteWorkerNodeResponse;
2610
2611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2612 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2613 }
2614
2615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2616 where
2617 V: serde::de::MapAccess<'de>,
2618 {
2619 let mut status__ = None;
2620 while let Some(k) = map_.next_key()? {
2621 match k {
2622 GeneratedField::Status => {
2623 if status__.is_some() {
2624 return Err(serde::de::Error::duplicate_field("status"));
2625 }
2626 status__ = map_.next_value()?;
2627 }
2628 }
2629 }
2630 Ok(DeleteWorkerNodeResponse {
2631 status: status__,
2632 })
2633 }
2634 }
2635 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2636 }
2637}
2638impl serde::Serialize for EventLog {
2639 #[allow(deprecated)]
2640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2641 where
2642 S: serde::Serializer,
2643 {
2644 use serde::ser::SerializeStruct;
2645 let mut len = 0;
2646 if self.unique_id.is_some() {
2647 len += 1;
2648 }
2649 if self.timestamp.is_some() {
2650 len += 1;
2651 }
2652 if self.event.is_some() {
2653 len += 1;
2654 }
2655 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2656 if let Some(v) = self.unique_id.as_ref() {
2657 struct_ser.serialize_field("uniqueId", v)?;
2658 }
2659 if let Some(v) = self.timestamp.as_ref() {
2660 #[allow(clippy::needless_borrow)]
2661 #[allow(clippy::needless_borrows_for_generic_args)]
2662 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2663 }
2664 if let Some(v) = self.event.as_ref() {
2665 match v {
2666 event_log::Event::CreateStreamJobFail(v) => {
2667 struct_ser.serialize_field("createStreamJobFail", v)?;
2668 }
2669 event_log::Event::DirtyStreamJobClear(v) => {
2670 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2671 }
2672 event_log::Event::MetaNodeStart(v) => {
2673 struct_ser.serialize_field("metaNodeStart", v)?;
2674 }
2675 event_log::Event::BarrierComplete(v) => {
2676 struct_ser.serialize_field("barrierComplete", v)?;
2677 }
2678 event_log::Event::InjectBarrierFail(v) => {
2679 struct_ser.serialize_field("injectBarrierFail", v)?;
2680 }
2681 event_log::Event::CollectBarrierFail(v) => {
2682 struct_ser.serialize_field("collectBarrierFail", v)?;
2683 }
2684 event_log::Event::WorkerNodePanic(v) => {
2685 struct_ser.serialize_field("workerNodePanic", v)?;
2686 }
2687 event_log::Event::AutoSchemaChangeFail(v) => {
2688 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2689 }
2690 event_log::Event::SinkFail(v) => {
2691 struct_ser.serialize_field("sinkFail", v)?;
2692 }
2693 event_log::Event::Recovery(v) => {
2694 struct_ser.serialize_field("recovery", v)?;
2695 }
2696 }
2697 }
2698 struct_ser.end()
2699 }
2700}
2701impl<'de> serde::Deserialize<'de> for EventLog {
2702 #[allow(deprecated)]
2703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2704 where
2705 D: serde::Deserializer<'de>,
2706 {
2707 const FIELDS: &[&str] = &[
2708 "unique_id",
2709 "uniqueId",
2710 "timestamp",
2711 "create_stream_job_fail",
2712 "createStreamJobFail",
2713 "dirty_stream_job_clear",
2714 "dirtyStreamJobClear",
2715 "meta_node_start",
2716 "metaNodeStart",
2717 "barrier_complete",
2718 "barrierComplete",
2719 "inject_barrier_fail",
2720 "injectBarrierFail",
2721 "collect_barrier_fail",
2722 "collectBarrierFail",
2723 "worker_node_panic",
2724 "workerNodePanic",
2725 "auto_schema_change_fail",
2726 "autoSchemaChangeFail",
2727 "sink_fail",
2728 "sinkFail",
2729 "recovery",
2730 ];
2731
2732 #[allow(clippy::enum_variant_names)]
2733 enum GeneratedField {
2734 UniqueId,
2735 Timestamp,
2736 CreateStreamJobFail,
2737 DirtyStreamJobClear,
2738 MetaNodeStart,
2739 BarrierComplete,
2740 InjectBarrierFail,
2741 CollectBarrierFail,
2742 WorkerNodePanic,
2743 AutoSchemaChangeFail,
2744 SinkFail,
2745 Recovery,
2746 }
2747 impl<'de> serde::Deserialize<'de> for GeneratedField {
2748 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2749 where
2750 D: serde::Deserializer<'de>,
2751 {
2752 struct GeneratedVisitor;
2753
2754 impl serde::de::Visitor<'_> for GeneratedVisitor {
2755 type Value = GeneratedField;
2756
2757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2758 write!(formatter, "expected one of: {:?}", &FIELDS)
2759 }
2760
2761 #[allow(unused_variables)]
2762 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2763 where
2764 E: serde::de::Error,
2765 {
2766 match value {
2767 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2768 "timestamp" => Ok(GeneratedField::Timestamp),
2769 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2770 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2771 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2772 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2773 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2774 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2775 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2776 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2777 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2778 "recovery" => Ok(GeneratedField::Recovery),
2779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2780 }
2781 }
2782 }
2783 deserializer.deserialize_identifier(GeneratedVisitor)
2784 }
2785 }
2786 struct GeneratedVisitor;
2787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2788 type Value = EventLog;
2789
2790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2791 formatter.write_str("struct meta.EventLog")
2792 }
2793
2794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2795 where
2796 V: serde::de::MapAccess<'de>,
2797 {
2798 let mut unique_id__ = None;
2799 let mut timestamp__ = None;
2800 let mut event__ = None;
2801 while let Some(k) = map_.next_key()? {
2802 match k {
2803 GeneratedField::UniqueId => {
2804 if unique_id__.is_some() {
2805 return Err(serde::de::Error::duplicate_field("uniqueId"));
2806 }
2807 unique_id__ = map_.next_value()?;
2808 }
2809 GeneratedField::Timestamp => {
2810 if timestamp__.is_some() {
2811 return Err(serde::de::Error::duplicate_field("timestamp"));
2812 }
2813 timestamp__ =
2814 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2815 ;
2816 }
2817 GeneratedField::CreateStreamJobFail => {
2818 if event__.is_some() {
2819 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2820 }
2821 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2822;
2823 }
2824 GeneratedField::DirtyStreamJobClear => {
2825 if event__.is_some() {
2826 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2827 }
2828 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2829;
2830 }
2831 GeneratedField::MetaNodeStart => {
2832 if event__.is_some() {
2833 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2834 }
2835 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2836;
2837 }
2838 GeneratedField::BarrierComplete => {
2839 if event__.is_some() {
2840 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2841 }
2842 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2843;
2844 }
2845 GeneratedField::InjectBarrierFail => {
2846 if event__.is_some() {
2847 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2848 }
2849 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2850;
2851 }
2852 GeneratedField::CollectBarrierFail => {
2853 if event__.is_some() {
2854 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2855 }
2856 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2857;
2858 }
2859 GeneratedField::WorkerNodePanic => {
2860 if event__.is_some() {
2861 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2862 }
2863 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2864;
2865 }
2866 GeneratedField::AutoSchemaChangeFail => {
2867 if event__.is_some() {
2868 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2869 }
2870 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2871;
2872 }
2873 GeneratedField::SinkFail => {
2874 if event__.is_some() {
2875 return Err(serde::de::Error::duplicate_field("sinkFail"));
2876 }
2877 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2878;
2879 }
2880 GeneratedField::Recovery => {
2881 if event__.is_some() {
2882 return Err(serde::de::Error::duplicate_field("recovery"));
2883 }
2884 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2885;
2886 }
2887 }
2888 }
2889 Ok(EventLog {
2890 unique_id: unique_id__,
2891 timestamp: timestamp__,
2892 event: event__,
2893 })
2894 }
2895 }
2896 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2897 }
2898}
2899impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2900 #[allow(deprecated)]
2901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2902 where
2903 S: serde::Serializer,
2904 {
2905 use serde::ser::SerializeStruct;
2906 let mut len = 0;
2907 if self.table_id != 0 {
2908 len += 1;
2909 }
2910 if !self.table_name.is_empty() {
2911 len += 1;
2912 }
2913 if !self.cdc_table_id.is_empty() {
2914 len += 1;
2915 }
2916 if !self.upstream_ddl.is_empty() {
2917 len += 1;
2918 }
2919 if !self.fail_info.is_empty() {
2920 len += 1;
2921 }
2922 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2923 if self.table_id != 0 {
2924 struct_ser.serialize_field("tableId", &self.table_id)?;
2925 }
2926 if !self.table_name.is_empty() {
2927 struct_ser.serialize_field("tableName", &self.table_name)?;
2928 }
2929 if !self.cdc_table_id.is_empty() {
2930 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2931 }
2932 if !self.upstream_ddl.is_empty() {
2933 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2934 }
2935 if !self.fail_info.is_empty() {
2936 struct_ser.serialize_field("failInfo", &self.fail_info)?;
2937 }
2938 struct_ser.end()
2939 }
2940}
2941impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2942 #[allow(deprecated)]
2943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2944 where
2945 D: serde::Deserializer<'de>,
2946 {
2947 const FIELDS: &[&str] = &[
2948 "table_id",
2949 "tableId",
2950 "table_name",
2951 "tableName",
2952 "cdc_table_id",
2953 "cdcTableId",
2954 "upstream_ddl",
2955 "upstreamDdl",
2956 "fail_info",
2957 "failInfo",
2958 ];
2959
2960 #[allow(clippy::enum_variant_names)]
2961 enum GeneratedField {
2962 TableId,
2963 TableName,
2964 CdcTableId,
2965 UpstreamDdl,
2966 FailInfo,
2967 }
2968 impl<'de> serde::Deserialize<'de> for GeneratedField {
2969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2970 where
2971 D: serde::Deserializer<'de>,
2972 {
2973 struct GeneratedVisitor;
2974
2975 impl serde::de::Visitor<'_> for GeneratedVisitor {
2976 type Value = GeneratedField;
2977
2978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2979 write!(formatter, "expected one of: {:?}", &FIELDS)
2980 }
2981
2982 #[allow(unused_variables)]
2983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2984 where
2985 E: serde::de::Error,
2986 {
2987 match value {
2988 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2989 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2990 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2991 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2992 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2994 }
2995 }
2996 }
2997 deserializer.deserialize_identifier(GeneratedVisitor)
2998 }
2999 }
3000 struct GeneratedVisitor;
3001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3002 type Value = event_log::EventAutoSchemaChangeFail;
3003
3004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3005 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
3006 }
3007
3008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
3009 where
3010 V: serde::de::MapAccess<'de>,
3011 {
3012 let mut table_id__ = None;
3013 let mut table_name__ = None;
3014 let mut cdc_table_id__ = None;
3015 let mut upstream_ddl__ = None;
3016 let mut fail_info__ = None;
3017 while let Some(k) = map_.next_key()? {
3018 match k {
3019 GeneratedField::TableId => {
3020 if table_id__.is_some() {
3021 return Err(serde::de::Error::duplicate_field("tableId"));
3022 }
3023 table_id__ =
3024 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3025 ;
3026 }
3027 GeneratedField::TableName => {
3028 if table_name__.is_some() {
3029 return Err(serde::de::Error::duplicate_field("tableName"));
3030 }
3031 table_name__ = Some(map_.next_value()?);
3032 }
3033 GeneratedField::CdcTableId => {
3034 if cdc_table_id__.is_some() {
3035 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3036 }
3037 cdc_table_id__ = Some(map_.next_value()?);
3038 }
3039 GeneratedField::UpstreamDdl => {
3040 if upstream_ddl__.is_some() {
3041 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3042 }
3043 upstream_ddl__ = Some(map_.next_value()?);
3044 }
3045 GeneratedField::FailInfo => {
3046 if fail_info__.is_some() {
3047 return Err(serde::de::Error::duplicate_field("failInfo"));
3048 }
3049 fail_info__ = Some(map_.next_value()?);
3050 }
3051 }
3052 }
3053 Ok(event_log::EventAutoSchemaChangeFail {
3054 table_id: table_id__.unwrap_or_default(),
3055 table_name: table_name__.unwrap_or_default(),
3056 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3057 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3058 fail_info: fail_info__.unwrap_or_default(),
3059 })
3060 }
3061 }
3062 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3063 }
3064}
3065impl serde::Serialize for event_log::EventBarrierComplete {
3066 #[allow(deprecated)]
3067 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3068 where
3069 S: serde::Serializer,
3070 {
3071 use serde::ser::SerializeStruct;
3072 let mut len = 0;
3073 if self.prev_epoch != 0 {
3074 len += 1;
3075 }
3076 if self.cur_epoch != 0 {
3077 len += 1;
3078 }
3079 if self.duration_sec != 0. {
3080 len += 1;
3081 }
3082 if !self.command.is_empty() {
3083 len += 1;
3084 }
3085 if !self.barrier_kind.is_empty() {
3086 len += 1;
3087 }
3088 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3089 if self.prev_epoch != 0 {
3090 #[allow(clippy::needless_borrow)]
3091 #[allow(clippy::needless_borrows_for_generic_args)]
3092 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3093 }
3094 if self.cur_epoch != 0 {
3095 #[allow(clippy::needless_borrow)]
3096 #[allow(clippy::needless_borrows_for_generic_args)]
3097 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3098 }
3099 if self.duration_sec != 0. {
3100 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3101 }
3102 if !self.command.is_empty() {
3103 struct_ser.serialize_field("command", &self.command)?;
3104 }
3105 if !self.barrier_kind.is_empty() {
3106 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3107 }
3108 struct_ser.end()
3109 }
3110}
3111impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3112 #[allow(deprecated)]
3113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3114 where
3115 D: serde::Deserializer<'de>,
3116 {
3117 const FIELDS: &[&str] = &[
3118 "prev_epoch",
3119 "prevEpoch",
3120 "cur_epoch",
3121 "curEpoch",
3122 "duration_sec",
3123 "durationSec",
3124 "command",
3125 "barrier_kind",
3126 "barrierKind",
3127 ];
3128
3129 #[allow(clippy::enum_variant_names)]
3130 enum GeneratedField {
3131 PrevEpoch,
3132 CurEpoch,
3133 DurationSec,
3134 Command,
3135 BarrierKind,
3136 }
3137 impl<'de> serde::Deserialize<'de> for GeneratedField {
3138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3139 where
3140 D: serde::Deserializer<'de>,
3141 {
3142 struct GeneratedVisitor;
3143
3144 impl serde::de::Visitor<'_> for GeneratedVisitor {
3145 type Value = GeneratedField;
3146
3147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3148 write!(formatter, "expected one of: {:?}", &FIELDS)
3149 }
3150
3151 #[allow(unused_variables)]
3152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3153 where
3154 E: serde::de::Error,
3155 {
3156 match value {
3157 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3158 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3159 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3160 "command" => Ok(GeneratedField::Command),
3161 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3162 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3163 }
3164 }
3165 }
3166 deserializer.deserialize_identifier(GeneratedVisitor)
3167 }
3168 }
3169 struct GeneratedVisitor;
3170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3171 type Value = event_log::EventBarrierComplete;
3172
3173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3174 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3175 }
3176
3177 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3178 where
3179 V: serde::de::MapAccess<'de>,
3180 {
3181 let mut prev_epoch__ = None;
3182 let mut cur_epoch__ = None;
3183 let mut duration_sec__ = None;
3184 let mut command__ = None;
3185 let mut barrier_kind__ = None;
3186 while let Some(k) = map_.next_key()? {
3187 match k {
3188 GeneratedField::PrevEpoch => {
3189 if prev_epoch__.is_some() {
3190 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3191 }
3192 prev_epoch__ =
3193 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3194 ;
3195 }
3196 GeneratedField::CurEpoch => {
3197 if cur_epoch__.is_some() {
3198 return Err(serde::de::Error::duplicate_field("curEpoch"));
3199 }
3200 cur_epoch__ =
3201 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3202 ;
3203 }
3204 GeneratedField::DurationSec => {
3205 if duration_sec__.is_some() {
3206 return Err(serde::de::Error::duplicate_field("durationSec"));
3207 }
3208 duration_sec__ =
3209 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3210 ;
3211 }
3212 GeneratedField::Command => {
3213 if command__.is_some() {
3214 return Err(serde::de::Error::duplicate_field("command"));
3215 }
3216 command__ = Some(map_.next_value()?);
3217 }
3218 GeneratedField::BarrierKind => {
3219 if barrier_kind__.is_some() {
3220 return Err(serde::de::Error::duplicate_field("barrierKind"));
3221 }
3222 barrier_kind__ = Some(map_.next_value()?);
3223 }
3224 }
3225 }
3226 Ok(event_log::EventBarrierComplete {
3227 prev_epoch: prev_epoch__.unwrap_or_default(),
3228 cur_epoch: cur_epoch__.unwrap_or_default(),
3229 duration_sec: duration_sec__.unwrap_or_default(),
3230 command: command__.unwrap_or_default(),
3231 barrier_kind: barrier_kind__.unwrap_or_default(),
3232 })
3233 }
3234 }
3235 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3236 }
3237}
3238impl serde::Serialize for event_log::EventCollectBarrierFail {
3239 #[allow(deprecated)]
3240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3241 where
3242 S: serde::Serializer,
3243 {
3244 use serde::ser::SerializeStruct;
3245 let mut len = 0;
3246 if !self.error.is_empty() {
3247 len += 1;
3248 }
3249 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3250 if !self.error.is_empty() {
3251 struct_ser.serialize_field("error", &self.error)?;
3252 }
3253 struct_ser.end()
3254 }
3255}
3256impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3257 #[allow(deprecated)]
3258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3259 where
3260 D: serde::Deserializer<'de>,
3261 {
3262 const FIELDS: &[&str] = &[
3263 "error",
3264 ];
3265
3266 #[allow(clippy::enum_variant_names)]
3267 enum GeneratedField {
3268 Error,
3269 }
3270 impl<'de> serde::Deserialize<'de> for GeneratedField {
3271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3272 where
3273 D: serde::Deserializer<'de>,
3274 {
3275 struct GeneratedVisitor;
3276
3277 impl serde::de::Visitor<'_> for GeneratedVisitor {
3278 type Value = GeneratedField;
3279
3280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3281 write!(formatter, "expected one of: {:?}", &FIELDS)
3282 }
3283
3284 #[allow(unused_variables)]
3285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3286 where
3287 E: serde::de::Error,
3288 {
3289 match value {
3290 "error" => Ok(GeneratedField::Error),
3291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3292 }
3293 }
3294 }
3295 deserializer.deserialize_identifier(GeneratedVisitor)
3296 }
3297 }
3298 struct GeneratedVisitor;
3299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3300 type Value = event_log::EventCollectBarrierFail;
3301
3302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3303 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3304 }
3305
3306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3307 where
3308 V: serde::de::MapAccess<'de>,
3309 {
3310 let mut error__ = None;
3311 while let Some(k) = map_.next_key()? {
3312 match k {
3313 GeneratedField::Error => {
3314 if error__.is_some() {
3315 return Err(serde::de::Error::duplicate_field("error"));
3316 }
3317 error__ = Some(map_.next_value()?);
3318 }
3319 }
3320 }
3321 Ok(event_log::EventCollectBarrierFail {
3322 error: error__.unwrap_or_default(),
3323 })
3324 }
3325 }
3326 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3327 }
3328}
3329impl serde::Serialize for event_log::EventCreateStreamJobFail {
3330 #[allow(deprecated)]
3331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3332 where
3333 S: serde::Serializer,
3334 {
3335 use serde::ser::SerializeStruct;
3336 let mut len = 0;
3337 if self.id != 0 {
3338 len += 1;
3339 }
3340 if !self.name.is_empty() {
3341 len += 1;
3342 }
3343 if !self.definition.is_empty() {
3344 len += 1;
3345 }
3346 if !self.error.is_empty() {
3347 len += 1;
3348 }
3349 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3350 if self.id != 0 {
3351 struct_ser.serialize_field("id", &self.id)?;
3352 }
3353 if !self.name.is_empty() {
3354 struct_ser.serialize_field("name", &self.name)?;
3355 }
3356 if !self.definition.is_empty() {
3357 struct_ser.serialize_field("definition", &self.definition)?;
3358 }
3359 if !self.error.is_empty() {
3360 struct_ser.serialize_field("error", &self.error)?;
3361 }
3362 struct_ser.end()
3363 }
3364}
3365impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3366 #[allow(deprecated)]
3367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3368 where
3369 D: serde::Deserializer<'de>,
3370 {
3371 const FIELDS: &[&str] = &[
3372 "id",
3373 "name",
3374 "definition",
3375 "error",
3376 ];
3377
3378 #[allow(clippy::enum_variant_names)]
3379 enum GeneratedField {
3380 Id,
3381 Name,
3382 Definition,
3383 Error,
3384 }
3385 impl<'de> serde::Deserialize<'de> for GeneratedField {
3386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3387 where
3388 D: serde::Deserializer<'de>,
3389 {
3390 struct GeneratedVisitor;
3391
3392 impl serde::de::Visitor<'_> for GeneratedVisitor {
3393 type Value = GeneratedField;
3394
3395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3396 write!(formatter, "expected one of: {:?}", &FIELDS)
3397 }
3398
3399 #[allow(unused_variables)]
3400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3401 where
3402 E: serde::de::Error,
3403 {
3404 match value {
3405 "id" => Ok(GeneratedField::Id),
3406 "name" => Ok(GeneratedField::Name),
3407 "definition" => Ok(GeneratedField::Definition),
3408 "error" => Ok(GeneratedField::Error),
3409 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3410 }
3411 }
3412 }
3413 deserializer.deserialize_identifier(GeneratedVisitor)
3414 }
3415 }
3416 struct GeneratedVisitor;
3417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3418 type Value = event_log::EventCreateStreamJobFail;
3419
3420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3421 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3422 }
3423
3424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3425 where
3426 V: serde::de::MapAccess<'de>,
3427 {
3428 let mut id__ = None;
3429 let mut name__ = None;
3430 let mut definition__ = None;
3431 let mut error__ = None;
3432 while let Some(k) = map_.next_key()? {
3433 match k {
3434 GeneratedField::Id => {
3435 if id__.is_some() {
3436 return Err(serde::de::Error::duplicate_field("id"));
3437 }
3438 id__ =
3439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3440 ;
3441 }
3442 GeneratedField::Name => {
3443 if name__.is_some() {
3444 return Err(serde::de::Error::duplicate_field("name"));
3445 }
3446 name__ = Some(map_.next_value()?);
3447 }
3448 GeneratedField::Definition => {
3449 if definition__.is_some() {
3450 return Err(serde::de::Error::duplicate_field("definition"));
3451 }
3452 definition__ = Some(map_.next_value()?);
3453 }
3454 GeneratedField::Error => {
3455 if error__.is_some() {
3456 return Err(serde::de::Error::duplicate_field("error"));
3457 }
3458 error__ = Some(map_.next_value()?);
3459 }
3460 }
3461 }
3462 Ok(event_log::EventCreateStreamJobFail {
3463 id: id__.unwrap_or_default(),
3464 name: name__.unwrap_or_default(),
3465 definition: definition__.unwrap_or_default(),
3466 error: error__.unwrap_or_default(),
3467 })
3468 }
3469 }
3470 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3471 }
3472}
3473impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3474 #[allow(deprecated)]
3475 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3476 where
3477 S: serde::Serializer,
3478 {
3479 use serde::ser::SerializeStruct;
3480 let mut len = 0;
3481 if self.id != 0 {
3482 len += 1;
3483 }
3484 if !self.name.is_empty() {
3485 len += 1;
3486 }
3487 if !self.definition.is_empty() {
3488 len += 1;
3489 }
3490 if !self.error.is_empty() {
3491 len += 1;
3492 }
3493 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3494 if self.id != 0 {
3495 struct_ser.serialize_field("id", &self.id)?;
3496 }
3497 if !self.name.is_empty() {
3498 struct_ser.serialize_field("name", &self.name)?;
3499 }
3500 if !self.definition.is_empty() {
3501 struct_ser.serialize_field("definition", &self.definition)?;
3502 }
3503 if !self.error.is_empty() {
3504 struct_ser.serialize_field("error", &self.error)?;
3505 }
3506 struct_ser.end()
3507 }
3508}
3509impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3510 #[allow(deprecated)]
3511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3512 where
3513 D: serde::Deserializer<'de>,
3514 {
3515 const FIELDS: &[&str] = &[
3516 "id",
3517 "name",
3518 "definition",
3519 "error",
3520 ];
3521
3522 #[allow(clippy::enum_variant_names)]
3523 enum GeneratedField {
3524 Id,
3525 Name,
3526 Definition,
3527 Error,
3528 }
3529 impl<'de> serde::Deserialize<'de> for GeneratedField {
3530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3531 where
3532 D: serde::Deserializer<'de>,
3533 {
3534 struct GeneratedVisitor;
3535
3536 impl serde::de::Visitor<'_> for GeneratedVisitor {
3537 type Value = GeneratedField;
3538
3539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3540 write!(formatter, "expected one of: {:?}", &FIELDS)
3541 }
3542
3543 #[allow(unused_variables)]
3544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3545 where
3546 E: serde::de::Error,
3547 {
3548 match value {
3549 "id" => Ok(GeneratedField::Id),
3550 "name" => Ok(GeneratedField::Name),
3551 "definition" => Ok(GeneratedField::Definition),
3552 "error" => Ok(GeneratedField::Error),
3553 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3554 }
3555 }
3556 }
3557 deserializer.deserialize_identifier(GeneratedVisitor)
3558 }
3559 }
3560 struct GeneratedVisitor;
3561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3562 type Value = event_log::EventDirtyStreamJobClear;
3563
3564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3565 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3566 }
3567
3568 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3569 where
3570 V: serde::de::MapAccess<'de>,
3571 {
3572 let mut id__ = None;
3573 let mut name__ = None;
3574 let mut definition__ = None;
3575 let mut error__ = None;
3576 while let Some(k) = map_.next_key()? {
3577 match k {
3578 GeneratedField::Id => {
3579 if id__.is_some() {
3580 return Err(serde::de::Error::duplicate_field("id"));
3581 }
3582 id__ =
3583 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3584 ;
3585 }
3586 GeneratedField::Name => {
3587 if name__.is_some() {
3588 return Err(serde::de::Error::duplicate_field("name"));
3589 }
3590 name__ = Some(map_.next_value()?);
3591 }
3592 GeneratedField::Definition => {
3593 if definition__.is_some() {
3594 return Err(serde::de::Error::duplicate_field("definition"));
3595 }
3596 definition__ = Some(map_.next_value()?);
3597 }
3598 GeneratedField::Error => {
3599 if error__.is_some() {
3600 return Err(serde::de::Error::duplicate_field("error"));
3601 }
3602 error__ = Some(map_.next_value()?);
3603 }
3604 }
3605 }
3606 Ok(event_log::EventDirtyStreamJobClear {
3607 id: id__.unwrap_or_default(),
3608 name: name__.unwrap_or_default(),
3609 definition: definition__.unwrap_or_default(),
3610 error: error__.unwrap_or_default(),
3611 })
3612 }
3613 }
3614 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3615 }
3616}
3617impl serde::Serialize for event_log::EventInjectBarrierFail {
3618 #[allow(deprecated)]
3619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3620 where
3621 S: serde::Serializer,
3622 {
3623 use serde::ser::SerializeStruct;
3624 let mut len = 0;
3625 if self.prev_epoch != 0 {
3626 len += 1;
3627 }
3628 if self.cur_epoch != 0 {
3629 len += 1;
3630 }
3631 if !self.error.is_empty() {
3632 len += 1;
3633 }
3634 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3635 if self.prev_epoch != 0 {
3636 #[allow(clippy::needless_borrow)]
3637 #[allow(clippy::needless_borrows_for_generic_args)]
3638 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3639 }
3640 if self.cur_epoch != 0 {
3641 #[allow(clippy::needless_borrow)]
3642 #[allow(clippy::needless_borrows_for_generic_args)]
3643 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3644 }
3645 if !self.error.is_empty() {
3646 struct_ser.serialize_field("error", &self.error)?;
3647 }
3648 struct_ser.end()
3649 }
3650}
3651impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3652 #[allow(deprecated)]
3653 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3654 where
3655 D: serde::Deserializer<'de>,
3656 {
3657 const FIELDS: &[&str] = &[
3658 "prev_epoch",
3659 "prevEpoch",
3660 "cur_epoch",
3661 "curEpoch",
3662 "error",
3663 ];
3664
3665 #[allow(clippy::enum_variant_names)]
3666 enum GeneratedField {
3667 PrevEpoch,
3668 CurEpoch,
3669 Error,
3670 }
3671 impl<'de> serde::Deserialize<'de> for GeneratedField {
3672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3673 where
3674 D: serde::Deserializer<'de>,
3675 {
3676 struct GeneratedVisitor;
3677
3678 impl serde::de::Visitor<'_> for GeneratedVisitor {
3679 type Value = GeneratedField;
3680
3681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3682 write!(formatter, "expected one of: {:?}", &FIELDS)
3683 }
3684
3685 #[allow(unused_variables)]
3686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3687 where
3688 E: serde::de::Error,
3689 {
3690 match value {
3691 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3692 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3693 "error" => Ok(GeneratedField::Error),
3694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3695 }
3696 }
3697 }
3698 deserializer.deserialize_identifier(GeneratedVisitor)
3699 }
3700 }
3701 struct GeneratedVisitor;
3702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3703 type Value = event_log::EventInjectBarrierFail;
3704
3705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3706 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3707 }
3708
3709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3710 where
3711 V: serde::de::MapAccess<'de>,
3712 {
3713 let mut prev_epoch__ = None;
3714 let mut cur_epoch__ = None;
3715 let mut error__ = None;
3716 while let Some(k) = map_.next_key()? {
3717 match k {
3718 GeneratedField::PrevEpoch => {
3719 if prev_epoch__.is_some() {
3720 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3721 }
3722 prev_epoch__ =
3723 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3724 ;
3725 }
3726 GeneratedField::CurEpoch => {
3727 if cur_epoch__.is_some() {
3728 return Err(serde::de::Error::duplicate_field("curEpoch"));
3729 }
3730 cur_epoch__ =
3731 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3732 ;
3733 }
3734 GeneratedField::Error => {
3735 if error__.is_some() {
3736 return Err(serde::de::Error::duplicate_field("error"));
3737 }
3738 error__ = Some(map_.next_value()?);
3739 }
3740 }
3741 }
3742 Ok(event_log::EventInjectBarrierFail {
3743 prev_epoch: prev_epoch__.unwrap_or_default(),
3744 cur_epoch: cur_epoch__.unwrap_or_default(),
3745 error: error__.unwrap_or_default(),
3746 })
3747 }
3748 }
3749 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3750 }
3751}
3752impl serde::Serialize for event_log::EventMetaNodeStart {
3753 #[allow(deprecated)]
3754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3755 where
3756 S: serde::Serializer,
3757 {
3758 use serde::ser::SerializeStruct;
3759 let mut len = 0;
3760 if !self.advertise_addr.is_empty() {
3761 len += 1;
3762 }
3763 if !self.listen_addr.is_empty() {
3764 len += 1;
3765 }
3766 if !self.opts.is_empty() {
3767 len += 1;
3768 }
3769 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3770 if !self.advertise_addr.is_empty() {
3771 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3772 }
3773 if !self.listen_addr.is_empty() {
3774 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3775 }
3776 if !self.opts.is_empty() {
3777 struct_ser.serialize_field("opts", &self.opts)?;
3778 }
3779 struct_ser.end()
3780 }
3781}
3782impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3783 #[allow(deprecated)]
3784 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3785 where
3786 D: serde::Deserializer<'de>,
3787 {
3788 const FIELDS: &[&str] = &[
3789 "advertise_addr",
3790 "advertiseAddr",
3791 "listen_addr",
3792 "listenAddr",
3793 "opts",
3794 ];
3795
3796 #[allow(clippy::enum_variant_names)]
3797 enum GeneratedField {
3798 AdvertiseAddr,
3799 ListenAddr,
3800 Opts,
3801 }
3802 impl<'de> serde::Deserialize<'de> for GeneratedField {
3803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3804 where
3805 D: serde::Deserializer<'de>,
3806 {
3807 struct GeneratedVisitor;
3808
3809 impl serde::de::Visitor<'_> for GeneratedVisitor {
3810 type Value = GeneratedField;
3811
3812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3813 write!(formatter, "expected one of: {:?}", &FIELDS)
3814 }
3815
3816 #[allow(unused_variables)]
3817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3818 where
3819 E: serde::de::Error,
3820 {
3821 match value {
3822 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3823 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3824 "opts" => Ok(GeneratedField::Opts),
3825 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3826 }
3827 }
3828 }
3829 deserializer.deserialize_identifier(GeneratedVisitor)
3830 }
3831 }
3832 struct GeneratedVisitor;
3833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3834 type Value = event_log::EventMetaNodeStart;
3835
3836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3837 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3838 }
3839
3840 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3841 where
3842 V: serde::de::MapAccess<'de>,
3843 {
3844 let mut advertise_addr__ = None;
3845 let mut listen_addr__ = None;
3846 let mut opts__ = None;
3847 while let Some(k) = map_.next_key()? {
3848 match k {
3849 GeneratedField::AdvertiseAddr => {
3850 if advertise_addr__.is_some() {
3851 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3852 }
3853 advertise_addr__ = Some(map_.next_value()?);
3854 }
3855 GeneratedField::ListenAddr => {
3856 if listen_addr__.is_some() {
3857 return Err(serde::de::Error::duplicate_field("listenAddr"));
3858 }
3859 listen_addr__ = Some(map_.next_value()?);
3860 }
3861 GeneratedField::Opts => {
3862 if opts__.is_some() {
3863 return Err(serde::de::Error::duplicate_field("opts"));
3864 }
3865 opts__ = Some(map_.next_value()?);
3866 }
3867 }
3868 }
3869 Ok(event_log::EventMetaNodeStart {
3870 advertise_addr: advertise_addr__.unwrap_or_default(),
3871 listen_addr: listen_addr__.unwrap_or_default(),
3872 opts: opts__.unwrap_or_default(),
3873 })
3874 }
3875 }
3876 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3877 }
3878}
3879impl serde::Serialize for event_log::EventRecovery {
3880 #[allow(deprecated)]
3881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3882 where
3883 S: serde::Serializer,
3884 {
3885 use serde::ser::SerializeStruct;
3886 let mut len = 0;
3887 if self.recovery_event.is_some() {
3888 len += 1;
3889 }
3890 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3891 if let Some(v) = self.recovery_event.as_ref() {
3892 match v {
3893 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3894 struct_ser.serialize_field("globalStart", v)?;
3895 }
3896 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3897 struct_ser.serialize_field("globalSuccess", v)?;
3898 }
3899 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3900 struct_ser.serialize_field("globalFailure", v)?;
3901 }
3902 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3903 struct_ser.serialize_field("databaseStart", v)?;
3904 }
3905 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3906 struct_ser.serialize_field("databaseFailure", v)?;
3907 }
3908 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3909 struct_ser.serialize_field("databaseSuccess", v)?;
3910 }
3911 }
3912 }
3913 struct_ser.end()
3914 }
3915}
3916impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3917 #[allow(deprecated)]
3918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3919 where
3920 D: serde::Deserializer<'de>,
3921 {
3922 const FIELDS: &[&str] = &[
3923 "global_start",
3924 "globalStart",
3925 "global_success",
3926 "globalSuccess",
3927 "global_failure",
3928 "globalFailure",
3929 "database_start",
3930 "databaseStart",
3931 "database_failure",
3932 "databaseFailure",
3933 "database_success",
3934 "databaseSuccess",
3935 ];
3936
3937 #[allow(clippy::enum_variant_names)]
3938 enum GeneratedField {
3939 GlobalStart,
3940 GlobalSuccess,
3941 GlobalFailure,
3942 DatabaseStart,
3943 DatabaseFailure,
3944 DatabaseSuccess,
3945 }
3946 impl<'de> serde::Deserialize<'de> for GeneratedField {
3947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3948 where
3949 D: serde::Deserializer<'de>,
3950 {
3951 struct GeneratedVisitor;
3952
3953 impl serde::de::Visitor<'_> for GeneratedVisitor {
3954 type Value = GeneratedField;
3955
3956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3957 write!(formatter, "expected one of: {:?}", &FIELDS)
3958 }
3959
3960 #[allow(unused_variables)]
3961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3962 where
3963 E: serde::de::Error,
3964 {
3965 match value {
3966 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3967 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3968 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3969 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3970 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3971 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3973 }
3974 }
3975 }
3976 deserializer.deserialize_identifier(GeneratedVisitor)
3977 }
3978 }
3979 struct GeneratedVisitor;
3980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3981 type Value = event_log::EventRecovery;
3982
3983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3984 formatter.write_str("struct meta.EventLog.EventRecovery")
3985 }
3986
3987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3988 where
3989 V: serde::de::MapAccess<'de>,
3990 {
3991 let mut recovery_event__ = None;
3992 while let Some(k) = map_.next_key()? {
3993 match k {
3994 GeneratedField::GlobalStart => {
3995 if recovery_event__.is_some() {
3996 return Err(serde::de::Error::duplicate_field("globalStart"));
3997 }
3998 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3999;
4000 }
4001 GeneratedField::GlobalSuccess => {
4002 if recovery_event__.is_some() {
4003 return Err(serde::de::Error::duplicate_field("globalSuccess"));
4004 }
4005 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
4006;
4007 }
4008 GeneratedField::GlobalFailure => {
4009 if recovery_event__.is_some() {
4010 return Err(serde::de::Error::duplicate_field("globalFailure"));
4011 }
4012 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
4013;
4014 }
4015 GeneratedField::DatabaseStart => {
4016 if recovery_event__.is_some() {
4017 return Err(serde::de::Error::duplicate_field("databaseStart"));
4018 }
4019 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
4020;
4021 }
4022 GeneratedField::DatabaseFailure => {
4023 if recovery_event__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4025 }
4026 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4027;
4028 }
4029 GeneratedField::DatabaseSuccess => {
4030 if recovery_event__.is_some() {
4031 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4032 }
4033 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4034;
4035 }
4036 }
4037 }
4038 Ok(event_log::EventRecovery {
4039 recovery_event: recovery_event__,
4040 })
4041 }
4042 }
4043 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4044 }
4045}
4046impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4047 #[allow(deprecated)]
4048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4049 where
4050 S: serde::Serializer,
4051 {
4052 use serde::ser::SerializeStruct;
4053 let mut len = 0;
4054 if self.database_id != 0 {
4055 len += 1;
4056 }
4057 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4058 if self.database_id != 0 {
4059 struct_ser.serialize_field("databaseId", &self.database_id)?;
4060 }
4061 struct_ser.end()
4062 }
4063}
4064impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4065 #[allow(deprecated)]
4066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4067 where
4068 D: serde::Deserializer<'de>,
4069 {
4070 const FIELDS: &[&str] = &[
4071 "database_id",
4072 "databaseId",
4073 ];
4074
4075 #[allow(clippy::enum_variant_names)]
4076 enum GeneratedField {
4077 DatabaseId,
4078 }
4079 impl<'de> serde::Deserialize<'de> for GeneratedField {
4080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4081 where
4082 D: serde::Deserializer<'de>,
4083 {
4084 struct GeneratedVisitor;
4085
4086 impl serde::de::Visitor<'_> for GeneratedVisitor {
4087 type Value = GeneratedField;
4088
4089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090 write!(formatter, "expected one of: {:?}", &FIELDS)
4091 }
4092
4093 #[allow(unused_variables)]
4094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4095 where
4096 E: serde::de::Error,
4097 {
4098 match value {
4099 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4101 }
4102 }
4103 }
4104 deserializer.deserialize_identifier(GeneratedVisitor)
4105 }
4106 }
4107 struct GeneratedVisitor;
4108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4109 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4110
4111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4112 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4113 }
4114
4115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4116 where
4117 V: serde::de::MapAccess<'de>,
4118 {
4119 let mut database_id__ = None;
4120 while let Some(k) = map_.next_key()? {
4121 match k {
4122 GeneratedField::DatabaseId => {
4123 if database_id__.is_some() {
4124 return Err(serde::de::Error::duplicate_field("databaseId"));
4125 }
4126 database_id__ =
4127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4128 ;
4129 }
4130 }
4131 }
4132 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4133 database_id: database_id__.unwrap_or_default(),
4134 })
4135 }
4136 }
4137 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4138 }
4139}
4140impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4141 #[allow(deprecated)]
4142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4143 where
4144 S: serde::Serializer,
4145 {
4146 use serde::ser::SerializeStruct;
4147 let mut len = 0;
4148 if self.database_id != 0 {
4149 len += 1;
4150 }
4151 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4152 if self.database_id != 0 {
4153 struct_ser.serialize_field("databaseId", &self.database_id)?;
4154 }
4155 struct_ser.end()
4156 }
4157}
4158impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
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 "database_id",
4166 "databaseId",
4167 ];
4168
4169 #[allow(clippy::enum_variant_names)]
4170 enum GeneratedField {
4171 DatabaseId,
4172 }
4173 impl<'de> serde::Deserialize<'de> for GeneratedField {
4174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4175 where
4176 D: serde::Deserializer<'de>,
4177 {
4178 struct GeneratedVisitor;
4179
4180 impl serde::de::Visitor<'_> for GeneratedVisitor {
4181 type Value = GeneratedField;
4182
4183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4184 write!(formatter, "expected one of: {:?}", &FIELDS)
4185 }
4186
4187 #[allow(unused_variables)]
4188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4189 where
4190 E: serde::de::Error,
4191 {
4192 match value {
4193 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4195 }
4196 }
4197 }
4198 deserializer.deserialize_identifier(GeneratedVisitor)
4199 }
4200 }
4201 struct GeneratedVisitor;
4202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4203 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4204
4205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4206 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4207 }
4208
4209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4210 where
4211 V: serde::de::MapAccess<'de>,
4212 {
4213 let mut database_id__ = None;
4214 while let Some(k) = map_.next_key()? {
4215 match k {
4216 GeneratedField::DatabaseId => {
4217 if database_id__.is_some() {
4218 return Err(serde::de::Error::duplicate_field("databaseId"));
4219 }
4220 database_id__ =
4221 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4222 ;
4223 }
4224 }
4225 }
4226 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4227 database_id: database_id__.unwrap_or_default(),
4228 })
4229 }
4230 }
4231 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4232 }
4233}
4234impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4235 #[allow(deprecated)]
4236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4237 where
4238 S: serde::Serializer,
4239 {
4240 use serde::ser::SerializeStruct;
4241 let mut len = 0;
4242 if self.database_id != 0 {
4243 len += 1;
4244 }
4245 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4246 if self.database_id != 0 {
4247 struct_ser.serialize_field("databaseId", &self.database_id)?;
4248 }
4249 struct_ser.end()
4250 }
4251}
4252impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4253 #[allow(deprecated)]
4254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4255 where
4256 D: serde::Deserializer<'de>,
4257 {
4258 const FIELDS: &[&str] = &[
4259 "database_id",
4260 "databaseId",
4261 ];
4262
4263 #[allow(clippy::enum_variant_names)]
4264 enum GeneratedField {
4265 DatabaseId,
4266 }
4267 impl<'de> serde::Deserialize<'de> for GeneratedField {
4268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4269 where
4270 D: serde::Deserializer<'de>,
4271 {
4272 struct GeneratedVisitor;
4273
4274 impl serde::de::Visitor<'_> for GeneratedVisitor {
4275 type Value = GeneratedField;
4276
4277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4278 write!(formatter, "expected one of: {:?}", &FIELDS)
4279 }
4280
4281 #[allow(unused_variables)]
4282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4283 where
4284 E: serde::de::Error,
4285 {
4286 match value {
4287 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4289 }
4290 }
4291 }
4292 deserializer.deserialize_identifier(GeneratedVisitor)
4293 }
4294 }
4295 struct GeneratedVisitor;
4296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4297 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4298
4299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4300 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4301 }
4302
4303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4304 where
4305 V: serde::de::MapAccess<'de>,
4306 {
4307 let mut database_id__ = None;
4308 while let Some(k) = map_.next_key()? {
4309 match k {
4310 GeneratedField::DatabaseId => {
4311 if database_id__.is_some() {
4312 return Err(serde::de::Error::duplicate_field("databaseId"));
4313 }
4314 database_id__ =
4315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4316 ;
4317 }
4318 }
4319 }
4320 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4321 database_id: database_id__.unwrap_or_default(),
4322 })
4323 }
4324 }
4325 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4326 }
4327}
4328impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4329 #[allow(deprecated)]
4330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4331 where
4332 S: serde::Serializer,
4333 {
4334 use serde::ser::SerializeStruct;
4335 let mut len = 0;
4336 if !self.reason.is_empty() {
4337 len += 1;
4338 }
4339 if !self.error.is_empty() {
4340 len += 1;
4341 }
4342 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4343 if !self.reason.is_empty() {
4344 struct_ser.serialize_field("reason", &self.reason)?;
4345 }
4346 if !self.error.is_empty() {
4347 struct_ser.serialize_field("error", &self.error)?;
4348 }
4349 struct_ser.end()
4350 }
4351}
4352impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4353 #[allow(deprecated)]
4354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4355 where
4356 D: serde::Deserializer<'de>,
4357 {
4358 const FIELDS: &[&str] = &[
4359 "reason",
4360 "error",
4361 ];
4362
4363 #[allow(clippy::enum_variant_names)]
4364 enum GeneratedField {
4365 Reason,
4366 Error,
4367 }
4368 impl<'de> serde::Deserialize<'de> for GeneratedField {
4369 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4370 where
4371 D: serde::Deserializer<'de>,
4372 {
4373 struct GeneratedVisitor;
4374
4375 impl serde::de::Visitor<'_> for GeneratedVisitor {
4376 type Value = GeneratedField;
4377
4378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4379 write!(formatter, "expected one of: {:?}", &FIELDS)
4380 }
4381
4382 #[allow(unused_variables)]
4383 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4384 where
4385 E: serde::de::Error,
4386 {
4387 match value {
4388 "reason" => Ok(GeneratedField::Reason),
4389 "error" => Ok(GeneratedField::Error),
4390 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4391 }
4392 }
4393 }
4394 deserializer.deserialize_identifier(GeneratedVisitor)
4395 }
4396 }
4397 struct GeneratedVisitor;
4398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4399 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4400
4401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4402 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4403 }
4404
4405 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4406 where
4407 V: serde::de::MapAccess<'de>,
4408 {
4409 let mut reason__ = None;
4410 let mut error__ = None;
4411 while let Some(k) = map_.next_key()? {
4412 match k {
4413 GeneratedField::Reason => {
4414 if reason__.is_some() {
4415 return Err(serde::de::Error::duplicate_field("reason"));
4416 }
4417 reason__ = Some(map_.next_value()?);
4418 }
4419 GeneratedField::Error => {
4420 if error__.is_some() {
4421 return Err(serde::de::Error::duplicate_field("error"));
4422 }
4423 error__ = Some(map_.next_value()?);
4424 }
4425 }
4426 }
4427 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4428 reason: reason__.unwrap_or_default(),
4429 error: error__.unwrap_or_default(),
4430 })
4431 }
4432 }
4433 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4434 }
4435}
4436impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4437 #[allow(deprecated)]
4438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4439 where
4440 S: serde::Serializer,
4441 {
4442 use serde::ser::SerializeStruct;
4443 let mut len = 0;
4444 if !self.reason.is_empty() {
4445 len += 1;
4446 }
4447 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4448 if !self.reason.is_empty() {
4449 struct_ser.serialize_field("reason", &self.reason)?;
4450 }
4451 struct_ser.end()
4452 }
4453}
4454impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4455 #[allow(deprecated)]
4456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4457 where
4458 D: serde::Deserializer<'de>,
4459 {
4460 const FIELDS: &[&str] = &[
4461 "reason",
4462 ];
4463
4464 #[allow(clippy::enum_variant_names)]
4465 enum GeneratedField {
4466 Reason,
4467 }
4468 impl<'de> serde::Deserialize<'de> for GeneratedField {
4469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4470 where
4471 D: serde::Deserializer<'de>,
4472 {
4473 struct GeneratedVisitor;
4474
4475 impl serde::de::Visitor<'_> for GeneratedVisitor {
4476 type Value = GeneratedField;
4477
4478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4479 write!(formatter, "expected one of: {:?}", &FIELDS)
4480 }
4481
4482 #[allow(unused_variables)]
4483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4484 where
4485 E: serde::de::Error,
4486 {
4487 match value {
4488 "reason" => Ok(GeneratedField::Reason),
4489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4490 }
4491 }
4492 }
4493 deserializer.deserialize_identifier(GeneratedVisitor)
4494 }
4495 }
4496 struct GeneratedVisitor;
4497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4498 type Value = event_log::event_recovery::GlobalRecoveryStart;
4499
4500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4501 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4502 }
4503
4504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4505 where
4506 V: serde::de::MapAccess<'de>,
4507 {
4508 let mut reason__ = None;
4509 while let Some(k) = map_.next_key()? {
4510 match k {
4511 GeneratedField::Reason => {
4512 if reason__.is_some() {
4513 return Err(serde::de::Error::duplicate_field("reason"));
4514 }
4515 reason__ = Some(map_.next_value()?);
4516 }
4517 }
4518 }
4519 Ok(event_log::event_recovery::GlobalRecoveryStart {
4520 reason: reason__.unwrap_or_default(),
4521 })
4522 }
4523 }
4524 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4525 }
4526}
4527impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4528 #[allow(deprecated)]
4529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4530 where
4531 S: serde::Serializer,
4532 {
4533 use serde::ser::SerializeStruct;
4534 let mut len = 0;
4535 if !self.reason.is_empty() {
4536 len += 1;
4537 }
4538 if self.duration_secs != 0. {
4539 len += 1;
4540 }
4541 if !self.running_database_ids.is_empty() {
4542 len += 1;
4543 }
4544 if !self.recovering_database_ids.is_empty() {
4545 len += 1;
4546 }
4547 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4548 if !self.reason.is_empty() {
4549 struct_ser.serialize_field("reason", &self.reason)?;
4550 }
4551 if self.duration_secs != 0. {
4552 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4553 }
4554 if !self.running_database_ids.is_empty() {
4555 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4556 }
4557 if !self.recovering_database_ids.is_empty() {
4558 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4559 }
4560 struct_ser.end()
4561 }
4562}
4563impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4564 #[allow(deprecated)]
4565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4566 where
4567 D: serde::Deserializer<'de>,
4568 {
4569 const FIELDS: &[&str] = &[
4570 "reason",
4571 "duration_secs",
4572 "durationSecs",
4573 "running_database_ids",
4574 "runningDatabaseIds",
4575 "recovering_database_ids",
4576 "recoveringDatabaseIds",
4577 ];
4578
4579 #[allow(clippy::enum_variant_names)]
4580 enum GeneratedField {
4581 Reason,
4582 DurationSecs,
4583 RunningDatabaseIds,
4584 RecoveringDatabaseIds,
4585 }
4586 impl<'de> serde::Deserialize<'de> for GeneratedField {
4587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4588 where
4589 D: serde::Deserializer<'de>,
4590 {
4591 struct GeneratedVisitor;
4592
4593 impl serde::de::Visitor<'_> for GeneratedVisitor {
4594 type Value = GeneratedField;
4595
4596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4597 write!(formatter, "expected one of: {:?}", &FIELDS)
4598 }
4599
4600 #[allow(unused_variables)]
4601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4602 where
4603 E: serde::de::Error,
4604 {
4605 match value {
4606 "reason" => Ok(GeneratedField::Reason),
4607 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4608 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4609 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4610 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4611 }
4612 }
4613 }
4614 deserializer.deserialize_identifier(GeneratedVisitor)
4615 }
4616 }
4617 struct GeneratedVisitor;
4618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4619 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4620
4621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4622 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4623 }
4624
4625 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4626 where
4627 V: serde::de::MapAccess<'de>,
4628 {
4629 let mut reason__ = None;
4630 let mut duration_secs__ = None;
4631 let mut running_database_ids__ = None;
4632 let mut recovering_database_ids__ = None;
4633 while let Some(k) = map_.next_key()? {
4634 match k {
4635 GeneratedField::Reason => {
4636 if reason__.is_some() {
4637 return Err(serde::de::Error::duplicate_field("reason"));
4638 }
4639 reason__ = Some(map_.next_value()?);
4640 }
4641 GeneratedField::DurationSecs => {
4642 if duration_secs__.is_some() {
4643 return Err(serde::de::Error::duplicate_field("durationSecs"));
4644 }
4645 duration_secs__ =
4646 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4647 ;
4648 }
4649 GeneratedField::RunningDatabaseIds => {
4650 if running_database_ids__.is_some() {
4651 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4652 }
4653 running_database_ids__ =
4654 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4655 .into_iter().map(|x| x.0).collect())
4656 ;
4657 }
4658 GeneratedField::RecoveringDatabaseIds => {
4659 if recovering_database_ids__.is_some() {
4660 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4661 }
4662 recovering_database_ids__ =
4663 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4664 .into_iter().map(|x| x.0).collect())
4665 ;
4666 }
4667 }
4668 }
4669 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4670 reason: reason__.unwrap_or_default(),
4671 duration_secs: duration_secs__.unwrap_or_default(),
4672 running_database_ids: running_database_ids__.unwrap_or_default(),
4673 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4674 })
4675 }
4676 }
4677 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4678 }
4679}
4680impl serde::Serialize for event_log::EventSinkFail {
4681 #[allow(deprecated)]
4682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4683 where
4684 S: serde::Serializer,
4685 {
4686 use serde::ser::SerializeStruct;
4687 let mut len = 0;
4688 if self.sink_id != 0 {
4689 len += 1;
4690 }
4691 if !self.sink_name.is_empty() {
4692 len += 1;
4693 }
4694 if !self.connector.is_empty() {
4695 len += 1;
4696 }
4697 if !self.error.is_empty() {
4698 len += 1;
4699 }
4700 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4701 if self.sink_id != 0 {
4702 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4703 }
4704 if !self.sink_name.is_empty() {
4705 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4706 }
4707 if !self.connector.is_empty() {
4708 struct_ser.serialize_field("connector", &self.connector)?;
4709 }
4710 if !self.error.is_empty() {
4711 struct_ser.serialize_field("error", &self.error)?;
4712 }
4713 struct_ser.end()
4714 }
4715}
4716impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4717 #[allow(deprecated)]
4718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4719 where
4720 D: serde::Deserializer<'de>,
4721 {
4722 const FIELDS: &[&str] = &[
4723 "sink_id",
4724 "sinkId",
4725 "sink_name",
4726 "sinkName",
4727 "connector",
4728 "error",
4729 ];
4730
4731 #[allow(clippy::enum_variant_names)]
4732 enum GeneratedField {
4733 SinkId,
4734 SinkName,
4735 Connector,
4736 Error,
4737 }
4738 impl<'de> serde::Deserialize<'de> for GeneratedField {
4739 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4740 where
4741 D: serde::Deserializer<'de>,
4742 {
4743 struct GeneratedVisitor;
4744
4745 impl serde::de::Visitor<'_> for GeneratedVisitor {
4746 type Value = GeneratedField;
4747
4748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4749 write!(formatter, "expected one of: {:?}", &FIELDS)
4750 }
4751
4752 #[allow(unused_variables)]
4753 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4754 where
4755 E: serde::de::Error,
4756 {
4757 match value {
4758 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4759 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4760 "connector" => Ok(GeneratedField::Connector),
4761 "error" => Ok(GeneratedField::Error),
4762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4763 }
4764 }
4765 }
4766 deserializer.deserialize_identifier(GeneratedVisitor)
4767 }
4768 }
4769 struct GeneratedVisitor;
4770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4771 type Value = event_log::EventSinkFail;
4772
4773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4774 formatter.write_str("struct meta.EventLog.EventSinkFail")
4775 }
4776
4777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4778 where
4779 V: serde::de::MapAccess<'de>,
4780 {
4781 let mut sink_id__ = None;
4782 let mut sink_name__ = None;
4783 let mut connector__ = None;
4784 let mut error__ = None;
4785 while let Some(k) = map_.next_key()? {
4786 match k {
4787 GeneratedField::SinkId => {
4788 if sink_id__.is_some() {
4789 return Err(serde::de::Error::duplicate_field("sinkId"));
4790 }
4791 sink_id__ =
4792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4793 ;
4794 }
4795 GeneratedField::SinkName => {
4796 if sink_name__.is_some() {
4797 return Err(serde::de::Error::duplicate_field("sinkName"));
4798 }
4799 sink_name__ = Some(map_.next_value()?);
4800 }
4801 GeneratedField::Connector => {
4802 if connector__.is_some() {
4803 return Err(serde::de::Error::duplicate_field("connector"));
4804 }
4805 connector__ = Some(map_.next_value()?);
4806 }
4807 GeneratedField::Error => {
4808 if error__.is_some() {
4809 return Err(serde::de::Error::duplicate_field("error"));
4810 }
4811 error__ = Some(map_.next_value()?);
4812 }
4813 }
4814 }
4815 Ok(event_log::EventSinkFail {
4816 sink_id: sink_id__.unwrap_or_default(),
4817 sink_name: sink_name__.unwrap_or_default(),
4818 connector: connector__.unwrap_or_default(),
4819 error: error__.unwrap_or_default(),
4820 })
4821 }
4822 }
4823 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4824 }
4825}
4826impl serde::Serialize for event_log::EventWorkerNodePanic {
4827 #[allow(deprecated)]
4828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4829 where
4830 S: serde::Serializer,
4831 {
4832 use serde::ser::SerializeStruct;
4833 let mut len = 0;
4834 if self.worker_id != 0 {
4835 len += 1;
4836 }
4837 if self.worker_type != 0 {
4838 len += 1;
4839 }
4840 if self.host_addr.is_some() {
4841 len += 1;
4842 }
4843 if !self.panic_info.is_empty() {
4844 len += 1;
4845 }
4846 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4847 if self.worker_id != 0 {
4848 struct_ser.serialize_field("workerId", &self.worker_id)?;
4849 }
4850 if self.worker_type != 0 {
4851 let v = super::common::WorkerType::try_from(self.worker_type)
4852 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4853 struct_ser.serialize_field("workerType", &v)?;
4854 }
4855 if let Some(v) = self.host_addr.as_ref() {
4856 struct_ser.serialize_field("hostAddr", v)?;
4857 }
4858 if !self.panic_info.is_empty() {
4859 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4860 }
4861 struct_ser.end()
4862 }
4863}
4864impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4865 #[allow(deprecated)]
4866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4867 where
4868 D: serde::Deserializer<'de>,
4869 {
4870 const FIELDS: &[&str] = &[
4871 "worker_id",
4872 "workerId",
4873 "worker_type",
4874 "workerType",
4875 "host_addr",
4876 "hostAddr",
4877 "panic_info",
4878 "panicInfo",
4879 ];
4880
4881 #[allow(clippy::enum_variant_names)]
4882 enum GeneratedField {
4883 WorkerId,
4884 WorkerType,
4885 HostAddr,
4886 PanicInfo,
4887 }
4888 impl<'de> serde::Deserialize<'de> for GeneratedField {
4889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4890 where
4891 D: serde::Deserializer<'de>,
4892 {
4893 struct GeneratedVisitor;
4894
4895 impl serde::de::Visitor<'_> for GeneratedVisitor {
4896 type Value = GeneratedField;
4897
4898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4899 write!(formatter, "expected one of: {:?}", &FIELDS)
4900 }
4901
4902 #[allow(unused_variables)]
4903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4904 where
4905 E: serde::de::Error,
4906 {
4907 match value {
4908 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4909 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4910 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4911 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4913 }
4914 }
4915 }
4916 deserializer.deserialize_identifier(GeneratedVisitor)
4917 }
4918 }
4919 struct GeneratedVisitor;
4920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4921 type Value = event_log::EventWorkerNodePanic;
4922
4923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4924 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4925 }
4926
4927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4928 where
4929 V: serde::de::MapAccess<'de>,
4930 {
4931 let mut worker_id__ = None;
4932 let mut worker_type__ = None;
4933 let mut host_addr__ = None;
4934 let mut panic_info__ = None;
4935 while let Some(k) = map_.next_key()? {
4936 match k {
4937 GeneratedField::WorkerId => {
4938 if worker_id__.is_some() {
4939 return Err(serde::de::Error::duplicate_field("workerId"));
4940 }
4941 worker_id__ =
4942 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4943 ;
4944 }
4945 GeneratedField::WorkerType => {
4946 if worker_type__.is_some() {
4947 return Err(serde::de::Error::duplicate_field("workerType"));
4948 }
4949 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4950 }
4951 GeneratedField::HostAddr => {
4952 if host_addr__.is_some() {
4953 return Err(serde::de::Error::duplicate_field("hostAddr"));
4954 }
4955 host_addr__ = map_.next_value()?;
4956 }
4957 GeneratedField::PanicInfo => {
4958 if panic_info__.is_some() {
4959 return Err(serde::de::Error::duplicate_field("panicInfo"));
4960 }
4961 panic_info__ = Some(map_.next_value()?);
4962 }
4963 }
4964 }
4965 Ok(event_log::EventWorkerNodePanic {
4966 worker_id: worker_id__.unwrap_or_default(),
4967 worker_type: worker_type__.unwrap_or_default(),
4968 host_addr: host_addr__,
4969 panic_info: panic_info__.unwrap_or_default(),
4970 })
4971 }
4972 }
4973 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4974 }
4975}
4976impl serde::Serialize for FlushRequest {
4977 #[allow(deprecated)]
4978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4979 where
4980 S: serde::Serializer,
4981 {
4982 use serde::ser::SerializeStruct;
4983 let mut len = 0;
4984 if self.database_id != 0 {
4985 len += 1;
4986 }
4987 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4988 if self.database_id != 0 {
4989 struct_ser.serialize_field("databaseId", &self.database_id)?;
4990 }
4991 struct_ser.end()
4992 }
4993}
4994impl<'de> serde::Deserialize<'de> for FlushRequest {
4995 #[allow(deprecated)]
4996 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4997 where
4998 D: serde::Deserializer<'de>,
4999 {
5000 const FIELDS: &[&str] = &[
5001 "database_id",
5002 "databaseId",
5003 ];
5004
5005 #[allow(clippy::enum_variant_names)]
5006 enum GeneratedField {
5007 DatabaseId,
5008 }
5009 impl<'de> serde::Deserialize<'de> for GeneratedField {
5010 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5011 where
5012 D: serde::Deserializer<'de>,
5013 {
5014 struct GeneratedVisitor;
5015
5016 impl serde::de::Visitor<'_> for GeneratedVisitor {
5017 type Value = GeneratedField;
5018
5019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5020 write!(formatter, "expected one of: {:?}", &FIELDS)
5021 }
5022
5023 #[allow(unused_variables)]
5024 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5025 where
5026 E: serde::de::Error,
5027 {
5028 match value {
5029 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5030 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5031 }
5032 }
5033 }
5034 deserializer.deserialize_identifier(GeneratedVisitor)
5035 }
5036 }
5037 struct GeneratedVisitor;
5038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5039 type Value = FlushRequest;
5040
5041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5042 formatter.write_str("struct meta.FlushRequest")
5043 }
5044
5045 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5046 where
5047 V: serde::de::MapAccess<'de>,
5048 {
5049 let mut database_id__ = None;
5050 while let Some(k) = map_.next_key()? {
5051 match k {
5052 GeneratedField::DatabaseId => {
5053 if database_id__.is_some() {
5054 return Err(serde::de::Error::duplicate_field("databaseId"));
5055 }
5056 database_id__ =
5057 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5058 ;
5059 }
5060 }
5061 }
5062 Ok(FlushRequest {
5063 database_id: database_id__.unwrap_or_default(),
5064 })
5065 }
5066 }
5067 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5068 }
5069}
5070impl serde::Serialize for FlushResponse {
5071 #[allow(deprecated)]
5072 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5073 where
5074 S: serde::Serializer,
5075 {
5076 use serde::ser::SerializeStruct;
5077 let mut len = 0;
5078 if self.status.is_some() {
5079 len += 1;
5080 }
5081 if self.hummock_version_id != 0 {
5082 len += 1;
5083 }
5084 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5085 if let Some(v) = self.status.as_ref() {
5086 struct_ser.serialize_field("status", v)?;
5087 }
5088 if self.hummock_version_id != 0 {
5089 #[allow(clippy::needless_borrow)]
5090 #[allow(clippy::needless_borrows_for_generic_args)]
5091 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5092 }
5093 struct_ser.end()
5094 }
5095}
5096impl<'de> serde::Deserialize<'de> for FlushResponse {
5097 #[allow(deprecated)]
5098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5099 where
5100 D: serde::Deserializer<'de>,
5101 {
5102 const FIELDS: &[&str] = &[
5103 "status",
5104 "hummock_version_id",
5105 "hummockVersionId",
5106 ];
5107
5108 #[allow(clippy::enum_variant_names)]
5109 enum GeneratedField {
5110 Status,
5111 HummockVersionId,
5112 }
5113 impl<'de> serde::Deserialize<'de> for GeneratedField {
5114 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5115 where
5116 D: serde::Deserializer<'de>,
5117 {
5118 struct GeneratedVisitor;
5119
5120 impl serde::de::Visitor<'_> for GeneratedVisitor {
5121 type Value = GeneratedField;
5122
5123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5124 write!(formatter, "expected one of: {:?}", &FIELDS)
5125 }
5126
5127 #[allow(unused_variables)]
5128 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5129 where
5130 E: serde::de::Error,
5131 {
5132 match value {
5133 "status" => Ok(GeneratedField::Status),
5134 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5135 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5136 }
5137 }
5138 }
5139 deserializer.deserialize_identifier(GeneratedVisitor)
5140 }
5141 }
5142 struct GeneratedVisitor;
5143 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5144 type Value = FlushResponse;
5145
5146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5147 formatter.write_str("struct meta.FlushResponse")
5148 }
5149
5150 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5151 where
5152 V: serde::de::MapAccess<'de>,
5153 {
5154 let mut status__ = None;
5155 let mut hummock_version_id__ = None;
5156 while let Some(k) = map_.next_key()? {
5157 match k {
5158 GeneratedField::Status => {
5159 if status__.is_some() {
5160 return Err(serde::de::Error::duplicate_field("status"));
5161 }
5162 status__ = map_.next_value()?;
5163 }
5164 GeneratedField::HummockVersionId => {
5165 if hummock_version_id__.is_some() {
5166 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5167 }
5168 hummock_version_id__ =
5169 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5170 ;
5171 }
5172 }
5173 }
5174 Ok(FlushResponse {
5175 status: status__,
5176 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5177 })
5178 }
5179 }
5180 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5181 }
5182}
5183impl serde::Serialize for FragmentDistribution {
5184 #[allow(deprecated)]
5185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5186 where
5187 S: serde::Serializer,
5188 {
5189 use serde::ser::SerializeStruct;
5190 let mut len = 0;
5191 if self.fragment_id != 0 {
5192 len += 1;
5193 }
5194 if self.table_id != 0 {
5195 len += 1;
5196 }
5197 if self.distribution_type != 0 {
5198 len += 1;
5199 }
5200 if !self.state_table_ids.is_empty() {
5201 len += 1;
5202 }
5203 if !self.upstream_fragment_ids.is_empty() {
5204 len += 1;
5205 }
5206 if self.fragment_type_mask != 0 {
5207 len += 1;
5208 }
5209 if self.parallelism != 0 {
5210 len += 1;
5211 }
5212 if self.vnode_count != 0 {
5213 len += 1;
5214 }
5215 if self.node.is_some() {
5216 len += 1;
5217 }
5218 if !self.parallelism_policy.is_empty() {
5219 len += 1;
5220 }
5221 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5222 if self.fragment_id != 0 {
5223 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5224 }
5225 if self.table_id != 0 {
5226 struct_ser.serialize_field("tableId", &self.table_id)?;
5227 }
5228 if self.distribution_type != 0 {
5229 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5230 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5231 struct_ser.serialize_field("distributionType", &v)?;
5232 }
5233 if !self.state_table_ids.is_empty() {
5234 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5235 }
5236 if !self.upstream_fragment_ids.is_empty() {
5237 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5238 }
5239 if self.fragment_type_mask != 0 {
5240 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5241 }
5242 if self.parallelism != 0 {
5243 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5244 }
5245 if self.vnode_count != 0 {
5246 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5247 }
5248 if let Some(v) = self.node.as_ref() {
5249 struct_ser.serialize_field("node", v)?;
5250 }
5251 if !self.parallelism_policy.is_empty() {
5252 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5253 }
5254 struct_ser.end()
5255 }
5256}
5257impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5258 #[allow(deprecated)]
5259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5260 where
5261 D: serde::Deserializer<'de>,
5262 {
5263 const FIELDS: &[&str] = &[
5264 "fragment_id",
5265 "fragmentId",
5266 "table_id",
5267 "tableId",
5268 "distribution_type",
5269 "distributionType",
5270 "state_table_ids",
5271 "stateTableIds",
5272 "upstream_fragment_ids",
5273 "upstreamFragmentIds",
5274 "fragment_type_mask",
5275 "fragmentTypeMask",
5276 "parallelism",
5277 "vnode_count",
5278 "vnodeCount",
5279 "node",
5280 "parallelism_policy",
5281 "parallelismPolicy",
5282 ];
5283
5284 #[allow(clippy::enum_variant_names)]
5285 enum GeneratedField {
5286 FragmentId,
5287 TableId,
5288 DistributionType,
5289 StateTableIds,
5290 UpstreamFragmentIds,
5291 FragmentTypeMask,
5292 Parallelism,
5293 VnodeCount,
5294 Node,
5295 ParallelismPolicy,
5296 }
5297 impl<'de> serde::Deserialize<'de> for GeneratedField {
5298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5299 where
5300 D: serde::Deserializer<'de>,
5301 {
5302 struct GeneratedVisitor;
5303
5304 impl serde::de::Visitor<'_> for GeneratedVisitor {
5305 type Value = GeneratedField;
5306
5307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5308 write!(formatter, "expected one of: {:?}", &FIELDS)
5309 }
5310
5311 #[allow(unused_variables)]
5312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5313 where
5314 E: serde::de::Error,
5315 {
5316 match value {
5317 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5318 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5319 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5320 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5321 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5322 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5323 "parallelism" => Ok(GeneratedField::Parallelism),
5324 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5325 "node" => Ok(GeneratedField::Node),
5326 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5328 }
5329 }
5330 }
5331 deserializer.deserialize_identifier(GeneratedVisitor)
5332 }
5333 }
5334 struct GeneratedVisitor;
5335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5336 type Value = FragmentDistribution;
5337
5338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5339 formatter.write_str("struct meta.FragmentDistribution")
5340 }
5341
5342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5343 where
5344 V: serde::de::MapAccess<'de>,
5345 {
5346 let mut fragment_id__ = None;
5347 let mut table_id__ = None;
5348 let mut distribution_type__ = None;
5349 let mut state_table_ids__ = None;
5350 let mut upstream_fragment_ids__ = None;
5351 let mut fragment_type_mask__ = None;
5352 let mut parallelism__ = None;
5353 let mut vnode_count__ = None;
5354 let mut node__ = None;
5355 let mut parallelism_policy__ = None;
5356 while let Some(k) = map_.next_key()? {
5357 match k {
5358 GeneratedField::FragmentId => {
5359 if fragment_id__.is_some() {
5360 return Err(serde::de::Error::duplicate_field("fragmentId"));
5361 }
5362 fragment_id__ =
5363 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5364 ;
5365 }
5366 GeneratedField::TableId => {
5367 if table_id__.is_some() {
5368 return Err(serde::de::Error::duplicate_field("tableId"));
5369 }
5370 table_id__ =
5371 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5372 ;
5373 }
5374 GeneratedField::DistributionType => {
5375 if distribution_type__.is_some() {
5376 return Err(serde::de::Error::duplicate_field("distributionType"));
5377 }
5378 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5379 }
5380 GeneratedField::StateTableIds => {
5381 if state_table_ids__.is_some() {
5382 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5383 }
5384 state_table_ids__ =
5385 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5386 .into_iter().map(|x| x.0).collect())
5387 ;
5388 }
5389 GeneratedField::UpstreamFragmentIds => {
5390 if upstream_fragment_ids__.is_some() {
5391 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5392 }
5393 upstream_fragment_ids__ =
5394 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5395 .into_iter().map(|x| x.0).collect())
5396 ;
5397 }
5398 GeneratedField::FragmentTypeMask => {
5399 if fragment_type_mask__.is_some() {
5400 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5401 }
5402 fragment_type_mask__ =
5403 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5404 ;
5405 }
5406 GeneratedField::Parallelism => {
5407 if parallelism__.is_some() {
5408 return Err(serde::de::Error::duplicate_field("parallelism"));
5409 }
5410 parallelism__ =
5411 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5412 ;
5413 }
5414 GeneratedField::VnodeCount => {
5415 if vnode_count__.is_some() {
5416 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5417 }
5418 vnode_count__ =
5419 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5420 ;
5421 }
5422 GeneratedField::Node => {
5423 if node__.is_some() {
5424 return Err(serde::de::Error::duplicate_field("node"));
5425 }
5426 node__ = map_.next_value()?;
5427 }
5428 GeneratedField::ParallelismPolicy => {
5429 if parallelism_policy__.is_some() {
5430 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5431 }
5432 parallelism_policy__ = Some(map_.next_value()?);
5433 }
5434 }
5435 }
5436 Ok(FragmentDistribution {
5437 fragment_id: fragment_id__.unwrap_or_default(),
5438 table_id: table_id__.unwrap_or_default(),
5439 distribution_type: distribution_type__.unwrap_or_default(),
5440 state_table_ids: state_table_ids__.unwrap_or_default(),
5441 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5442 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5443 parallelism: parallelism__.unwrap_or_default(),
5444 vnode_count: vnode_count__.unwrap_or_default(),
5445 node: node__,
5446 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5447 })
5448 }
5449 }
5450 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5451 }
5452}
5453impl serde::Serialize for FragmentIdToActorIdMap {
5454 #[allow(deprecated)]
5455 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5456 where
5457 S: serde::Serializer,
5458 {
5459 use serde::ser::SerializeStruct;
5460 let mut len = 0;
5461 if !self.map.is_empty() {
5462 len += 1;
5463 }
5464 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5465 if !self.map.is_empty() {
5466 struct_ser.serialize_field("map", &self.map)?;
5467 }
5468 struct_ser.end()
5469 }
5470}
5471impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5472 #[allow(deprecated)]
5473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5474 where
5475 D: serde::Deserializer<'de>,
5476 {
5477 const FIELDS: &[&str] = &[
5478 "map",
5479 ];
5480
5481 #[allow(clippy::enum_variant_names)]
5482 enum GeneratedField {
5483 Map,
5484 }
5485 impl<'de> serde::Deserialize<'de> for GeneratedField {
5486 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5487 where
5488 D: serde::Deserializer<'de>,
5489 {
5490 struct GeneratedVisitor;
5491
5492 impl serde::de::Visitor<'_> for GeneratedVisitor {
5493 type Value = GeneratedField;
5494
5495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5496 write!(formatter, "expected one of: {:?}", &FIELDS)
5497 }
5498
5499 #[allow(unused_variables)]
5500 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5501 where
5502 E: serde::de::Error,
5503 {
5504 match value {
5505 "map" => Ok(GeneratedField::Map),
5506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5507 }
5508 }
5509 }
5510 deserializer.deserialize_identifier(GeneratedVisitor)
5511 }
5512 }
5513 struct GeneratedVisitor;
5514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5515 type Value = FragmentIdToActorIdMap;
5516
5517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5518 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5519 }
5520
5521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5522 where
5523 V: serde::de::MapAccess<'de>,
5524 {
5525 let mut map__ = None;
5526 while let Some(k) = map_.next_key()? {
5527 match k {
5528 GeneratedField::Map => {
5529 if map__.is_some() {
5530 return Err(serde::de::Error::duplicate_field("map"));
5531 }
5532 map__ = Some(
5533 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5534 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5535 );
5536 }
5537 }
5538 }
5539 Ok(FragmentIdToActorIdMap {
5540 map: map__.unwrap_or_default(),
5541 })
5542 }
5543 }
5544 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5545 }
5546}
5547impl serde::Serialize for FragmentToRelationMap {
5548 #[allow(deprecated)]
5549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5550 where
5551 S: serde::Serializer,
5552 {
5553 use serde::ser::SerializeStruct;
5554 let mut len = 0;
5555 if !self.fragment_to_relation_map.is_empty() {
5556 len += 1;
5557 }
5558 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5559 if !self.fragment_to_relation_map.is_empty() {
5560 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5561 }
5562 struct_ser.end()
5563 }
5564}
5565impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5566 #[allow(deprecated)]
5567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5568 where
5569 D: serde::Deserializer<'de>,
5570 {
5571 const FIELDS: &[&str] = &[
5572 "fragment_to_relation_map",
5573 "fragmentToRelationMap",
5574 ];
5575
5576 #[allow(clippy::enum_variant_names)]
5577 enum GeneratedField {
5578 FragmentToRelationMap,
5579 }
5580 impl<'de> serde::Deserialize<'de> for GeneratedField {
5581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5582 where
5583 D: serde::Deserializer<'de>,
5584 {
5585 struct GeneratedVisitor;
5586
5587 impl serde::de::Visitor<'_> for GeneratedVisitor {
5588 type Value = GeneratedField;
5589
5590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5591 write!(formatter, "expected one of: {:?}", &FIELDS)
5592 }
5593
5594 #[allow(unused_variables)]
5595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5596 where
5597 E: serde::de::Error,
5598 {
5599 match value {
5600 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5601 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5602 }
5603 }
5604 }
5605 deserializer.deserialize_identifier(GeneratedVisitor)
5606 }
5607 }
5608 struct GeneratedVisitor;
5609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5610 type Value = FragmentToRelationMap;
5611
5612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5613 formatter.write_str("struct meta.FragmentToRelationMap")
5614 }
5615
5616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5617 where
5618 V: serde::de::MapAccess<'de>,
5619 {
5620 let mut fragment_to_relation_map__ = None;
5621 while let Some(k) = map_.next_key()? {
5622 match k {
5623 GeneratedField::FragmentToRelationMap => {
5624 if fragment_to_relation_map__.is_some() {
5625 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5626 }
5627 fragment_to_relation_map__ = Some(
5628 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5629 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
5630 );
5631 }
5632 }
5633 }
5634 Ok(FragmentToRelationMap {
5635 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5636 })
5637 }
5638 }
5639 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5640 }
5641}
5642impl serde::Serialize for FragmentWorkerSlotMapping {
5643 #[allow(deprecated)]
5644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5645 where
5646 S: serde::Serializer,
5647 {
5648 use serde::ser::SerializeStruct;
5649 let mut len = 0;
5650 if self.fragment_id != 0 {
5651 len += 1;
5652 }
5653 if self.mapping.is_some() {
5654 len += 1;
5655 }
5656 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5657 if self.fragment_id != 0 {
5658 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5659 }
5660 if let Some(v) = self.mapping.as_ref() {
5661 struct_ser.serialize_field("mapping", v)?;
5662 }
5663 struct_ser.end()
5664 }
5665}
5666impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5667 #[allow(deprecated)]
5668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5669 where
5670 D: serde::Deserializer<'de>,
5671 {
5672 const FIELDS: &[&str] = &[
5673 "fragment_id",
5674 "fragmentId",
5675 "mapping",
5676 ];
5677
5678 #[allow(clippy::enum_variant_names)]
5679 enum GeneratedField {
5680 FragmentId,
5681 Mapping,
5682 }
5683 impl<'de> serde::Deserialize<'de> for GeneratedField {
5684 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5685 where
5686 D: serde::Deserializer<'de>,
5687 {
5688 struct GeneratedVisitor;
5689
5690 impl serde::de::Visitor<'_> for GeneratedVisitor {
5691 type Value = GeneratedField;
5692
5693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5694 write!(formatter, "expected one of: {:?}", &FIELDS)
5695 }
5696
5697 #[allow(unused_variables)]
5698 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5699 where
5700 E: serde::de::Error,
5701 {
5702 match value {
5703 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5704 "mapping" => Ok(GeneratedField::Mapping),
5705 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5706 }
5707 }
5708 }
5709 deserializer.deserialize_identifier(GeneratedVisitor)
5710 }
5711 }
5712 struct GeneratedVisitor;
5713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5714 type Value = FragmentWorkerSlotMapping;
5715
5716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5717 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5718 }
5719
5720 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5721 where
5722 V: serde::de::MapAccess<'de>,
5723 {
5724 let mut fragment_id__ = None;
5725 let mut mapping__ = None;
5726 while let Some(k) = map_.next_key()? {
5727 match k {
5728 GeneratedField::FragmentId => {
5729 if fragment_id__.is_some() {
5730 return Err(serde::de::Error::duplicate_field("fragmentId"));
5731 }
5732 fragment_id__ =
5733 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5734 ;
5735 }
5736 GeneratedField::Mapping => {
5737 if mapping__.is_some() {
5738 return Err(serde::de::Error::duplicate_field("mapping"));
5739 }
5740 mapping__ = map_.next_value()?;
5741 }
5742 }
5743 }
5744 Ok(FragmentWorkerSlotMapping {
5745 fragment_id: fragment_id__.unwrap_or_default(),
5746 mapping: mapping__,
5747 })
5748 }
5749 }
5750 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5751 }
5752}
5753impl serde::Serialize for FragmentWorkerSlotMappings {
5754 #[allow(deprecated)]
5755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5756 where
5757 S: serde::Serializer,
5758 {
5759 use serde::ser::SerializeStruct;
5760 let mut len = 0;
5761 if !self.mappings.is_empty() {
5762 len += 1;
5763 }
5764 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5765 if !self.mappings.is_empty() {
5766 struct_ser.serialize_field("mappings", &self.mappings)?;
5767 }
5768 struct_ser.end()
5769 }
5770}
5771impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5772 #[allow(deprecated)]
5773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5774 where
5775 D: serde::Deserializer<'de>,
5776 {
5777 const FIELDS: &[&str] = &[
5778 "mappings",
5779 ];
5780
5781 #[allow(clippy::enum_variant_names)]
5782 enum GeneratedField {
5783 Mappings,
5784 }
5785 impl<'de> serde::Deserialize<'de> for GeneratedField {
5786 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5787 where
5788 D: serde::Deserializer<'de>,
5789 {
5790 struct GeneratedVisitor;
5791
5792 impl serde::de::Visitor<'_> for GeneratedVisitor {
5793 type Value = GeneratedField;
5794
5795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5796 write!(formatter, "expected one of: {:?}", &FIELDS)
5797 }
5798
5799 #[allow(unused_variables)]
5800 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5801 where
5802 E: serde::de::Error,
5803 {
5804 match value {
5805 "mappings" => Ok(GeneratedField::Mappings),
5806 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5807 }
5808 }
5809 }
5810 deserializer.deserialize_identifier(GeneratedVisitor)
5811 }
5812 }
5813 struct GeneratedVisitor;
5814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5815 type Value = FragmentWorkerSlotMappings;
5816
5817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5818 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5819 }
5820
5821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5822 where
5823 V: serde::de::MapAccess<'de>,
5824 {
5825 let mut mappings__ = None;
5826 while let Some(k) = map_.next_key()? {
5827 match k {
5828 GeneratedField::Mappings => {
5829 if mappings__.is_some() {
5830 return Err(serde::de::Error::duplicate_field("mappings"));
5831 }
5832 mappings__ = Some(map_.next_value()?);
5833 }
5834 }
5835 }
5836 Ok(FragmentWorkerSlotMappings {
5837 mappings: mappings__.unwrap_or_default(),
5838 })
5839 }
5840 }
5841 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5842 }
5843}
5844impl serde::Serialize for GetActorVnodesRequest {
5845 #[allow(deprecated)]
5846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5847 where
5848 S: serde::Serializer,
5849 {
5850 use serde::ser::SerializeStruct;
5851 let mut len = 0;
5852 if self.actor_id != 0 {
5853 len += 1;
5854 }
5855 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
5856 if self.actor_id != 0 {
5857 struct_ser.serialize_field("actorId", &self.actor_id)?;
5858 }
5859 struct_ser.end()
5860 }
5861}
5862impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
5863 #[allow(deprecated)]
5864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5865 where
5866 D: serde::Deserializer<'de>,
5867 {
5868 const FIELDS: &[&str] = &[
5869 "actor_id",
5870 "actorId",
5871 ];
5872
5873 #[allow(clippy::enum_variant_names)]
5874 enum GeneratedField {
5875 ActorId,
5876 }
5877 impl<'de> serde::Deserialize<'de> for GeneratedField {
5878 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5879 where
5880 D: serde::Deserializer<'de>,
5881 {
5882 struct GeneratedVisitor;
5883
5884 impl serde::de::Visitor<'_> for GeneratedVisitor {
5885 type Value = GeneratedField;
5886
5887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5888 write!(formatter, "expected one of: {:?}", &FIELDS)
5889 }
5890
5891 #[allow(unused_variables)]
5892 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5893 where
5894 E: serde::de::Error,
5895 {
5896 match value {
5897 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
5898 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5899 }
5900 }
5901 }
5902 deserializer.deserialize_identifier(GeneratedVisitor)
5903 }
5904 }
5905 struct GeneratedVisitor;
5906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5907 type Value = GetActorVnodesRequest;
5908
5909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5910 formatter.write_str("struct meta.GetActorVnodesRequest")
5911 }
5912
5913 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
5914 where
5915 V: serde::de::MapAccess<'de>,
5916 {
5917 let mut actor_id__ = None;
5918 while let Some(k) = map_.next_key()? {
5919 match k {
5920 GeneratedField::ActorId => {
5921 if actor_id__.is_some() {
5922 return Err(serde::de::Error::duplicate_field("actorId"));
5923 }
5924 actor_id__ =
5925 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5926 ;
5927 }
5928 }
5929 }
5930 Ok(GetActorVnodesRequest {
5931 actor_id: actor_id__.unwrap_or_default(),
5932 })
5933 }
5934 }
5935 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
5936 }
5937}
5938impl serde::Serialize for GetActorVnodesResponse {
5939 #[allow(deprecated)]
5940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5941 where
5942 S: serde::Serializer,
5943 {
5944 use serde::ser::SerializeStruct;
5945 let mut len = 0;
5946 if !self.vnode_indices.is_empty() {
5947 len += 1;
5948 }
5949 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
5950 if !self.vnode_indices.is_empty() {
5951 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
5952 }
5953 struct_ser.end()
5954 }
5955}
5956impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
5957 #[allow(deprecated)]
5958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5959 where
5960 D: serde::Deserializer<'de>,
5961 {
5962 const FIELDS: &[&str] = &[
5963 "vnode_indices",
5964 "vnodeIndices",
5965 ];
5966
5967 #[allow(clippy::enum_variant_names)]
5968 enum GeneratedField {
5969 VnodeIndices,
5970 }
5971 impl<'de> serde::Deserialize<'de> for GeneratedField {
5972 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5973 where
5974 D: serde::Deserializer<'de>,
5975 {
5976 struct GeneratedVisitor;
5977
5978 impl serde::de::Visitor<'_> for GeneratedVisitor {
5979 type Value = GeneratedField;
5980
5981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5982 write!(formatter, "expected one of: {:?}", &FIELDS)
5983 }
5984
5985 #[allow(unused_variables)]
5986 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5987 where
5988 E: serde::de::Error,
5989 {
5990 match value {
5991 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
5992 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5993 }
5994 }
5995 }
5996 deserializer.deserialize_identifier(GeneratedVisitor)
5997 }
5998 }
5999 struct GeneratedVisitor;
6000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6001 type Value = GetActorVnodesResponse;
6002
6003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6004 formatter.write_str("struct meta.GetActorVnodesResponse")
6005 }
6006
6007 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
6008 where
6009 V: serde::de::MapAccess<'de>,
6010 {
6011 let mut vnode_indices__ = None;
6012 while let Some(k) = map_.next_key()? {
6013 match k {
6014 GeneratedField::VnodeIndices => {
6015 if vnode_indices__.is_some() {
6016 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
6017 }
6018 vnode_indices__ =
6019 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6020 .into_iter().map(|x| x.0).collect())
6021 ;
6022 }
6023 }
6024 }
6025 Ok(GetActorVnodesResponse {
6026 vnode_indices: vnode_indices__.unwrap_or_default(),
6027 })
6028 }
6029 }
6030 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6031 }
6032}
6033impl serde::Serialize for GetClusterInfoRequest {
6034 #[allow(deprecated)]
6035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6036 where
6037 S: serde::Serializer,
6038 {
6039 use serde::ser::SerializeStruct;
6040 let len = 0;
6041 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6042 struct_ser.end()
6043 }
6044}
6045impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6046 #[allow(deprecated)]
6047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6048 where
6049 D: serde::Deserializer<'de>,
6050 {
6051 const FIELDS: &[&str] = &[
6052 ];
6053
6054 #[allow(clippy::enum_variant_names)]
6055 enum GeneratedField {
6056 }
6057 impl<'de> serde::Deserialize<'de> for GeneratedField {
6058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6059 where
6060 D: serde::Deserializer<'de>,
6061 {
6062 struct GeneratedVisitor;
6063
6064 impl serde::de::Visitor<'_> for GeneratedVisitor {
6065 type Value = GeneratedField;
6066
6067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6068 write!(formatter, "expected one of: {:?}", &FIELDS)
6069 }
6070
6071 #[allow(unused_variables)]
6072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6073 where
6074 E: serde::de::Error,
6075 {
6076 Err(serde::de::Error::unknown_field(value, FIELDS))
6077 }
6078 }
6079 deserializer.deserialize_identifier(GeneratedVisitor)
6080 }
6081 }
6082 struct GeneratedVisitor;
6083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6084 type Value = GetClusterInfoRequest;
6085
6086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6087 formatter.write_str("struct meta.GetClusterInfoRequest")
6088 }
6089
6090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6091 where
6092 V: serde::de::MapAccess<'de>,
6093 {
6094 while map_.next_key::<GeneratedField>()?.is_some() {
6095 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6096 }
6097 Ok(GetClusterInfoRequest {
6098 })
6099 }
6100 }
6101 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6102 }
6103}
6104impl serde::Serialize for GetClusterInfoResponse {
6105 #[allow(deprecated)]
6106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6107 where
6108 S: serde::Serializer,
6109 {
6110 use serde::ser::SerializeStruct;
6111 let mut len = 0;
6112 if !self.worker_nodes.is_empty() {
6113 len += 1;
6114 }
6115 if !self.table_fragments.is_empty() {
6116 len += 1;
6117 }
6118 if !self.actor_splits.is_empty() {
6119 len += 1;
6120 }
6121 if !self.source_infos.is_empty() {
6122 len += 1;
6123 }
6124 if self.revision != 0 {
6125 len += 1;
6126 }
6127 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6128 if !self.worker_nodes.is_empty() {
6129 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6130 }
6131 if !self.table_fragments.is_empty() {
6132 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6133 }
6134 if !self.actor_splits.is_empty() {
6135 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6136 }
6137 if !self.source_infos.is_empty() {
6138 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6139 }
6140 if self.revision != 0 {
6141 #[allow(clippy::needless_borrow)]
6142 #[allow(clippy::needless_borrows_for_generic_args)]
6143 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6144 }
6145 struct_ser.end()
6146 }
6147}
6148impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6149 #[allow(deprecated)]
6150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6151 where
6152 D: serde::Deserializer<'de>,
6153 {
6154 const FIELDS: &[&str] = &[
6155 "worker_nodes",
6156 "workerNodes",
6157 "table_fragments",
6158 "tableFragments",
6159 "actor_splits",
6160 "actorSplits",
6161 "source_infos",
6162 "sourceInfos",
6163 "revision",
6164 ];
6165
6166 #[allow(clippy::enum_variant_names)]
6167 enum GeneratedField {
6168 WorkerNodes,
6169 TableFragments,
6170 ActorSplits,
6171 SourceInfos,
6172 Revision,
6173 }
6174 impl<'de> serde::Deserialize<'de> for GeneratedField {
6175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6176 where
6177 D: serde::Deserializer<'de>,
6178 {
6179 struct GeneratedVisitor;
6180
6181 impl serde::de::Visitor<'_> for GeneratedVisitor {
6182 type Value = GeneratedField;
6183
6184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6185 write!(formatter, "expected one of: {:?}", &FIELDS)
6186 }
6187
6188 #[allow(unused_variables)]
6189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6190 where
6191 E: serde::de::Error,
6192 {
6193 match value {
6194 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6195 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6196 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6197 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6198 "revision" => Ok(GeneratedField::Revision),
6199 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6200 }
6201 }
6202 }
6203 deserializer.deserialize_identifier(GeneratedVisitor)
6204 }
6205 }
6206 struct GeneratedVisitor;
6207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6208 type Value = GetClusterInfoResponse;
6209
6210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6211 formatter.write_str("struct meta.GetClusterInfoResponse")
6212 }
6213
6214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6215 where
6216 V: serde::de::MapAccess<'de>,
6217 {
6218 let mut worker_nodes__ = None;
6219 let mut table_fragments__ = None;
6220 let mut actor_splits__ = None;
6221 let mut source_infos__ = None;
6222 let mut revision__ = None;
6223 while let Some(k) = map_.next_key()? {
6224 match k {
6225 GeneratedField::WorkerNodes => {
6226 if worker_nodes__.is_some() {
6227 return Err(serde::de::Error::duplicate_field("workerNodes"));
6228 }
6229 worker_nodes__ = Some(map_.next_value()?);
6230 }
6231 GeneratedField::TableFragments => {
6232 if table_fragments__.is_some() {
6233 return Err(serde::de::Error::duplicate_field("tableFragments"));
6234 }
6235 table_fragments__ = Some(map_.next_value()?);
6236 }
6237 GeneratedField::ActorSplits => {
6238 if actor_splits__.is_some() {
6239 return Err(serde::de::Error::duplicate_field("actorSplits"));
6240 }
6241 actor_splits__ = Some(
6242 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6243 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6244 );
6245 }
6246 GeneratedField::SourceInfos => {
6247 if source_infos__.is_some() {
6248 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6249 }
6250 source_infos__ = Some(
6251 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6252 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6253 );
6254 }
6255 GeneratedField::Revision => {
6256 if revision__.is_some() {
6257 return Err(serde::de::Error::duplicate_field("revision"));
6258 }
6259 revision__ =
6260 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6261 ;
6262 }
6263 }
6264 }
6265 Ok(GetClusterInfoResponse {
6266 worker_nodes: worker_nodes__.unwrap_or_default(),
6267 table_fragments: table_fragments__.unwrap_or_default(),
6268 actor_splits: actor_splits__.unwrap_or_default(),
6269 source_infos: source_infos__.unwrap_or_default(),
6270 revision: revision__.unwrap_or_default(),
6271 })
6272 }
6273 }
6274 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6275 }
6276}
6277impl serde::Serialize for GetClusterLimitsRequest {
6278 #[allow(deprecated)]
6279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6280 where
6281 S: serde::Serializer,
6282 {
6283 use serde::ser::SerializeStruct;
6284 let len = 0;
6285 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6286 struct_ser.end()
6287 }
6288}
6289impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6290 #[allow(deprecated)]
6291 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6292 where
6293 D: serde::Deserializer<'de>,
6294 {
6295 const FIELDS: &[&str] = &[
6296 ];
6297
6298 #[allow(clippy::enum_variant_names)]
6299 enum GeneratedField {
6300 }
6301 impl<'de> serde::Deserialize<'de> for GeneratedField {
6302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6303 where
6304 D: serde::Deserializer<'de>,
6305 {
6306 struct GeneratedVisitor;
6307
6308 impl serde::de::Visitor<'_> for GeneratedVisitor {
6309 type Value = GeneratedField;
6310
6311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6312 write!(formatter, "expected one of: {:?}", &FIELDS)
6313 }
6314
6315 #[allow(unused_variables)]
6316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6317 where
6318 E: serde::de::Error,
6319 {
6320 Err(serde::de::Error::unknown_field(value, FIELDS))
6321 }
6322 }
6323 deserializer.deserialize_identifier(GeneratedVisitor)
6324 }
6325 }
6326 struct GeneratedVisitor;
6327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6328 type Value = GetClusterLimitsRequest;
6329
6330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6331 formatter.write_str("struct meta.GetClusterLimitsRequest")
6332 }
6333
6334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6335 where
6336 V: serde::de::MapAccess<'de>,
6337 {
6338 while map_.next_key::<GeneratedField>()?.is_some() {
6339 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6340 }
6341 Ok(GetClusterLimitsRequest {
6342 })
6343 }
6344 }
6345 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6346 }
6347}
6348impl serde::Serialize for GetClusterLimitsResponse {
6349 #[allow(deprecated)]
6350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6351 where
6352 S: serde::Serializer,
6353 {
6354 use serde::ser::SerializeStruct;
6355 let mut len = 0;
6356 if !self.active_limits.is_empty() {
6357 len += 1;
6358 }
6359 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6360 if !self.active_limits.is_empty() {
6361 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6362 }
6363 struct_ser.end()
6364 }
6365}
6366impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6367 #[allow(deprecated)]
6368 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6369 where
6370 D: serde::Deserializer<'de>,
6371 {
6372 const FIELDS: &[&str] = &[
6373 "active_limits",
6374 "activeLimits",
6375 ];
6376
6377 #[allow(clippy::enum_variant_names)]
6378 enum GeneratedField {
6379 ActiveLimits,
6380 }
6381 impl<'de> serde::Deserialize<'de> for GeneratedField {
6382 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6383 where
6384 D: serde::Deserializer<'de>,
6385 {
6386 struct GeneratedVisitor;
6387
6388 impl serde::de::Visitor<'_> for GeneratedVisitor {
6389 type Value = GeneratedField;
6390
6391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6392 write!(formatter, "expected one of: {:?}", &FIELDS)
6393 }
6394
6395 #[allow(unused_variables)]
6396 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6397 where
6398 E: serde::de::Error,
6399 {
6400 match value {
6401 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6402 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6403 }
6404 }
6405 }
6406 deserializer.deserialize_identifier(GeneratedVisitor)
6407 }
6408 }
6409 struct GeneratedVisitor;
6410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6411 type Value = GetClusterLimitsResponse;
6412
6413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6414 formatter.write_str("struct meta.GetClusterLimitsResponse")
6415 }
6416
6417 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6418 where
6419 V: serde::de::MapAccess<'de>,
6420 {
6421 let mut active_limits__ = None;
6422 while let Some(k) = map_.next_key()? {
6423 match k {
6424 GeneratedField::ActiveLimits => {
6425 if active_limits__.is_some() {
6426 return Err(serde::de::Error::duplicate_field("activeLimits"));
6427 }
6428 active_limits__ = Some(map_.next_value()?);
6429 }
6430 }
6431 }
6432 Ok(GetClusterLimitsResponse {
6433 active_limits: active_limits__.unwrap_or_default(),
6434 })
6435 }
6436 }
6437 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6438 }
6439}
6440impl serde::Serialize for GetClusterRecoveryStatusRequest {
6441 #[allow(deprecated)]
6442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6443 where
6444 S: serde::Serializer,
6445 {
6446 use serde::ser::SerializeStruct;
6447 let len = 0;
6448 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6449 struct_ser.end()
6450 }
6451}
6452impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6453 #[allow(deprecated)]
6454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6455 where
6456 D: serde::Deserializer<'de>,
6457 {
6458 const FIELDS: &[&str] = &[
6459 ];
6460
6461 #[allow(clippy::enum_variant_names)]
6462 enum GeneratedField {
6463 }
6464 impl<'de> serde::Deserialize<'de> for GeneratedField {
6465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6466 where
6467 D: serde::Deserializer<'de>,
6468 {
6469 struct GeneratedVisitor;
6470
6471 impl serde::de::Visitor<'_> for GeneratedVisitor {
6472 type Value = GeneratedField;
6473
6474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6475 write!(formatter, "expected one of: {:?}", &FIELDS)
6476 }
6477
6478 #[allow(unused_variables)]
6479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6480 where
6481 E: serde::de::Error,
6482 {
6483 Err(serde::de::Error::unknown_field(value, FIELDS))
6484 }
6485 }
6486 deserializer.deserialize_identifier(GeneratedVisitor)
6487 }
6488 }
6489 struct GeneratedVisitor;
6490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6491 type Value = GetClusterRecoveryStatusRequest;
6492
6493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6494 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6495 }
6496
6497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6498 where
6499 V: serde::de::MapAccess<'de>,
6500 {
6501 while map_.next_key::<GeneratedField>()?.is_some() {
6502 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6503 }
6504 Ok(GetClusterRecoveryStatusRequest {
6505 })
6506 }
6507 }
6508 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6509 }
6510}
6511impl serde::Serialize for GetClusterRecoveryStatusResponse {
6512 #[allow(deprecated)]
6513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6514 where
6515 S: serde::Serializer,
6516 {
6517 use serde::ser::SerializeStruct;
6518 let mut len = 0;
6519 if self.status != 0 {
6520 len += 1;
6521 }
6522 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6523 if self.status != 0 {
6524 let v = RecoveryStatus::try_from(self.status)
6525 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6526 struct_ser.serialize_field("status", &v)?;
6527 }
6528 struct_ser.end()
6529 }
6530}
6531impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6532 #[allow(deprecated)]
6533 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6534 where
6535 D: serde::Deserializer<'de>,
6536 {
6537 const FIELDS: &[&str] = &[
6538 "status",
6539 ];
6540
6541 #[allow(clippy::enum_variant_names)]
6542 enum GeneratedField {
6543 Status,
6544 }
6545 impl<'de> serde::Deserialize<'de> for GeneratedField {
6546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6547 where
6548 D: serde::Deserializer<'de>,
6549 {
6550 struct GeneratedVisitor;
6551
6552 impl serde::de::Visitor<'_> for GeneratedVisitor {
6553 type Value = GeneratedField;
6554
6555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6556 write!(formatter, "expected one of: {:?}", &FIELDS)
6557 }
6558
6559 #[allow(unused_variables)]
6560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6561 where
6562 E: serde::de::Error,
6563 {
6564 match value {
6565 "status" => Ok(GeneratedField::Status),
6566 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6567 }
6568 }
6569 }
6570 deserializer.deserialize_identifier(GeneratedVisitor)
6571 }
6572 }
6573 struct GeneratedVisitor;
6574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6575 type Value = GetClusterRecoveryStatusResponse;
6576
6577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6578 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6579 }
6580
6581 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6582 where
6583 V: serde::de::MapAccess<'de>,
6584 {
6585 let mut status__ = None;
6586 while let Some(k) = map_.next_key()? {
6587 match k {
6588 GeneratedField::Status => {
6589 if status__.is_some() {
6590 return Err(serde::de::Error::duplicate_field("status"));
6591 }
6592 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6593 }
6594 }
6595 }
6596 Ok(GetClusterRecoveryStatusResponse {
6597 status: status__.unwrap_or_default(),
6598 })
6599 }
6600 }
6601 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6602 }
6603}
6604impl serde::Serialize for GetFragmentByIdRequest {
6605 #[allow(deprecated)]
6606 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6607 where
6608 S: serde::Serializer,
6609 {
6610 use serde::ser::SerializeStruct;
6611 let mut len = 0;
6612 if self.fragment_id != 0 {
6613 len += 1;
6614 }
6615 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6616 if self.fragment_id != 0 {
6617 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6618 }
6619 struct_ser.end()
6620 }
6621}
6622impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6623 #[allow(deprecated)]
6624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6625 where
6626 D: serde::Deserializer<'de>,
6627 {
6628 const FIELDS: &[&str] = &[
6629 "fragment_id",
6630 "fragmentId",
6631 ];
6632
6633 #[allow(clippy::enum_variant_names)]
6634 enum GeneratedField {
6635 FragmentId,
6636 }
6637 impl<'de> serde::Deserialize<'de> for GeneratedField {
6638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6639 where
6640 D: serde::Deserializer<'de>,
6641 {
6642 struct GeneratedVisitor;
6643
6644 impl serde::de::Visitor<'_> for GeneratedVisitor {
6645 type Value = GeneratedField;
6646
6647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6648 write!(formatter, "expected one of: {:?}", &FIELDS)
6649 }
6650
6651 #[allow(unused_variables)]
6652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6653 where
6654 E: serde::de::Error,
6655 {
6656 match value {
6657 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6658 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6659 }
6660 }
6661 }
6662 deserializer.deserialize_identifier(GeneratedVisitor)
6663 }
6664 }
6665 struct GeneratedVisitor;
6666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6667 type Value = GetFragmentByIdRequest;
6668
6669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6670 formatter.write_str("struct meta.GetFragmentByIdRequest")
6671 }
6672
6673 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6674 where
6675 V: serde::de::MapAccess<'de>,
6676 {
6677 let mut fragment_id__ = None;
6678 while let Some(k) = map_.next_key()? {
6679 match k {
6680 GeneratedField::FragmentId => {
6681 if fragment_id__.is_some() {
6682 return Err(serde::de::Error::duplicate_field("fragmentId"));
6683 }
6684 fragment_id__ =
6685 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6686 ;
6687 }
6688 }
6689 }
6690 Ok(GetFragmentByIdRequest {
6691 fragment_id: fragment_id__.unwrap_or_default(),
6692 })
6693 }
6694 }
6695 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6696 }
6697}
6698impl serde::Serialize for GetFragmentByIdResponse {
6699 #[allow(deprecated)]
6700 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6701 where
6702 S: serde::Serializer,
6703 {
6704 use serde::ser::SerializeStruct;
6705 let mut len = 0;
6706 if self.distribution.is_some() {
6707 len += 1;
6708 }
6709 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6710 if let Some(v) = self.distribution.as_ref() {
6711 struct_ser.serialize_field("distribution", v)?;
6712 }
6713 struct_ser.end()
6714 }
6715}
6716impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6717 #[allow(deprecated)]
6718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6719 where
6720 D: serde::Deserializer<'de>,
6721 {
6722 const FIELDS: &[&str] = &[
6723 "distribution",
6724 ];
6725
6726 #[allow(clippy::enum_variant_names)]
6727 enum GeneratedField {
6728 Distribution,
6729 }
6730 impl<'de> serde::Deserialize<'de> for GeneratedField {
6731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6732 where
6733 D: serde::Deserializer<'de>,
6734 {
6735 struct GeneratedVisitor;
6736
6737 impl serde::de::Visitor<'_> for GeneratedVisitor {
6738 type Value = GeneratedField;
6739
6740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6741 write!(formatter, "expected one of: {:?}", &FIELDS)
6742 }
6743
6744 #[allow(unused_variables)]
6745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6746 where
6747 E: serde::de::Error,
6748 {
6749 match value {
6750 "distribution" => Ok(GeneratedField::Distribution),
6751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6752 }
6753 }
6754 }
6755 deserializer.deserialize_identifier(GeneratedVisitor)
6756 }
6757 }
6758 struct GeneratedVisitor;
6759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6760 type Value = GetFragmentByIdResponse;
6761
6762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6763 formatter.write_str("struct meta.GetFragmentByIdResponse")
6764 }
6765
6766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6767 where
6768 V: serde::de::MapAccess<'de>,
6769 {
6770 let mut distribution__ = None;
6771 while let Some(k) = map_.next_key()? {
6772 match k {
6773 GeneratedField::Distribution => {
6774 if distribution__.is_some() {
6775 return Err(serde::de::Error::duplicate_field("distribution"));
6776 }
6777 distribution__ = map_.next_value()?;
6778 }
6779 }
6780 }
6781 Ok(GetFragmentByIdResponse {
6782 distribution: distribution__,
6783 })
6784 }
6785 }
6786 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6787 }
6788}
6789impl serde::Serialize for GetFragmentVnodesRequest {
6790 #[allow(deprecated)]
6791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6792 where
6793 S: serde::Serializer,
6794 {
6795 use serde::ser::SerializeStruct;
6796 let mut len = 0;
6797 if self.fragment_id != 0 {
6798 len += 1;
6799 }
6800 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
6801 if self.fragment_id != 0 {
6802 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6803 }
6804 struct_ser.end()
6805 }
6806}
6807impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
6808 #[allow(deprecated)]
6809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6810 where
6811 D: serde::Deserializer<'de>,
6812 {
6813 const FIELDS: &[&str] = &[
6814 "fragment_id",
6815 "fragmentId",
6816 ];
6817
6818 #[allow(clippy::enum_variant_names)]
6819 enum GeneratedField {
6820 FragmentId,
6821 }
6822 impl<'de> serde::Deserialize<'de> for GeneratedField {
6823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6824 where
6825 D: serde::Deserializer<'de>,
6826 {
6827 struct GeneratedVisitor;
6828
6829 impl serde::de::Visitor<'_> for GeneratedVisitor {
6830 type Value = GeneratedField;
6831
6832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6833 write!(formatter, "expected one of: {:?}", &FIELDS)
6834 }
6835
6836 #[allow(unused_variables)]
6837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6838 where
6839 E: serde::de::Error,
6840 {
6841 match value {
6842 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6844 }
6845 }
6846 }
6847 deserializer.deserialize_identifier(GeneratedVisitor)
6848 }
6849 }
6850 struct GeneratedVisitor;
6851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6852 type Value = GetFragmentVnodesRequest;
6853
6854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6855 formatter.write_str("struct meta.GetFragmentVnodesRequest")
6856 }
6857
6858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
6859 where
6860 V: serde::de::MapAccess<'de>,
6861 {
6862 let mut fragment_id__ = None;
6863 while let Some(k) = map_.next_key()? {
6864 match k {
6865 GeneratedField::FragmentId => {
6866 if fragment_id__.is_some() {
6867 return Err(serde::de::Error::duplicate_field("fragmentId"));
6868 }
6869 fragment_id__ =
6870 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6871 ;
6872 }
6873 }
6874 }
6875 Ok(GetFragmentVnodesRequest {
6876 fragment_id: fragment_id__.unwrap_or_default(),
6877 })
6878 }
6879 }
6880 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
6881 }
6882}
6883impl serde::Serialize for GetFragmentVnodesResponse {
6884 #[allow(deprecated)]
6885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6886 where
6887 S: serde::Serializer,
6888 {
6889 use serde::ser::SerializeStruct;
6890 let mut len = 0;
6891 if !self.actor_vnodes.is_empty() {
6892 len += 1;
6893 }
6894 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
6895 if !self.actor_vnodes.is_empty() {
6896 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
6897 }
6898 struct_ser.end()
6899 }
6900}
6901impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
6902 #[allow(deprecated)]
6903 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6904 where
6905 D: serde::Deserializer<'de>,
6906 {
6907 const FIELDS: &[&str] = &[
6908 "actor_vnodes",
6909 "actorVnodes",
6910 ];
6911
6912 #[allow(clippy::enum_variant_names)]
6913 enum GeneratedField {
6914 ActorVnodes,
6915 }
6916 impl<'de> serde::Deserialize<'de> for GeneratedField {
6917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6918 where
6919 D: serde::Deserializer<'de>,
6920 {
6921 struct GeneratedVisitor;
6922
6923 impl serde::de::Visitor<'_> for GeneratedVisitor {
6924 type Value = GeneratedField;
6925
6926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6927 write!(formatter, "expected one of: {:?}", &FIELDS)
6928 }
6929
6930 #[allow(unused_variables)]
6931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6932 where
6933 E: serde::de::Error,
6934 {
6935 match value {
6936 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
6937 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6938 }
6939 }
6940 }
6941 deserializer.deserialize_identifier(GeneratedVisitor)
6942 }
6943 }
6944 struct GeneratedVisitor;
6945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6946 type Value = GetFragmentVnodesResponse;
6947
6948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6949 formatter.write_str("struct meta.GetFragmentVnodesResponse")
6950 }
6951
6952 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
6953 where
6954 V: serde::de::MapAccess<'de>,
6955 {
6956 let mut actor_vnodes__ = None;
6957 while let Some(k) = map_.next_key()? {
6958 match k {
6959 GeneratedField::ActorVnodes => {
6960 if actor_vnodes__.is_some() {
6961 return Err(serde::de::Error::duplicate_field("actorVnodes"));
6962 }
6963 actor_vnodes__ = Some(map_.next_value()?);
6964 }
6965 }
6966 }
6967 Ok(GetFragmentVnodesResponse {
6968 actor_vnodes: actor_vnodes__.unwrap_or_default(),
6969 })
6970 }
6971 }
6972 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
6973 }
6974}
6975impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
6976 #[allow(deprecated)]
6977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6978 where
6979 S: serde::Serializer,
6980 {
6981 use serde::ser::SerializeStruct;
6982 let mut len = 0;
6983 if self.actor_id != 0 {
6984 len += 1;
6985 }
6986 if !self.vnode_indices.is_empty() {
6987 len += 1;
6988 }
6989 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
6990 if self.actor_id != 0 {
6991 struct_ser.serialize_field("actorId", &self.actor_id)?;
6992 }
6993 if !self.vnode_indices.is_empty() {
6994 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6995 }
6996 struct_ser.end()
6997 }
6998}
6999impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
7000 #[allow(deprecated)]
7001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7002 where
7003 D: serde::Deserializer<'de>,
7004 {
7005 const FIELDS: &[&str] = &[
7006 "actor_id",
7007 "actorId",
7008 "vnode_indices",
7009 "vnodeIndices",
7010 ];
7011
7012 #[allow(clippy::enum_variant_names)]
7013 enum GeneratedField {
7014 ActorId,
7015 VnodeIndices,
7016 }
7017 impl<'de> serde::Deserialize<'de> for GeneratedField {
7018 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7019 where
7020 D: serde::Deserializer<'de>,
7021 {
7022 struct GeneratedVisitor;
7023
7024 impl serde::de::Visitor<'_> for GeneratedVisitor {
7025 type Value = GeneratedField;
7026
7027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7028 write!(formatter, "expected one of: {:?}", &FIELDS)
7029 }
7030
7031 #[allow(unused_variables)]
7032 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7033 where
7034 E: serde::de::Error,
7035 {
7036 match value {
7037 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7038 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7040 }
7041 }
7042 }
7043 deserializer.deserialize_identifier(GeneratedVisitor)
7044 }
7045 }
7046 struct GeneratedVisitor;
7047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7048 type Value = get_fragment_vnodes_response::ActorVnodes;
7049
7050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7051 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7052 }
7053
7054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7055 where
7056 V: serde::de::MapAccess<'de>,
7057 {
7058 let mut actor_id__ = None;
7059 let mut vnode_indices__ = None;
7060 while let Some(k) = map_.next_key()? {
7061 match k {
7062 GeneratedField::ActorId => {
7063 if actor_id__.is_some() {
7064 return Err(serde::de::Error::duplicate_field("actorId"));
7065 }
7066 actor_id__ =
7067 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7068 ;
7069 }
7070 GeneratedField::VnodeIndices => {
7071 if vnode_indices__.is_some() {
7072 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7073 }
7074 vnode_indices__ =
7075 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7076 .into_iter().map(|x| x.0).collect())
7077 ;
7078 }
7079 }
7080 }
7081 Ok(get_fragment_vnodes_response::ActorVnodes {
7082 actor_id: actor_id__.unwrap_or_default(),
7083 vnode_indices: vnode_indices__.unwrap_or_default(),
7084 })
7085 }
7086 }
7087 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7088 }
7089}
7090impl serde::Serialize for GetMetaStoreInfoRequest {
7091 #[allow(deprecated)]
7092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7093 where
7094 S: serde::Serializer,
7095 {
7096 use serde::ser::SerializeStruct;
7097 let len = 0;
7098 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7099 struct_ser.end()
7100 }
7101}
7102impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7103 #[allow(deprecated)]
7104 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7105 where
7106 D: serde::Deserializer<'de>,
7107 {
7108 const FIELDS: &[&str] = &[
7109 ];
7110
7111 #[allow(clippy::enum_variant_names)]
7112 enum GeneratedField {
7113 }
7114 impl<'de> serde::Deserialize<'de> for GeneratedField {
7115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7116 where
7117 D: serde::Deserializer<'de>,
7118 {
7119 struct GeneratedVisitor;
7120
7121 impl serde::de::Visitor<'_> for GeneratedVisitor {
7122 type Value = GeneratedField;
7123
7124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7125 write!(formatter, "expected one of: {:?}", &FIELDS)
7126 }
7127
7128 #[allow(unused_variables)]
7129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7130 where
7131 E: serde::de::Error,
7132 {
7133 Err(serde::de::Error::unknown_field(value, FIELDS))
7134 }
7135 }
7136 deserializer.deserialize_identifier(GeneratedVisitor)
7137 }
7138 }
7139 struct GeneratedVisitor;
7140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7141 type Value = GetMetaStoreInfoRequest;
7142
7143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7144 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7145 }
7146
7147 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7148 where
7149 V: serde::de::MapAccess<'de>,
7150 {
7151 while map_.next_key::<GeneratedField>()?.is_some() {
7152 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7153 }
7154 Ok(GetMetaStoreInfoRequest {
7155 })
7156 }
7157 }
7158 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7159 }
7160}
7161impl serde::Serialize for GetMetaStoreInfoResponse {
7162 #[allow(deprecated)]
7163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7164 where
7165 S: serde::Serializer,
7166 {
7167 use serde::ser::SerializeStruct;
7168 let mut len = 0;
7169 if !self.meta_store_endpoint.is_empty() {
7170 len += 1;
7171 }
7172 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7173 if !self.meta_store_endpoint.is_empty() {
7174 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7175 }
7176 struct_ser.end()
7177 }
7178}
7179impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7180 #[allow(deprecated)]
7181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7182 where
7183 D: serde::Deserializer<'de>,
7184 {
7185 const FIELDS: &[&str] = &[
7186 "meta_store_endpoint",
7187 "metaStoreEndpoint",
7188 ];
7189
7190 #[allow(clippy::enum_variant_names)]
7191 enum GeneratedField {
7192 MetaStoreEndpoint,
7193 }
7194 impl<'de> serde::Deserialize<'de> for GeneratedField {
7195 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7196 where
7197 D: serde::Deserializer<'de>,
7198 {
7199 struct GeneratedVisitor;
7200
7201 impl serde::de::Visitor<'_> for GeneratedVisitor {
7202 type Value = GeneratedField;
7203
7204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7205 write!(formatter, "expected one of: {:?}", &FIELDS)
7206 }
7207
7208 #[allow(unused_variables)]
7209 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7210 where
7211 E: serde::de::Error,
7212 {
7213 match value {
7214 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7216 }
7217 }
7218 }
7219 deserializer.deserialize_identifier(GeneratedVisitor)
7220 }
7221 }
7222 struct GeneratedVisitor;
7223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7224 type Value = GetMetaStoreInfoResponse;
7225
7226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7227 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7228 }
7229
7230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7231 where
7232 V: serde::de::MapAccess<'de>,
7233 {
7234 let mut meta_store_endpoint__ = None;
7235 while let Some(k) = map_.next_key()? {
7236 match k {
7237 GeneratedField::MetaStoreEndpoint => {
7238 if meta_store_endpoint__.is_some() {
7239 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7240 }
7241 meta_store_endpoint__ = Some(map_.next_value()?);
7242 }
7243 }
7244 }
7245 Ok(GetMetaStoreInfoResponse {
7246 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7247 })
7248 }
7249 }
7250 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7251 }
7252}
7253impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7254 #[allow(deprecated)]
7255 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7256 where
7257 S: serde::Serializer,
7258 {
7259 use serde::ser::SerializeStruct;
7260 let len = 0;
7261 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7262 struct_ser.end()
7263 }
7264}
7265impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
7266 #[allow(deprecated)]
7267 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7268 where
7269 D: serde::Deserializer<'de>,
7270 {
7271 const FIELDS: &[&str] = &[
7272 ];
7273
7274 #[allow(clippy::enum_variant_names)]
7275 enum GeneratedField {
7276 }
7277 impl<'de> serde::Deserialize<'de> for GeneratedField {
7278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7279 where
7280 D: serde::Deserializer<'de>,
7281 {
7282 struct GeneratedVisitor;
7283
7284 impl serde::de::Visitor<'_> for GeneratedVisitor {
7285 type Value = GeneratedField;
7286
7287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7288 write!(formatter, "expected one of: {:?}", &FIELDS)
7289 }
7290
7291 #[allow(unused_variables)]
7292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7293 where
7294 E: serde::de::Error,
7295 {
7296 Err(serde::de::Error::unknown_field(value, FIELDS))
7297 }
7298 }
7299 deserializer.deserialize_identifier(GeneratedVisitor)
7300 }
7301 }
7302 struct GeneratedVisitor;
7303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7304 type Value = GetServerlessStreamingJobsStatusRequest;
7305
7306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7307 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7308 }
7309
7310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7311 where
7312 V: serde::de::MapAccess<'de>,
7313 {
7314 while map_.next_key::<GeneratedField>()?.is_some() {
7315 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7316 }
7317 Ok(GetServerlessStreamingJobsStatusRequest {
7318 })
7319 }
7320 }
7321 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7322 }
7323}
7324impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
7325 #[allow(deprecated)]
7326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7327 where
7328 S: serde::Serializer,
7329 {
7330 use serde::ser::SerializeStruct;
7331 let mut len = 0;
7332 if !self.streaming_job_statuses.is_empty() {
7333 len += 1;
7334 }
7335 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7336 if !self.streaming_job_statuses.is_empty() {
7337 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7338 }
7339 struct_ser.end()
7340 }
7341}
7342impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7343 #[allow(deprecated)]
7344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7345 where
7346 D: serde::Deserializer<'de>,
7347 {
7348 const FIELDS: &[&str] = &[
7349 "streaming_job_statuses",
7350 "streamingJobStatuses",
7351 ];
7352
7353 #[allow(clippy::enum_variant_names)]
7354 enum GeneratedField {
7355 StreamingJobStatuses,
7356 }
7357 impl<'de> serde::Deserialize<'de> for GeneratedField {
7358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7359 where
7360 D: serde::Deserializer<'de>,
7361 {
7362 struct GeneratedVisitor;
7363
7364 impl serde::de::Visitor<'_> for GeneratedVisitor {
7365 type Value = GeneratedField;
7366
7367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7368 write!(formatter, "expected one of: {:?}", &FIELDS)
7369 }
7370
7371 #[allow(unused_variables)]
7372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7373 where
7374 E: serde::de::Error,
7375 {
7376 match value {
7377 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7379 }
7380 }
7381 }
7382 deserializer.deserialize_identifier(GeneratedVisitor)
7383 }
7384 }
7385 struct GeneratedVisitor;
7386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7387 type Value = GetServerlessStreamingJobsStatusResponse;
7388
7389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7390 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7391 }
7392
7393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7394 where
7395 V: serde::de::MapAccess<'de>,
7396 {
7397 let mut streaming_job_statuses__ = None;
7398 while let Some(k) = map_.next_key()? {
7399 match k {
7400 GeneratedField::StreamingJobStatuses => {
7401 if streaming_job_statuses__.is_some() {
7402 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7403 }
7404 streaming_job_statuses__ = Some(map_.next_value()?);
7405 }
7406 }
7407 }
7408 Ok(GetServerlessStreamingJobsStatusResponse {
7409 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7410 })
7411 }
7412 }
7413 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7414 }
7415}
7416impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7417 #[allow(deprecated)]
7418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7419 where
7420 S: serde::Serializer,
7421 {
7422 use serde::ser::SerializeStruct;
7423 let mut len = 0;
7424 if self.table_id != 0 {
7425 len += 1;
7426 }
7427 if !self.node_label.is_empty() {
7428 len += 1;
7429 }
7430 if self.backfill_done {
7431 len += 1;
7432 }
7433 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7434 if self.table_id != 0 {
7435 struct_ser.serialize_field("tableId", &self.table_id)?;
7436 }
7437 if !self.node_label.is_empty() {
7438 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7439 }
7440 if self.backfill_done {
7441 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7442 }
7443 struct_ser.end()
7444 }
7445}
7446impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7447 #[allow(deprecated)]
7448 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7449 where
7450 D: serde::Deserializer<'de>,
7451 {
7452 const FIELDS: &[&str] = &[
7453 "table_id",
7454 "tableId",
7455 "node_label",
7456 "nodeLabel",
7457 "backfill_done",
7458 "backfillDone",
7459 ];
7460
7461 #[allow(clippy::enum_variant_names)]
7462 enum GeneratedField {
7463 TableId,
7464 NodeLabel,
7465 BackfillDone,
7466 }
7467 impl<'de> serde::Deserialize<'de> for GeneratedField {
7468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7469 where
7470 D: serde::Deserializer<'de>,
7471 {
7472 struct GeneratedVisitor;
7473
7474 impl serde::de::Visitor<'_> for GeneratedVisitor {
7475 type Value = GeneratedField;
7476
7477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7478 write!(formatter, "expected one of: {:?}", &FIELDS)
7479 }
7480
7481 #[allow(unused_variables)]
7482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7483 where
7484 E: serde::de::Error,
7485 {
7486 match value {
7487 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7488 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7489 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7491 }
7492 }
7493 }
7494 deserializer.deserialize_identifier(GeneratedVisitor)
7495 }
7496 }
7497 struct GeneratedVisitor;
7498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7499 type Value = get_serverless_streaming_jobs_status_response::Status;
7500
7501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7502 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7503 }
7504
7505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7506 where
7507 V: serde::de::MapAccess<'de>,
7508 {
7509 let mut table_id__ = None;
7510 let mut node_label__ = None;
7511 let mut backfill_done__ = None;
7512 while let Some(k) = map_.next_key()? {
7513 match k {
7514 GeneratedField::TableId => {
7515 if table_id__.is_some() {
7516 return Err(serde::de::Error::duplicate_field("tableId"));
7517 }
7518 table_id__ =
7519 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7520 ;
7521 }
7522 GeneratedField::NodeLabel => {
7523 if node_label__.is_some() {
7524 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7525 }
7526 node_label__ = Some(map_.next_value()?);
7527 }
7528 GeneratedField::BackfillDone => {
7529 if backfill_done__.is_some() {
7530 return Err(serde::de::Error::duplicate_field("backfillDone"));
7531 }
7532 backfill_done__ = Some(map_.next_value()?);
7533 }
7534 }
7535 }
7536 Ok(get_serverless_streaming_jobs_status_response::Status {
7537 table_id: table_id__.unwrap_or_default(),
7538 node_label: node_label__.unwrap_or_default(),
7539 backfill_done: backfill_done__.unwrap_or_default(),
7540 })
7541 }
7542 }
7543 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7544 }
7545}
7546impl serde::Serialize for GetServingVnodeMappingsRequest {
7547 #[allow(deprecated)]
7548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7549 where
7550 S: serde::Serializer,
7551 {
7552 use serde::ser::SerializeStruct;
7553 let len = 0;
7554 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7555 struct_ser.end()
7556 }
7557}
7558impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7559 #[allow(deprecated)]
7560 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7561 where
7562 D: serde::Deserializer<'de>,
7563 {
7564 const FIELDS: &[&str] = &[
7565 ];
7566
7567 #[allow(clippy::enum_variant_names)]
7568 enum GeneratedField {
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 serde::de::Visitor<'_> 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 Err(serde::de::Error::unknown_field(value, FIELDS))
7590 }
7591 }
7592 deserializer.deserialize_identifier(GeneratedVisitor)
7593 }
7594 }
7595 struct GeneratedVisitor;
7596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7597 type Value = GetServingVnodeMappingsRequest;
7598
7599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7600 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7601 }
7602
7603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7604 where
7605 V: serde::de::MapAccess<'de>,
7606 {
7607 while map_.next_key::<GeneratedField>()?.is_some() {
7608 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7609 }
7610 Ok(GetServingVnodeMappingsRequest {
7611 })
7612 }
7613 }
7614 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7615 }
7616}
7617impl serde::Serialize for GetServingVnodeMappingsResponse {
7618 #[allow(deprecated)]
7619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7620 where
7621 S: serde::Serializer,
7622 {
7623 use serde::ser::SerializeStruct;
7624 let mut len = 0;
7625 if !self.fragment_to_table.is_empty() {
7626 len += 1;
7627 }
7628 if !self.worker_slot_mappings.is_empty() {
7629 len += 1;
7630 }
7631 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7632 if !self.fragment_to_table.is_empty() {
7633 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7634 }
7635 if !self.worker_slot_mappings.is_empty() {
7636 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7637 }
7638 struct_ser.end()
7639 }
7640}
7641impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
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 "fragment_to_table",
7649 "fragmentToTable",
7650 "worker_slot_mappings",
7651 "workerSlotMappings",
7652 ];
7653
7654 #[allow(clippy::enum_variant_names)]
7655 enum GeneratedField {
7656 FragmentToTable,
7657 WorkerSlotMappings,
7658 }
7659 impl<'de> serde::Deserialize<'de> for GeneratedField {
7660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7661 where
7662 D: serde::Deserializer<'de>,
7663 {
7664 struct GeneratedVisitor;
7665
7666 impl serde::de::Visitor<'_> for GeneratedVisitor {
7667 type Value = GeneratedField;
7668
7669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7670 write!(formatter, "expected one of: {:?}", &FIELDS)
7671 }
7672
7673 #[allow(unused_variables)]
7674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7675 where
7676 E: serde::de::Error,
7677 {
7678 match value {
7679 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7680 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7682 }
7683 }
7684 }
7685 deserializer.deserialize_identifier(GeneratedVisitor)
7686 }
7687 }
7688 struct GeneratedVisitor;
7689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7690 type Value = GetServingVnodeMappingsResponse;
7691
7692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7693 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7694 }
7695
7696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7697 where
7698 V: serde::de::MapAccess<'de>,
7699 {
7700 let mut fragment_to_table__ = None;
7701 let mut worker_slot_mappings__ = None;
7702 while let Some(k) = map_.next_key()? {
7703 match k {
7704 GeneratedField::FragmentToTable => {
7705 if fragment_to_table__.is_some() {
7706 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7707 }
7708 fragment_to_table__ = Some(
7709 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7710 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
7711 );
7712 }
7713 GeneratedField::WorkerSlotMappings => {
7714 if worker_slot_mappings__.is_some() {
7715 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7716 }
7717 worker_slot_mappings__ = Some(map_.next_value()?);
7718 }
7719 }
7720 }
7721 Ok(GetServingVnodeMappingsResponse {
7722 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7723 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7724 })
7725 }
7726 }
7727 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7728 }
7729}
7730impl serde::Serialize for GetSessionParamsRequest {
7731 #[allow(deprecated)]
7732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7733 where
7734 S: serde::Serializer,
7735 {
7736 use serde::ser::SerializeStruct;
7737 let len = 0;
7738 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7739 struct_ser.end()
7740 }
7741}
7742impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7743 #[allow(deprecated)]
7744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7745 where
7746 D: serde::Deserializer<'de>,
7747 {
7748 const FIELDS: &[&str] = &[
7749 ];
7750
7751 #[allow(clippy::enum_variant_names)]
7752 enum GeneratedField {
7753 }
7754 impl<'de> serde::Deserialize<'de> for GeneratedField {
7755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7756 where
7757 D: serde::Deserializer<'de>,
7758 {
7759 struct GeneratedVisitor;
7760
7761 impl serde::de::Visitor<'_> for GeneratedVisitor {
7762 type Value = GeneratedField;
7763
7764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7765 write!(formatter, "expected one of: {:?}", &FIELDS)
7766 }
7767
7768 #[allow(unused_variables)]
7769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7770 where
7771 E: serde::de::Error,
7772 {
7773 Err(serde::de::Error::unknown_field(value, FIELDS))
7774 }
7775 }
7776 deserializer.deserialize_identifier(GeneratedVisitor)
7777 }
7778 }
7779 struct GeneratedVisitor;
7780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7781 type Value = GetSessionParamsRequest;
7782
7783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7784 formatter.write_str("struct meta.GetSessionParamsRequest")
7785 }
7786
7787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7788 where
7789 V: serde::de::MapAccess<'de>,
7790 {
7791 while map_.next_key::<GeneratedField>()?.is_some() {
7792 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7793 }
7794 Ok(GetSessionParamsRequest {
7795 })
7796 }
7797 }
7798 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7799 }
7800}
7801impl serde::Serialize for GetSessionParamsResponse {
7802 #[allow(deprecated)]
7803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7804 where
7805 S: serde::Serializer,
7806 {
7807 use serde::ser::SerializeStruct;
7808 let mut len = 0;
7809 if !self.params.is_empty() {
7810 len += 1;
7811 }
7812 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7813 if !self.params.is_empty() {
7814 struct_ser.serialize_field("params", &self.params)?;
7815 }
7816 struct_ser.end()
7817 }
7818}
7819impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7820 #[allow(deprecated)]
7821 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7822 where
7823 D: serde::Deserializer<'de>,
7824 {
7825 const FIELDS: &[&str] = &[
7826 "params",
7827 ];
7828
7829 #[allow(clippy::enum_variant_names)]
7830 enum GeneratedField {
7831 Params,
7832 }
7833 impl<'de> serde::Deserialize<'de> for GeneratedField {
7834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7835 where
7836 D: serde::Deserializer<'de>,
7837 {
7838 struct GeneratedVisitor;
7839
7840 impl serde::de::Visitor<'_> for GeneratedVisitor {
7841 type Value = GeneratedField;
7842
7843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7844 write!(formatter, "expected one of: {:?}", &FIELDS)
7845 }
7846
7847 #[allow(unused_variables)]
7848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7849 where
7850 E: serde::de::Error,
7851 {
7852 match value {
7853 "params" => Ok(GeneratedField::Params),
7854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7855 }
7856 }
7857 }
7858 deserializer.deserialize_identifier(GeneratedVisitor)
7859 }
7860 }
7861 struct GeneratedVisitor;
7862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7863 type Value = GetSessionParamsResponse;
7864
7865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7866 formatter.write_str("struct meta.GetSessionParamsResponse")
7867 }
7868
7869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7870 where
7871 V: serde::de::MapAccess<'de>,
7872 {
7873 let mut params__ = None;
7874 while let Some(k) = map_.next_key()? {
7875 match k {
7876 GeneratedField::Params => {
7877 if params__.is_some() {
7878 return Err(serde::de::Error::duplicate_field("params"));
7879 }
7880 params__ = Some(map_.next_value()?);
7881 }
7882 }
7883 }
7884 Ok(GetSessionParamsResponse {
7885 params: params__.unwrap_or_default(),
7886 })
7887 }
7888 }
7889 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7890 }
7891}
7892impl serde::Serialize for GetSystemParamsRequest {
7893 #[allow(deprecated)]
7894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7895 where
7896 S: serde::Serializer,
7897 {
7898 use serde::ser::SerializeStruct;
7899 let len = 0;
7900 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7901 struct_ser.end()
7902 }
7903}
7904impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7905 #[allow(deprecated)]
7906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7907 where
7908 D: serde::Deserializer<'de>,
7909 {
7910 const FIELDS: &[&str] = &[
7911 ];
7912
7913 #[allow(clippy::enum_variant_names)]
7914 enum GeneratedField {
7915 }
7916 impl<'de> serde::Deserialize<'de> for GeneratedField {
7917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7918 where
7919 D: serde::Deserializer<'de>,
7920 {
7921 struct GeneratedVisitor;
7922
7923 impl serde::de::Visitor<'_> for GeneratedVisitor {
7924 type Value = GeneratedField;
7925
7926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7927 write!(formatter, "expected one of: {:?}", &FIELDS)
7928 }
7929
7930 #[allow(unused_variables)]
7931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7932 where
7933 E: serde::de::Error,
7934 {
7935 Err(serde::de::Error::unknown_field(value, FIELDS))
7936 }
7937 }
7938 deserializer.deserialize_identifier(GeneratedVisitor)
7939 }
7940 }
7941 struct GeneratedVisitor;
7942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7943 type Value = GetSystemParamsRequest;
7944
7945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7946 formatter.write_str("struct meta.GetSystemParamsRequest")
7947 }
7948
7949 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7950 where
7951 V: serde::de::MapAccess<'de>,
7952 {
7953 while map_.next_key::<GeneratedField>()?.is_some() {
7954 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7955 }
7956 Ok(GetSystemParamsRequest {
7957 })
7958 }
7959 }
7960 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7961 }
7962}
7963impl serde::Serialize for GetSystemParamsResponse {
7964 #[allow(deprecated)]
7965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7966 where
7967 S: serde::Serializer,
7968 {
7969 use serde::ser::SerializeStruct;
7970 let mut len = 0;
7971 if self.params.is_some() {
7972 len += 1;
7973 }
7974 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7975 if let Some(v) = self.params.as_ref() {
7976 struct_ser.serialize_field("params", v)?;
7977 }
7978 struct_ser.end()
7979 }
7980}
7981impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7982 #[allow(deprecated)]
7983 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7984 where
7985 D: serde::Deserializer<'de>,
7986 {
7987 const FIELDS: &[&str] = &[
7988 "params",
7989 ];
7990
7991 #[allow(clippy::enum_variant_names)]
7992 enum GeneratedField {
7993 Params,
7994 }
7995 impl<'de> serde::Deserialize<'de> for GeneratedField {
7996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7997 where
7998 D: serde::Deserializer<'de>,
7999 {
8000 struct GeneratedVisitor;
8001
8002 impl serde::de::Visitor<'_> for GeneratedVisitor {
8003 type Value = GeneratedField;
8004
8005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8006 write!(formatter, "expected one of: {:?}", &FIELDS)
8007 }
8008
8009 #[allow(unused_variables)]
8010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8011 where
8012 E: serde::de::Error,
8013 {
8014 match value {
8015 "params" => Ok(GeneratedField::Params),
8016 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8017 }
8018 }
8019 }
8020 deserializer.deserialize_identifier(GeneratedVisitor)
8021 }
8022 }
8023 struct GeneratedVisitor;
8024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8025 type Value = GetSystemParamsResponse;
8026
8027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8028 formatter.write_str("struct meta.GetSystemParamsResponse")
8029 }
8030
8031 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8032 where
8033 V: serde::de::MapAccess<'de>,
8034 {
8035 let mut params__ = None;
8036 while let Some(k) = map_.next_key()? {
8037 match k {
8038 GeneratedField::Params => {
8039 if params__.is_some() {
8040 return Err(serde::de::Error::duplicate_field("params"));
8041 }
8042 params__ = map_.next_value()?;
8043 }
8044 }
8045 }
8046 Ok(GetSystemParamsResponse {
8047 params: params__,
8048 })
8049 }
8050 }
8051 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8052 }
8053}
8054impl serde::Serialize for GetTelemetryInfoRequest {
8055 #[allow(deprecated)]
8056 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8057 where
8058 S: serde::Serializer,
8059 {
8060 use serde::ser::SerializeStruct;
8061 let len = 0;
8062 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8063 struct_ser.end()
8064 }
8065}
8066impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8067 #[allow(deprecated)]
8068 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8069 where
8070 D: serde::Deserializer<'de>,
8071 {
8072 const FIELDS: &[&str] = &[
8073 ];
8074
8075 #[allow(clippy::enum_variant_names)]
8076 enum GeneratedField {
8077 }
8078 impl<'de> serde::Deserialize<'de> for GeneratedField {
8079 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8080 where
8081 D: serde::Deserializer<'de>,
8082 {
8083 struct GeneratedVisitor;
8084
8085 impl serde::de::Visitor<'_> for GeneratedVisitor {
8086 type Value = GeneratedField;
8087
8088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8089 write!(formatter, "expected one of: {:?}", &FIELDS)
8090 }
8091
8092 #[allow(unused_variables)]
8093 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8094 where
8095 E: serde::de::Error,
8096 {
8097 Err(serde::de::Error::unknown_field(value, FIELDS))
8098 }
8099 }
8100 deserializer.deserialize_identifier(GeneratedVisitor)
8101 }
8102 }
8103 struct GeneratedVisitor;
8104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8105 type Value = GetTelemetryInfoRequest;
8106
8107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8108 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8109 }
8110
8111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8112 where
8113 V: serde::de::MapAccess<'de>,
8114 {
8115 while map_.next_key::<GeneratedField>()?.is_some() {
8116 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8117 }
8118 Ok(GetTelemetryInfoRequest {
8119 })
8120 }
8121 }
8122 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8123 }
8124}
8125impl serde::Serialize for HeartbeatRequest {
8126 #[allow(deprecated)]
8127 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8128 where
8129 S: serde::Serializer,
8130 {
8131 use serde::ser::SerializeStruct;
8132 let mut len = 0;
8133 if self.node_id != 0 {
8134 len += 1;
8135 }
8136 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8137 if self.node_id != 0 {
8138 struct_ser.serialize_field("nodeId", &self.node_id)?;
8139 }
8140 struct_ser.end()
8141 }
8142}
8143impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8144 #[allow(deprecated)]
8145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8146 where
8147 D: serde::Deserializer<'de>,
8148 {
8149 const FIELDS: &[&str] = &[
8150 "node_id",
8151 "nodeId",
8152 ];
8153
8154 #[allow(clippy::enum_variant_names)]
8155 enum GeneratedField {
8156 NodeId,
8157 }
8158 impl<'de> serde::Deserialize<'de> for GeneratedField {
8159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8160 where
8161 D: serde::Deserializer<'de>,
8162 {
8163 struct GeneratedVisitor;
8164
8165 impl serde::de::Visitor<'_> for GeneratedVisitor {
8166 type Value = GeneratedField;
8167
8168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8169 write!(formatter, "expected one of: {:?}", &FIELDS)
8170 }
8171
8172 #[allow(unused_variables)]
8173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8174 where
8175 E: serde::de::Error,
8176 {
8177 match value {
8178 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8179 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8180 }
8181 }
8182 }
8183 deserializer.deserialize_identifier(GeneratedVisitor)
8184 }
8185 }
8186 struct GeneratedVisitor;
8187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8188 type Value = HeartbeatRequest;
8189
8190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8191 formatter.write_str("struct meta.HeartbeatRequest")
8192 }
8193
8194 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8195 where
8196 V: serde::de::MapAccess<'de>,
8197 {
8198 let mut node_id__ = None;
8199 while let Some(k) = map_.next_key()? {
8200 match k {
8201 GeneratedField::NodeId => {
8202 if node_id__.is_some() {
8203 return Err(serde::de::Error::duplicate_field("nodeId"));
8204 }
8205 node_id__ =
8206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8207 ;
8208 }
8209 }
8210 }
8211 Ok(HeartbeatRequest {
8212 node_id: node_id__.unwrap_or_default(),
8213 })
8214 }
8215 }
8216 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8217 }
8218}
8219impl serde::Serialize for HeartbeatResponse {
8220 #[allow(deprecated)]
8221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8222 where
8223 S: serde::Serializer,
8224 {
8225 use serde::ser::SerializeStruct;
8226 let mut len = 0;
8227 if self.status.is_some() {
8228 len += 1;
8229 }
8230 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8231 if let Some(v) = self.status.as_ref() {
8232 struct_ser.serialize_field("status", v)?;
8233 }
8234 struct_ser.end()
8235 }
8236}
8237impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8238 #[allow(deprecated)]
8239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8240 where
8241 D: serde::Deserializer<'de>,
8242 {
8243 const FIELDS: &[&str] = &[
8244 "status",
8245 ];
8246
8247 #[allow(clippy::enum_variant_names)]
8248 enum GeneratedField {
8249 Status,
8250 }
8251 impl<'de> serde::Deserialize<'de> for GeneratedField {
8252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8253 where
8254 D: serde::Deserializer<'de>,
8255 {
8256 struct GeneratedVisitor;
8257
8258 impl serde::de::Visitor<'_> for GeneratedVisitor {
8259 type Value = GeneratedField;
8260
8261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8262 write!(formatter, "expected one of: {:?}", &FIELDS)
8263 }
8264
8265 #[allow(unused_variables)]
8266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8267 where
8268 E: serde::de::Error,
8269 {
8270 match value {
8271 "status" => Ok(GeneratedField::Status),
8272 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8273 }
8274 }
8275 }
8276 deserializer.deserialize_identifier(GeneratedVisitor)
8277 }
8278 }
8279 struct GeneratedVisitor;
8280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8281 type Value = HeartbeatResponse;
8282
8283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8284 formatter.write_str("struct meta.HeartbeatResponse")
8285 }
8286
8287 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8288 where
8289 V: serde::de::MapAccess<'de>,
8290 {
8291 let mut status__ = None;
8292 while let Some(k) = map_.next_key()? {
8293 match k {
8294 GeneratedField::Status => {
8295 if status__.is_some() {
8296 return Err(serde::de::Error::duplicate_field("status"));
8297 }
8298 status__ = map_.next_value()?;
8299 }
8300 }
8301 }
8302 Ok(HeartbeatResponse {
8303 status: status__,
8304 })
8305 }
8306 }
8307 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8308 }
8309}
8310impl serde::Serialize for ListActorSplitsRequest {
8311 #[allow(deprecated)]
8312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8313 where
8314 S: serde::Serializer,
8315 {
8316 use serde::ser::SerializeStruct;
8317 let len = 0;
8318 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8319 struct_ser.end()
8320 }
8321}
8322impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8323 #[allow(deprecated)]
8324 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8325 where
8326 D: serde::Deserializer<'de>,
8327 {
8328 const FIELDS: &[&str] = &[
8329 ];
8330
8331 #[allow(clippy::enum_variant_names)]
8332 enum GeneratedField {
8333 }
8334 impl<'de> serde::Deserialize<'de> for GeneratedField {
8335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8336 where
8337 D: serde::Deserializer<'de>,
8338 {
8339 struct GeneratedVisitor;
8340
8341 impl serde::de::Visitor<'_> for GeneratedVisitor {
8342 type Value = GeneratedField;
8343
8344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8345 write!(formatter, "expected one of: {:?}", &FIELDS)
8346 }
8347
8348 #[allow(unused_variables)]
8349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8350 where
8351 E: serde::de::Error,
8352 {
8353 Err(serde::de::Error::unknown_field(value, FIELDS))
8354 }
8355 }
8356 deserializer.deserialize_identifier(GeneratedVisitor)
8357 }
8358 }
8359 struct GeneratedVisitor;
8360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8361 type Value = ListActorSplitsRequest;
8362
8363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8364 formatter.write_str("struct meta.ListActorSplitsRequest")
8365 }
8366
8367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8368 where
8369 V: serde::de::MapAccess<'de>,
8370 {
8371 while map_.next_key::<GeneratedField>()?.is_some() {
8372 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8373 }
8374 Ok(ListActorSplitsRequest {
8375 })
8376 }
8377 }
8378 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
8379 }
8380}
8381impl serde::Serialize for ListActorSplitsResponse {
8382 #[allow(deprecated)]
8383 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8384 where
8385 S: serde::Serializer,
8386 {
8387 use serde::ser::SerializeStruct;
8388 let mut len = 0;
8389 if !self.actor_splits.is_empty() {
8390 len += 1;
8391 }
8392 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
8393 if !self.actor_splits.is_empty() {
8394 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
8395 }
8396 struct_ser.end()
8397 }
8398}
8399impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
8400 #[allow(deprecated)]
8401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8402 where
8403 D: serde::Deserializer<'de>,
8404 {
8405 const FIELDS: &[&str] = &[
8406 "actor_splits",
8407 "actorSplits",
8408 ];
8409
8410 #[allow(clippy::enum_variant_names)]
8411 enum GeneratedField {
8412 ActorSplits,
8413 }
8414 impl<'de> serde::Deserialize<'de> for GeneratedField {
8415 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8416 where
8417 D: serde::Deserializer<'de>,
8418 {
8419 struct GeneratedVisitor;
8420
8421 impl serde::de::Visitor<'_> for GeneratedVisitor {
8422 type Value = GeneratedField;
8423
8424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8425 write!(formatter, "expected one of: {:?}", &FIELDS)
8426 }
8427
8428 #[allow(unused_variables)]
8429 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8430 where
8431 E: serde::de::Error,
8432 {
8433 match value {
8434 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
8435 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8436 }
8437 }
8438 }
8439 deserializer.deserialize_identifier(GeneratedVisitor)
8440 }
8441 }
8442 struct GeneratedVisitor;
8443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8444 type Value = ListActorSplitsResponse;
8445
8446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8447 formatter.write_str("struct meta.ListActorSplitsResponse")
8448 }
8449
8450 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
8451 where
8452 V: serde::de::MapAccess<'de>,
8453 {
8454 let mut actor_splits__ = None;
8455 while let Some(k) = map_.next_key()? {
8456 match k {
8457 GeneratedField::ActorSplits => {
8458 if actor_splits__.is_some() {
8459 return Err(serde::de::Error::duplicate_field("actorSplits"));
8460 }
8461 actor_splits__ = Some(map_.next_value()?);
8462 }
8463 }
8464 }
8465 Ok(ListActorSplitsResponse {
8466 actor_splits: actor_splits__.unwrap_or_default(),
8467 })
8468 }
8469 }
8470 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
8471 }
8472}
8473impl serde::Serialize for list_actor_splits_response::ActorSplit {
8474 #[allow(deprecated)]
8475 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8476 where
8477 S: serde::Serializer,
8478 {
8479 use serde::ser::SerializeStruct;
8480 let mut len = 0;
8481 if self.actor_id != 0 {
8482 len += 1;
8483 }
8484 if self.fragment_id != 0 {
8485 len += 1;
8486 }
8487 if self.source_id != 0 {
8488 len += 1;
8489 }
8490 if !self.split_id.is_empty() {
8491 len += 1;
8492 }
8493 if self.fragment_type != 0 {
8494 len += 1;
8495 }
8496 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
8497 if self.actor_id != 0 {
8498 struct_ser.serialize_field("actorId", &self.actor_id)?;
8499 }
8500 if self.fragment_id != 0 {
8501 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8502 }
8503 if self.source_id != 0 {
8504 struct_ser.serialize_field("sourceId", &self.source_id)?;
8505 }
8506 if !self.split_id.is_empty() {
8507 struct_ser.serialize_field("splitId", &self.split_id)?;
8508 }
8509 if self.fragment_type != 0 {
8510 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
8511 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8512 struct_ser.serialize_field("fragmentType", &v)?;
8513 }
8514 struct_ser.end()
8515 }
8516}
8517impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8518 #[allow(deprecated)]
8519 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8520 where
8521 D: serde::Deserializer<'de>,
8522 {
8523 const FIELDS: &[&str] = &[
8524 "actor_id",
8525 "actorId",
8526 "fragment_id",
8527 "fragmentId",
8528 "source_id",
8529 "sourceId",
8530 "split_id",
8531 "splitId",
8532 "fragment_type",
8533 "fragmentType",
8534 ];
8535
8536 #[allow(clippy::enum_variant_names)]
8537 enum GeneratedField {
8538 ActorId,
8539 FragmentId,
8540 SourceId,
8541 SplitId,
8542 FragmentType,
8543 }
8544 impl<'de> serde::Deserialize<'de> for GeneratedField {
8545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8546 where
8547 D: serde::Deserializer<'de>,
8548 {
8549 struct GeneratedVisitor;
8550
8551 impl serde::de::Visitor<'_> for GeneratedVisitor {
8552 type Value = GeneratedField;
8553
8554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8555 write!(formatter, "expected one of: {:?}", &FIELDS)
8556 }
8557
8558 #[allow(unused_variables)]
8559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8560 where
8561 E: serde::de::Error,
8562 {
8563 match value {
8564 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8565 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8566 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8567 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
8568 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
8569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8570 }
8571 }
8572 }
8573 deserializer.deserialize_identifier(GeneratedVisitor)
8574 }
8575 }
8576 struct GeneratedVisitor;
8577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8578 type Value = list_actor_splits_response::ActorSplit;
8579
8580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8581 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
8582 }
8583
8584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
8585 where
8586 V: serde::de::MapAccess<'de>,
8587 {
8588 let mut actor_id__ = None;
8589 let mut fragment_id__ = None;
8590 let mut source_id__ = None;
8591 let mut split_id__ = None;
8592 let mut fragment_type__ = None;
8593 while let Some(k) = map_.next_key()? {
8594 match k {
8595 GeneratedField::ActorId => {
8596 if actor_id__.is_some() {
8597 return Err(serde::de::Error::duplicate_field("actorId"));
8598 }
8599 actor_id__ =
8600 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8601 ;
8602 }
8603 GeneratedField::FragmentId => {
8604 if fragment_id__.is_some() {
8605 return Err(serde::de::Error::duplicate_field("fragmentId"));
8606 }
8607 fragment_id__ =
8608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8609 ;
8610 }
8611 GeneratedField::SourceId => {
8612 if source_id__.is_some() {
8613 return Err(serde::de::Error::duplicate_field("sourceId"));
8614 }
8615 source_id__ =
8616 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8617 ;
8618 }
8619 GeneratedField::SplitId => {
8620 if split_id__.is_some() {
8621 return Err(serde::de::Error::duplicate_field("splitId"));
8622 }
8623 split_id__ = Some(map_.next_value()?);
8624 }
8625 GeneratedField::FragmentType => {
8626 if fragment_type__.is_some() {
8627 return Err(serde::de::Error::duplicate_field("fragmentType"));
8628 }
8629 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
8630 }
8631 }
8632 }
8633 Ok(list_actor_splits_response::ActorSplit {
8634 actor_id: actor_id__.unwrap_or_default(),
8635 fragment_id: fragment_id__.unwrap_or_default(),
8636 source_id: source_id__.unwrap_or_default(),
8637 split_id: split_id__.unwrap_or_default(),
8638 fragment_type: fragment_type__.unwrap_or_default(),
8639 })
8640 }
8641 }
8642 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
8643 }
8644}
8645impl serde::Serialize for list_actor_splits_response::FragmentType {
8646 #[allow(deprecated)]
8647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8648 where
8649 S: serde::Serializer,
8650 {
8651 let variant = match self {
8652 Self::Unspecified => "UNSPECIFIED",
8653 Self::NonSharedSource => "NON_SHARED_SOURCE",
8654 Self::SharedSource => "SHARED_SOURCE",
8655 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
8656 };
8657 serializer.serialize_str(variant)
8658 }
8659}
8660impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
8661 #[allow(deprecated)]
8662 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8663 where
8664 D: serde::Deserializer<'de>,
8665 {
8666 const FIELDS: &[&str] = &[
8667 "UNSPECIFIED",
8668 "NON_SHARED_SOURCE",
8669 "SHARED_SOURCE",
8670 "SHARED_SOURCE_BACKFILL",
8671 ];
8672
8673 struct GeneratedVisitor;
8674
8675 impl serde::de::Visitor<'_> for GeneratedVisitor {
8676 type Value = list_actor_splits_response::FragmentType;
8677
8678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8679 write!(formatter, "expected one of: {:?}", &FIELDS)
8680 }
8681
8682 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8683 where
8684 E: serde::de::Error,
8685 {
8686 i32::try_from(v)
8687 .ok()
8688 .and_then(|x| x.try_into().ok())
8689 .ok_or_else(|| {
8690 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8691 })
8692 }
8693
8694 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8695 where
8696 E: serde::de::Error,
8697 {
8698 i32::try_from(v)
8699 .ok()
8700 .and_then(|x| x.try_into().ok())
8701 .ok_or_else(|| {
8702 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8703 })
8704 }
8705
8706 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8707 where
8708 E: serde::de::Error,
8709 {
8710 match value {
8711 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8712 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8713 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8714 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8715 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8716 }
8717 }
8718 }
8719 deserializer.deserialize_any(GeneratedVisitor)
8720 }
8721}
8722impl serde::Serialize for ListActorStatesRequest {
8723 #[allow(deprecated)]
8724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8725 where
8726 S: serde::Serializer,
8727 {
8728 use serde::ser::SerializeStruct;
8729 let len = 0;
8730 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8731 struct_ser.end()
8732 }
8733}
8734impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8735 #[allow(deprecated)]
8736 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8737 where
8738 D: serde::Deserializer<'de>,
8739 {
8740 const FIELDS: &[&str] = &[
8741 ];
8742
8743 #[allow(clippy::enum_variant_names)]
8744 enum GeneratedField {
8745 }
8746 impl<'de> serde::Deserialize<'de> for GeneratedField {
8747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8748 where
8749 D: serde::Deserializer<'de>,
8750 {
8751 struct GeneratedVisitor;
8752
8753 impl serde::de::Visitor<'_> for GeneratedVisitor {
8754 type Value = GeneratedField;
8755
8756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8757 write!(formatter, "expected one of: {:?}", &FIELDS)
8758 }
8759
8760 #[allow(unused_variables)]
8761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8762 where
8763 E: serde::de::Error,
8764 {
8765 Err(serde::de::Error::unknown_field(value, FIELDS))
8766 }
8767 }
8768 deserializer.deserialize_identifier(GeneratedVisitor)
8769 }
8770 }
8771 struct GeneratedVisitor;
8772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8773 type Value = ListActorStatesRequest;
8774
8775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8776 formatter.write_str("struct meta.ListActorStatesRequest")
8777 }
8778
8779 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8780 where
8781 V: serde::de::MapAccess<'de>,
8782 {
8783 while map_.next_key::<GeneratedField>()?.is_some() {
8784 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8785 }
8786 Ok(ListActorStatesRequest {
8787 })
8788 }
8789 }
8790 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8791 }
8792}
8793impl serde::Serialize for ListActorStatesResponse {
8794 #[allow(deprecated)]
8795 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8796 where
8797 S: serde::Serializer,
8798 {
8799 use serde::ser::SerializeStruct;
8800 let mut len = 0;
8801 if !self.states.is_empty() {
8802 len += 1;
8803 }
8804 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8805 if !self.states.is_empty() {
8806 struct_ser.serialize_field("states", &self.states)?;
8807 }
8808 struct_ser.end()
8809 }
8810}
8811impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8812 #[allow(deprecated)]
8813 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8814 where
8815 D: serde::Deserializer<'de>,
8816 {
8817 const FIELDS: &[&str] = &[
8818 "states",
8819 ];
8820
8821 #[allow(clippy::enum_variant_names)]
8822 enum GeneratedField {
8823 States,
8824 }
8825 impl<'de> serde::Deserialize<'de> for GeneratedField {
8826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8827 where
8828 D: serde::Deserializer<'de>,
8829 {
8830 struct GeneratedVisitor;
8831
8832 impl serde::de::Visitor<'_> for GeneratedVisitor {
8833 type Value = GeneratedField;
8834
8835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8836 write!(formatter, "expected one of: {:?}", &FIELDS)
8837 }
8838
8839 #[allow(unused_variables)]
8840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8841 where
8842 E: serde::de::Error,
8843 {
8844 match value {
8845 "states" => Ok(GeneratedField::States),
8846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8847 }
8848 }
8849 }
8850 deserializer.deserialize_identifier(GeneratedVisitor)
8851 }
8852 }
8853 struct GeneratedVisitor;
8854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8855 type Value = ListActorStatesResponse;
8856
8857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8858 formatter.write_str("struct meta.ListActorStatesResponse")
8859 }
8860
8861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8862 where
8863 V: serde::de::MapAccess<'de>,
8864 {
8865 let mut states__ = None;
8866 while let Some(k) = map_.next_key()? {
8867 match k {
8868 GeneratedField::States => {
8869 if states__.is_some() {
8870 return Err(serde::de::Error::duplicate_field("states"));
8871 }
8872 states__ = Some(map_.next_value()?);
8873 }
8874 }
8875 }
8876 Ok(ListActorStatesResponse {
8877 states: states__.unwrap_or_default(),
8878 })
8879 }
8880 }
8881 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8882 }
8883}
8884impl serde::Serialize for list_actor_states_response::ActorState {
8885 #[allow(deprecated)]
8886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8887 where
8888 S: serde::Serializer,
8889 {
8890 use serde::ser::SerializeStruct;
8891 let mut len = 0;
8892 if self.actor_id != 0 {
8893 len += 1;
8894 }
8895 if self.fragment_id != 0 {
8896 len += 1;
8897 }
8898 if self.worker_id != 0 {
8899 len += 1;
8900 }
8901 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8902 if self.actor_id != 0 {
8903 struct_ser.serialize_field("actorId", &self.actor_id)?;
8904 }
8905 if self.fragment_id != 0 {
8906 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8907 }
8908 if self.worker_id != 0 {
8909 struct_ser.serialize_field("workerId", &self.worker_id)?;
8910 }
8911 struct_ser.end()
8912 }
8913}
8914impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8915 #[allow(deprecated)]
8916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8917 where
8918 D: serde::Deserializer<'de>,
8919 {
8920 const FIELDS: &[&str] = &[
8921 "actor_id",
8922 "actorId",
8923 "fragment_id",
8924 "fragmentId",
8925 "worker_id",
8926 "workerId",
8927 ];
8928
8929 #[allow(clippy::enum_variant_names)]
8930 enum GeneratedField {
8931 ActorId,
8932 FragmentId,
8933 WorkerId,
8934 }
8935 impl<'de> serde::Deserialize<'de> for GeneratedField {
8936 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8937 where
8938 D: serde::Deserializer<'de>,
8939 {
8940 struct GeneratedVisitor;
8941
8942 impl serde::de::Visitor<'_> for GeneratedVisitor {
8943 type Value = GeneratedField;
8944
8945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8946 write!(formatter, "expected one of: {:?}", &FIELDS)
8947 }
8948
8949 #[allow(unused_variables)]
8950 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8951 where
8952 E: serde::de::Error,
8953 {
8954 match value {
8955 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8956 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8957 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8958 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8959 }
8960 }
8961 }
8962 deserializer.deserialize_identifier(GeneratedVisitor)
8963 }
8964 }
8965 struct GeneratedVisitor;
8966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8967 type Value = list_actor_states_response::ActorState;
8968
8969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8970 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8971 }
8972
8973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8974 where
8975 V: serde::de::MapAccess<'de>,
8976 {
8977 let mut actor_id__ = None;
8978 let mut fragment_id__ = None;
8979 let mut worker_id__ = None;
8980 while let Some(k) = map_.next_key()? {
8981 match k {
8982 GeneratedField::ActorId => {
8983 if actor_id__.is_some() {
8984 return Err(serde::de::Error::duplicate_field("actorId"));
8985 }
8986 actor_id__ =
8987 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8988 ;
8989 }
8990 GeneratedField::FragmentId => {
8991 if fragment_id__.is_some() {
8992 return Err(serde::de::Error::duplicate_field("fragmentId"));
8993 }
8994 fragment_id__ =
8995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8996 ;
8997 }
8998 GeneratedField::WorkerId => {
8999 if worker_id__.is_some() {
9000 return Err(serde::de::Error::duplicate_field("workerId"));
9001 }
9002 worker_id__ =
9003 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9004 ;
9005 }
9006 }
9007 }
9008 Ok(list_actor_states_response::ActorState {
9009 actor_id: actor_id__.unwrap_or_default(),
9010 fragment_id: fragment_id__.unwrap_or_default(),
9011 worker_id: worker_id__.unwrap_or_default(),
9012 })
9013 }
9014 }
9015 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
9016 }
9017}
9018impl serde::Serialize for ListAllNodesRequest {
9019 #[allow(deprecated)]
9020 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9021 where
9022 S: serde::Serializer,
9023 {
9024 use serde::ser::SerializeStruct;
9025 let mut len = 0;
9026 if self.worker_type.is_some() {
9027 len += 1;
9028 }
9029 if self.include_starting_nodes {
9030 len += 1;
9031 }
9032 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9033 if let Some(v) = self.worker_type.as_ref() {
9034 let v = super::common::WorkerType::try_from(*v)
9035 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9036 struct_ser.serialize_field("workerType", &v)?;
9037 }
9038 if self.include_starting_nodes {
9039 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9040 }
9041 struct_ser.end()
9042 }
9043}
9044impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9045 #[allow(deprecated)]
9046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9047 where
9048 D: serde::Deserializer<'de>,
9049 {
9050 const FIELDS: &[&str] = &[
9051 "worker_type",
9052 "workerType",
9053 "include_starting_nodes",
9054 "includeStartingNodes",
9055 ];
9056
9057 #[allow(clippy::enum_variant_names)]
9058 enum GeneratedField {
9059 WorkerType,
9060 IncludeStartingNodes,
9061 }
9062 impl<'de> serde::Deserialize<'de> for GeneratedField {
9063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9064 where
9065 D: serde::Deserializer<'de>,
9066 {
9067 struct GeneratedVisitor;
9068
9069 impl serde::de::Visitor<'_> for GeneratedVisitor {
9070 type Value = GeneratedField;
9071
9072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9073 write!(formatter, "expected one of: {:?}", &FIELDS)
9074 }
9075
9076 #[allow(unused_variables)]
9077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9078 where
9079 E: serde::de::Error,
9080 {
9081 match value {
9082 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9083 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9085 }
9086 }
9087 }
9088 deserializer.deserialize_identifier(GeneratedVisitor)
9089 }
9090 }
9091 struct GeneratedVisitor;
9092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9093 type Value = ListAllNodesRequest;
9094
9095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9096 formatter.write_str("struct meta.ListAllNodesRequest")
9097 }
9098
9099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9100 where
9101 V: serde::de::MapAccess<'de>,
9102 {
9103 let mut worker_type__ = None;
9104 let mut include_starting_nodes__ = None;
9105 while let Some(k) = map_.next_key()? {
9106 match k {
9107 GeneratedField::WorkerType => {
9108 if worker_type__.is_some() {
9109 return Err(serde::de::Error::duplicate_field("workerType"));
9110 }
9111 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9112 }
9113 GeneratedField::IncludeStartingNodes => {
9114 if include_starting_nodes__.is_some() {
9115 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9116 }
9117 include_starting_nodes__ = Some(map_.next_value()?);
9118 }
9119 }
9120 }
9121 Ok(ListAllNodesRequest {
9122 worker_type: worker_type__,
9123 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9124 })
9125 }
9126 }
9127 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9128 }
9129}
9130impl serde::Serialize for ListAllNodesResponse {
9131 #[allow(deprecated)]
9132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9133 where
9134 S: serde::Serializer,
9135 {
9136 use serde::ser::SerializeStruct;
9137 let mut len = 0;
9138 if self.status.is_some() {
9139 len += 1;
9140 }
9141 if !self.nodes.is_empty() {
9142 len += 1;
9143 }
9144 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9145 if let Some(v) = self.status.as_ref() {
9146 struct_ser.serialize_field("status", v)?;
9147 }
9148 if !self.nodes.is_empty() {
9149 struct_ser.serialize_field("nodes", &self.nodes)?;
9150 }
9151 struct_ser.end()
9152 }
9153}
9154impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9155 #[allow(deprecated)]
9156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9157 where
9158 D: serde::Deserializer<'de>,
9159 {
9160 const FIELDS: &[&str] = &[
9161 "status",
9162 "nodes",
9163 ];
9164
9165 #[allow(clippy::enum_variant_names)]
9166 enum GeneratedField {
9167 Status,
9168 Nodes,
9169 }
9170 impl<'de> serde::Deserialize<'de> for GeneratedField {
9171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9172 where
9173 D: serde::Deserializer<'de>,
9174 {
9175 struct GeneratedVisitor;
9176
9177 impl serde::de::Visitor<'_> for GeneratedVisitor {
9178 type Value = GeneratedField;
9179
9180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9181 write!(formatter, "expected one of: {:?}", &FIELDS)
9182 }
9183
9184 #[allow(unused_variables)]
9185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9186 where
9187 E: serde::de::Error,
9188 {
9189 match value {
9190 "status" => Ok(GeneratedField::Status),
9191 "nodes" => Ok(GeneratedField::Nodes),
9192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9193 }
9194 }
9195 }
9196 deserializer.deserialize_identifier(GeneratedVisitor)
9197 }
9198 }
9199 struct GeneratedVisitor;
9200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9201 type Value = ListAllNodesResponse;
9202
9203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9204 formatter.write_str("struct meta.ListAllNodesResponse")
9205 }
9206
9207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9208 where
9209 V: serde::de::MapAccess<'de>,
9210 {
9211 let mut status__ = None;
9212 let mut nodes__ = None;
9213 while let Some(k) = map_.next_key()? {
9214 match k {
9215 GeneratedField::Status => {
9216 if status__.is_some() {
9217 return Err(serde::de::Error::duplicate_field("status"));
9218 }
9219 status__ = map_.next_value()?;
9220 }
9221 GeneratedField::Nodes => {
9222 if nodes__.is_some() {
9223 return Err(serde::de::Error::duplicate_field("nodes"));
9224 }
9225 nodes__ = Some(map_.next_value()?);
9226 }
9227 }
9228 }
9229 Ok(ListAllNodesResponse {
9230 status: status__,
9231 nodes: nodes__.unwrap_or_default(),
9232 })
9233 }
9234 }
9235 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9236 }
9237}
9238impl serde::Serialize for ListCdcProgressRequest {
9239 #[allow(deprecated)]
9240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9241 where
9242 S: serde::Serializer,
9243 {
9244 use serde::ser::SerializeStruct;
9245 let len = 0;
9246 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9247 struct_ser.end()
9248 }
9249}
9250impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9251 #[allow(deprecated)]
9252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9253 where
9254 D: serde::Deserializer<'de>,
9255 {
9256 const FIELDS: &[&str] = &[
9257 ];
9258
9259 #[allow(clippy::enum_variant_names)]
9260 enum GeneratedField {
9261 }
9262 impl<'de> serde::Deserialize<'de> for GeneratedField {
9263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9264 where
9265 D: serde::Deserializer<'de>,
9266 {
9267 struct GeneratedVisitor;
9268
9269 impl serde::de::Visitor<'_> for GeneratedVisitor {
9270 type Value = GeneratedField;
9271
9272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9273 write!(formatter, "expected one of: {:?}", &FIELDS)
9274 }
9275
9276 #[allow(unused_variables)]
9277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9278 where
9279 E: serde::de::Error,
9280 {
9281 Err(serde::de::Error::unknown_field(value, FIELDS))
9282 }
9283 }
9284 deserializer.deserialize_identifier(GeneratedVisitor)
9285 }
9286 }
9287 struct GeneratedVisitor;
9288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9289 type Value = ListCdcProgressRequest;
9290
9291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9292 formatter.write_str("struct meta.ListCdcProgressRequest")
9293 }
9294
9295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9296 where
9297 V: serde::de::MapAccess<'de>,
9298 {
9299 while map_.next_key::<GeneratedField>()?.is_some() {
9300 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9301 }
9302 Ok(ListCdcProgressRequest {
9303 })
9304 }
9305 }
9306 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9307 }
9308}
9309impl serde::Serialize for ListCdcProgressResponse {
9310 #[allow(deprecated)]
9311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9312 where
9313 S: serde::Serializer,
9314 {
9315 use serde::ser::SerializeStruct;
9316 let mut len = 0;
9317 if !self.cdc_progress.is_empty() {
9318 len += 1;
9319 }
9320 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9321 if !self.cdc_progress.is_empty() {
9322 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9323 }
9324 struct_ser.end()
9325 }
9326}
9327impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9328 #[allow(deprecated)]
9329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9330 where
9331 D: serde::Deserializer<'de>,
9332 {
9333 const FIELDS: &[&str] = &[
9334 "cdc_progress",
9335 "cdcProgress",
9336 ];
9337
9338 #[allow(clippy::enum_variant_names)]
9339 enum GeneratedField {
9340 CdcProgress,
9341 }
9342 impl<'de> serde::Deserialize<'de> for GeneratedField {
9343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9344 where
9345 D: serde::Deserializer<'de>,
9346 {
9347 struct GeneratedVisitor;
9348
9349 impl serde::de::Visitor<'_> for GeneratedVisitor {
9350 type Value = GeneratedField;
9351
9352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9353 write!(formatter, "expected one of: {:?}", &FIELDS)
9354 }
9355
9356 #[allow(unused_variables)]
9357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9358 where
9359 E: serde::de::Error,
9360 {
9361 match value {
9362 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9364 }
9365 }
9366 }
9367 deserializer.deserialize_identifier(GeneratedVisitor)
9368 }
9369 }
9370 struct GeneratedVisitor;
9371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9372 type Value = ListCdcProgressResponse;
9373
9374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9375 formatter.write_str("struct meta.ListCdcProgressResponse")
9376 }
9377
9378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
9379 where
9380 V: serde::de::MapAccess<'de>,
9381 {
9382 let mut cdc_progress__ = None;
9383 while let Some(k) = map_.next_key()? {
9384 match k {
9385 GeneratedField::CdcProgress => {
9386 if cdc_progress__.is_some() {
9387 return Err(serde::de::Error::duplicate_field("cdcProgress"));
9388 }
9389 cdc_progress__ = Some(
9390 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9391 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9392 );
9393 }
9394 }
9395 }
9396 Ok(ListCdcProgressResponse {
9397 cdc_progress: cdc_progress__.unwrap_or_default(),
9398 })
9399 }
9400 }
9401 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
9402 }
9403}
9404impl serde::Serialize for list_cdc_progress_response::CdcProgress {
9405 #[allow(deprecated)]
9406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9407 where
9408 S: serde::Serializer,
9409 {
9410 use serde::ser::SerializeStruct;
9411 let mut len = 0;
9412 if self.split_total_count != 0 {
9413 len += 1;
9414 }
9415 if self.split_backfilled_count != 0 {
9416 len += 1;
9417 }
9418 if self.split_completed_count != 0 {
9419 len += 1;
9420 }
9421 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
9422 if self.split_total_count != 0 {
9423 #[allow(clippy::needless_borrow)]
9424 #[allow(clippy::needless_borrows_for_generic_args)]
9425 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
9426 }
9427 if self.split_backfilled_count != 0 {
9428 #[allow(clippy::needless_borrow)]
9429 #[allow(clippy::needless_borrows_for_generic_args)]
9430 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
9431 }
9432 if self.split_completed_count != 0 {
9433 #[allow(clippy::needless_borrow)]
9434 #[allow(clippy::needless_borrows_for_generic_args)]
9435 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
9436 }
9437 struct_ser.end()
9438 }
9439}
9440impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
9441 #[allow(deprecated)]
9442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9443 where
9444 D: serde::Deserializer<'de>,
9445 {
9446 const FIELDS: &[&str] = &[
9447 "split_total_count",
9448 "splitTotalCount",
9449 "split_backfilled_count",
9450 "splitBackfilledCount",
9451 "split_completed_count",
9452 "splitCompletedCount",
9453 ];
9454
9455 #[allow(clippy::enum_variant_names)]
9456 enum GeneratedField {
9457 SplitTotalCount,
9458 SplitBackfilledCount,
9459 SplitCompletedCount,
9460 }
9461 impl<'de> serde::Deserialize<'de> for GeneratedField {
9462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9463 where
9464 D: serde::Deserializer<'de>,
9465 {
9466 struct GeneratedVisitor;
9467
9468 impl serde::de::Visitor<'_> for GeneratedVisitor {
9469 type Value = GeneratedField;
9470
9471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9472 write!(formatter, "expected one of: {:?}", &FIELDS)
9473 }
9474
9475 #[allow(unused_variables)]
9476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9477 where
9478 E: serde::de::Error,
9479 {
9480 match value {
9481 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
9482 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
9483 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
9484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9485 }
9486 }
9487 }
9488 deserializer.deserialize_identifier(GeneratedVisitor)
9489 }
9490 }
9491 struct GeneratedVisitor;
9492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9493 type Value = list_cdc_progress_response::CdcProgress;
9494
9495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9496 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
9497 }
9498
9499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
9500 where
9501 V: serde::de::MapAccess<'de>,
9502 {
9503 let mut split_total_count__ = None;
9504 let mut split_backfilled_count__ = None;
9505 let mut split_completed_count__ = None;
9506 while let Some(k) = map_.next_key()? {
9507 match k {
9508 GeneratedField::SplitTotalCount => {
9509 if split_total_count__.is_some() {
9510 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9511 }
9512 split_total_count__ =
9513 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9514 ;
9515 }
9516 GeneratedField::SplitBackfilledCount => {
9517 if split_backfilled_count__.is_some() {
9518 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9519 }
9520 split_backfilled_count__ =
9521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9522 ;
9523 }
9524 GeneratedField::SplitCompletedCount => {
9525 if split_completed_count__.is_some() {
9526 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9527 }
9528 split_completed_count__ =
9529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9530 ;
9531 }
9532 }
9533 }
9534 Ok(list_cdc_progress_response::CdcProgress {
9535 split_total_count: split_total_count__.unwrap_or_default(),
9536 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9537 split_completed_count: split_completed_count__.unwrap_or_default(),
9538 })
9539 }
9540 }
9541 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9542 }
9543}
9544impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9545 #[allow(deprecated)]
9546 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9547 where
9548 S: serde::Serializer,
9549 {
9550 use serde::ser::SerializeStruct;
9551 let len = 0;
9552 let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
9553 struct_ser.end()
9554 }
9555}
9556impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
9557 #[allow(deprecated)]
9558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9559 where
9560 D: serde::Deserializer<'de>,
9561 {
9562 const FIELDS: &[&str] = &[
9563 ];
9564
9565 #[allow(clippy::enum_variant_names)]
9566 enum GeneratedField {
9567 }
9568 impl<'de> serde::Deserialize<'de> for GeneratedField {
9569 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9570 where
9571 D: serde::Deserializer<'de>,
9572 {
9573 struct GeneratedVisitor;
9574
9575 impl serde::de::Visitor<'_> for GeneratedVisitor {
9576 type Value = GeneratedField;
9577
9578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9579 write!(formatter, "expected one of: {:?}", &FIELDS)
9580 }
9581
9582 #[allow(unused_variables)]
9583 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9584 where
9585 E: serde::de::Error,
9586 {
9587 Err(serde::de::Error::unknown_field(value, FIELDS))
9588 }
9589 }
9590 deserializer.deserialize_identifier(GeneratedVisitor)
9591 }
9592 }
9593 struct GeneratedVisitor;
9594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9595 type Value = ListCreatingFragmentDistributionRequest;
9596
9597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9598 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
9599 }
9600
9601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
9602 where
9603 V: serde::de::MapAccess<'de>,
9604 {
9605 while map_.next_key::<GeneratedField>()?.is_some() {
9606 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9607 }
9608 Ok(ListCreatingFragmentDistributionRequest {
9609 })
9610 }
9611 }
9612 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9613 }
9614}
9615impl serde::Serialize for ListCreatingFragmentDistributionResponse {
9616 #[allow(deprecated)]
9617 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9618 where
9619 S: serde::Serializer,
9620 {
9621 use serde::ser::SerializeStruct;
9622 let mut len = 0;
9623 if !self.distributions.is_empty() {
9624 len += 1;
9625 }
9626 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
9627 if !self.distributions.is_empty() {
9628 struct_ser.serialize_field("distributions", &self.distributions)?;
9629 }
9630 struct_ser.end()
9631 }
9632}
9633impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
9634 #[allow(deprecated)]
9635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9636 where
9637 D: serde::Deserializer<'de>,
9638 {
9639 const FIELDS: &[&str] = &[
9640 "distributions",
9641 ];
9642
9643 #[allow(clippy::enum_variant_names)]
9644 enum GeneratedField {
9645 Distributions,
9646 }
9647 impl<'de> serde::Deserialize<'de> for GeneratedField {
9648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9649 where
9650 D: serde::Deserializer<'de>,
9651 {
9652 struct GeneratedVisitor;
9653
9654 impl serde::de::Visitor<'_> for GeneratedVisitor {
9655 type Value = GeneratedField;
9656
9657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9658 write!(formatter, "expected one of: {:?}", &FIELDS)
9659 }
9660
9661 #[allow(unused_variables)]
9662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9663 where
9664 E: serde::de::Error,
9665 {
9666 match value {
9667 "distributions" => Ok(GeneratedField::Distributions),
9668 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9669 }
9670 }
9671 }
9672 deserializer.deserialize_identifier(GeneratedVisitor)
9673 }
9674 }
9675 struct GeneratedVisitor;
9676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9677 type Value = ListCreatingFragmentDistributionResponse;
9678
9679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9680 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9681 }
9682
9683 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9684 where
9685 V: serde::de::MapAccess<'de>,
9686 {
9687 let mut distributions__ = None;
9688 while let Some(k) = map_.next_key()? {
9689 match k {
9690 GeneratedField::Distributions => {
9691 if distributions__.is_some() {
9692 return Err(serde::de::Error::duplicate_field("distributions"));
9693 }
9694 distributions__ = Some(map_.next_value()?);
9695 }
9696 }
9697 }
9698 Ok(ListCreatingFragmentDistributionResponse {
9699 distributions: distributions__.unwrap_or_default(),
9700 })
9701 }
9702 }
9703 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9704 }
9705}
9706impl serde::Serialize for ListEventLogRequest {
9707 #[allow(deprecated)]
9708 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9709 where
9710 S: serde::Serializer,
9711 {
9712 use serde::ser::SerializeStruct;
9713 let len = 0;
9714 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9715 struct_ser.end()
9716 }
9717}
9718impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9719 #[allow(deprecated)]
9720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9721 where
9722 D: serde::Deserializer<'de>,
9723 {
9724 const FIELDS: &[&str] = &[
9725 ];
9726
9727 #[allow(clippy::enum_variant_names)]
9728 enum GeneratedField {
9729 }
9730 impl<'de> serde::Deserialize<'de> for GeneratedField {
9731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9732 where
9733 D: serde::Deserializer<'de>,
9734 {
9735 struct GeneratedVisitor;
9736
9737 impl serde::de::Visitor<'_> for GeneratedVisitor {
9738 type Value = GeneratedField;
9739
9740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9741 write!(formatter, "expected one of: {:?}", &FIELDS)
9742 }
9743
9744 #[allow(unused_variables)]
9745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9746 where
9747 E: serde::de::Error,
9748 {
9749 Err(serde::de::Error::unknown_field(value, FIELDS))
9750 }
9751 }
9752 deserializer.deserialize_identifier(GeneratedVisitor)
9753 }
9754 }
9755 struct GeneratedVisitor;
9756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9757 type Value = ListEventLogRequest;
9758
9759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9760 formatter.write_str("struct meta.ListEventLogRequest")
9761 }
9762
9763 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9764 where
9765 V: serde::de::MapAccess<'de>,
9766 {
9767 while map_.next_key::<GeneratedField>()?.is_some() {
9768 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9769 }
9770 Ok(ListEventLogRequest {
9771 })
9772 }
9773 }
9774 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9775 }
9776}
9777impl serde::Serialize for ListEventLogResponse {
9778 #[allow(deprecated)]
9779 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9780 where
9781 S: serde::Serializer,
9782 {
9783 use serde::ser::SerializeStruct;
9784 let mut len = 0;
9785 if !self.event_logs.is_empty() {
9786 len += 1;
9787 }
9788 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9789 if !self.event_logs.is_empty() {
9790 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9791 }
9792 struct_ser.end()
9793 }
9794}
9795impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9796 #[allow(deprecated)]
9797 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9798 where
9799 D: serde::Deserializer<'de>,
9800 {
9801 const FIELDS: &[&str] = &[
9802 "event_logs",
9803 "eventLogs",
9804 ];
9805
9806 #[allow(clippy::enum_variant_names)]
9807 enum GeneratedField {
9808 EventLogs,
9809 }
9810 impl<'de> serde::Deserialize<'de> for GeneratedField {
9811 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9812 where
9813 D: serde::Deserializer<'de>,
9814 {
9815 struct GeneratedVisitor;
9816
9817 impl serde::de::Visitor<'_> for GeneratedVisitor {
9818 type Value = GeneratedField;
9819
9820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9821 write!(formatter, "expected one of: {:?}", &FIELDS)
9822 }
9823
9824 #[allow(unused_variables)]
9825 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9826 where
9827 E: serde::de::Error,
9828 {
9829 match value {
9830 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9831 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9832 }
9833 }
9834 }
9835 deserializer.deserialize_identifier(GeneratedVisitor)
9836 }
9837 }
9838 struct GeneratedVisitor;
9839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9840 type Value = ListEventLogResponse;
9841
9842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9843 formatter.write_str("struct meta.ListEventLogResponse")
9844 }
9845
9846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9847 where
9848 V: serde::de::MapAccess<'de>,
9849 {
9850 let mut event_logs__ = None;
9851 while let Some(k) = map_.next_key()? {
9852 match k {
9853 GeneratedField::EventLogs => {
9854 if event_logs__.is_some() {
9855 return Err(serde::de::Error::duplicate_field("eventLogs"));
9856 }
9857 event_logs__ = Some(map_.next_value()?);
9858 }
9859 }
9860 }
9861 Ok(ListEventLogResponse {
9862 event_logs: event_logs__.unwrap_or_default(),
9863 })
9864 }
9865 }
9866 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9867 }
9868}
9869impl serde::Serialize for ListFragmentDistributionRequest {
9870 #[allow(deprecated)]
9871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9872 where
9873 S: serde::Serializer,
9874 {
9875 use serde::ser::SerializeStruct;
9876 let len = 0;
9877 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9878 struct_ser.end()
9879 }
9880}
9881impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9882 #[allow(deprecated)]
9883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9884 where
9885 D: serde::Deserializer<'de>,
9886 {
9887 const FIELDS: &[&str] = &[
9888 ];
9889
9890 #[allow(clippy::enum_variant_names)]
9891 enum GeneratedField {
9892 }
9893 impl<'de> serde::Deserialize<'de> for GeneratedField {
9894 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9895 where
9896 D: serde::Deserializer<'de>,
9897 {
9898 struct GeneratedVisitor;
9899
9900 impl serde::de::Visitor<'_> for GeneratedVisitor {
9901 type Value = GeneratedField;
9902
9903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9904 write!(formatter, "expected one of: {:?}", &FIELDS)
9905 }
9906
9907 #[allow(unused_variables)]
9908 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9909 where
9910 E: serde::de::Error,
9911 {
9912 Err(serde::de::Error::unknown_field(value, FIELDS))
9913 }
9914 }
9915 deserializer.deserialize_identifier(GeneratedVisitor)
9916 }
9917 }
9918 struct GeneratedVisitor;
9919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9920 type Value = ListFragmentDistributionRequest;
9921
9922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9923 formatter.write_str("struct meta.ListFragmentDistributionRequest")
9924 }
9925
9926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9927 where
9928 V: serde::de::MapAccess<'de>,
9929 {
9930 while map_.next_key::<GeneratedField>()?.is_some() {
9931 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9932 }
9933 Ok(ListFragmentDistributionRequest {
9934 })
9935 }
9936 }
9937 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9938 }
9939}
9940impl serde::Serialize for ListFragmentDistributionResponse {
9941 #[allow(deprecated)]
9942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9943 where
9944 S: serde::Serializer,
9945 {
9946 use serde::ser::SerializeStruct;
9947 let mut len = 0;
9948 if !self.distributions.is_empty() {
9949 len += 1;
9950 }
9951 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9952 if !self.distributions.is_empty() {
9953 struct_ser.serialize_field("distributions", &self.distributions)?;
9954 }
9955 struct_ser.end()
9956 }
9957}
9958impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9959 #[allow(deprecated)]
9960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9961 where
9962 D: serde::Deserializer<'de>,
9963 {
9964 const FIELDS: &[&str] = &[
9965 "distributions",
9966 ];
9967
9968 #[allow(clippy::enum_variant_names)]
9969 enum GeneratedField {
9970 Distributions,
9971 }
9972 impl<'de> serde::Deserialize<'de> for GeneratedField {
9973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9974 where
9975 D: serde::Deserializer<'de>,
9976 {
9977 struct GeneratedVisitor;
9978
9979 impl serde::de::Visitor<'_> for GeneratedVisitor {
9980 type Value = GeneratedField;
9981
9982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9983 write!(formatter, "expected one of: {:?}", &FIELDS)
9984 }
9985
9986 #[allow(unused_variables)]
9987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9988 where
9989 E: serde::de::Error,
9990 {
9991 match value {
9992 "distributions" => Ok(GeneratedField::Distributions),
9993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9994 }
9995 }
9996 }
9997 deserializer.deserialize_identifier(GeneratedVisitor)
9998 }
9999 }
10000 struct GeneratedVisitor;
10001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10002 type Value = ListFragmentDistributionResponse;
10003
10004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10005 formatter.write_str("struct meta.ListFragmentDistributionResponse")
10006 }
10007
10008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
10009 where
10010 V: serde::de::MapAccess<'de>,
10011 {
10012 let mut distributions__ = None;
10013 while let Some(k) = map_.next_key()? {
10014 match k {
10015 GeneratedField::Distributions => {
10016 if distributions__.is_some() {
10017 return Err(serde::de::Error::duplicate_field("distributions"));
10018 }
10019 distributions__ = Some(map_.next_value()?);
10020 }
10021 }
10022 }
10023 Ok(ListFragmentDistributionResponse {
10024 distributions: distributions__.unwrap_or_default(),
10025 })
10026 }
10027 }
10028 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10029 }
10030}
10031impl serde::Serialize for ListIcebergTablesRequest {
10032 #[allow(deprecated)]
10033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10034 where
10035 S: serde::Serializer,
10036 {
10037 use serde::ser::SerializeStruct;
10038 let len = 0;
10039 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
10040 struct_ser.end()
10041 }
10042}
10043impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
10044 #[allow(deprecated)]
10045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10046 where
10047 D: serde::Deserializer<'de>,
10048 {
10049 const FIELDS: &[&str] = &[
10050 ];
10051
10052 #[allow(clippy::enum_variant_names)]
10053 enum GeneratedField {
10054 }
10055 impl<'de> serde::Deserialize<'de> for GeneratedField {
10056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10057 where
10058 D: serde::Deserializer<'de>,
10059 {
10060 struct GeneratedVisitor;
10061
10062 impl serde::de::Visitor<'_> for GeneratedVisitor {
10063 type Value = GeneratedField;
10064
10065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10066 write!(formatter, "expected one of: {:?}", &FIELDS)
10067 }
10068
10069 #[allow(unused_variables)]
10070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10071 where
10072 E: serde::de::Error,
10073 {
10074 Err(serde::de::Error::unknown_field(value, FIELDS))
10075 }
10076 }
10077 deserializer.deserialize_identifier(GeneratedVisitor)
10078 }
10079 }
10080 struct GeneratedVisitor;
10081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10082 type Value = ListIcebergTablesRequest;
10083
10084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10085 formatter.write_str("struct meta.ListIcebergTablesRequest")
10086 }
10087
10088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
10089 where
10090 V: serde::de::MapAccess<'de>,
10091 {
10092 while map_.next_key::<GeneratedField>()?.is_some() {
10093 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10094 }
10095 Ok(ListIcebergTablesRequest {
10096 })
10097 }
10098 }
10099 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
10100 }
10101}
10102impl serde::Serialize for ListIcebergTablesResponse {
10103 #[allow(deprecated)]
10104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10105 where
10106 S: serde::Serializer,
10107 {
10108 use serde::ser::SerializeStruct;
10109 let mut len = 0;
10110 if !self.iceberg_tables.is_empty() {
10111 len += 1;
10112 }
10113 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
10114 if !self.iceberg_tables.is_empty() {
10115 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
10116 }
10117 struct_ser.end()
10118 }
10119}
10120impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
10121 #[allow(deprecated)]
10122 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10123 where
10124 D: serde::Deserializer<'de>,
10125 {
10126 const FIELDS: &[&str] = &[
10127 "iceberg_tables",
10128 "icebergTables",
10129 ];
10130
10131 #[allow(clippy::enum_variant_names)]
10132 enum GeneratedField {
10133 IcebergTables,
10134 }
10135 impl<'de> serde::Deserialize<'de> for GeneratedField {
10136 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10137 where
10138 D: serde::Deserializer<'de>,
10139 {
10140 struct GeneratedVisitor;
10141
10142 impl serde::de::Visitor<'_> for GeneratedVisitor {
10143 type Value = GeneratedField;
10144
10145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10146 write!(formatter, "expected one of: {:?}", &FIELDS)
10147 }
10148
10149 #[allow(unused_variables)]
10150 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10151 where
10152 E: serde::de::Error,
10153 {
10154 match value {
10155 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
10156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10157 }
10158 }
10159 }
10160 deserializer.deserialize_identifier(GeneratedVisitor)
10161 }
10162 }
10163 struct GeneratedVisitor;
10164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10165 type Value = ListIcebergTablesResponse;
10166
10167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10168 formatter.write_str("struct meta.ListIcebergTablesResponse")
10169 }
10170
10171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
10172 where
10173 V: serde::de::MapAccess<'de>,
10174 {
10175 let mut iceberg_tables__ = None;
10176 while let Some(k) = map_.next_key()? {
10177 match k {
10178 GeneratedField::IcebergTables => {
10179 if iceberg_tables__.is_some() {
10180 return Err(serde::de::Error::duplicate_field("icebergTables"));
10181 }
10182 iceberg_tables__ = Some(map_.next_value()?);
10183 }
10184 }
10185 }
10186 Ok(ListIcebergTablesResponse {
10187 iceberg_tables: iceberg_tables__.unwrap_or_default(),
10188 })
10189 }
10190 }
10191 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
10192 }
10193}
10194impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
10195 #[allow(deprecated)]
10196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10197 where
10198 S: serde::Serializer,
10199 {
10200 use serde::ser::SerializeStruct;
10201 let mut len = 0;
10202 if !self.catalog_name.is_empty() {
10203 len += 1;
10204 }
10205 if !self.table_namespace.is_empty() {
10206 len += 1;
10207 }
10208 if !self.table_name.is_empty() {
10209 len += 1;
10210 }
10211 if self.metadata_location.is_some() {
10212 len += 1;
10213 }
10214 if self.previous_metadata_location.is_some() {
10215 len += 1;
10216 }
10217 if self.iceberg_type.is_some() {
10218 len += 1;
10219 }
10220 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
10221 if !self.catalog_name.is_empty() {
10222 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
10223 }
10224 if !self.table_namespace.is_empty() {
10225 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
10226 }
10227 if !self.table_name.is_empty() {
10228 struct_ser.serialize_field("tableName", &self.table_name)?;
10229 }
10230 if let Some(v) = self.metadata_location.as_ref() {
10231 struct_ser.serialize_field("metadataLocation", v)?;
10232 }
10233 if let Some(v) = self.previous_metadata_location.as_ref() {
10234 struct_ser.serialize_field("previousMetadataLocation", v)?;
10235 }
10236 if let Some(v) = self.iceberg_type.as_ref() {
10237 struct_ser.serialize_field("icebergType", v)?;
10238 }
10239 struct_ser.end()
10240 }
10241}
10242impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
10243 #[allow(deprecated)]
10244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10245 where
10246 D: serde::Deserializer<'de>,
10247 {
10248 const FIELDS: &[&str] = &[
10249 "catalog_name",
10250 "catalogName",
10251 "table_namespace",
10252 "tableNamespace",
10253 "table_name",
10254 "tableName",
10255 "metadata_location",
10256 "metadataLocation",
10257 "previous_metadata_location",
10258 "previousMetadataLocation",
10259 "iceberg_type",
10260 "icebergType",
10261 ];
10262
10263 #[allow(clippy::enum_variant_names)]
10264 enum GeneratedField {
10265 CatalogName,
10266 TableNamespace,
10267 TableName,
10268 MetadataLocation,
10269 PreviousMetadataLocation,
10270 IcebergType,
10271 }
10272 impl<'de> serde::Deserialize<'de> for GeneratedField {
10273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10274 where
10275 D: serde::Deserializer<'de>,
10276 {
10277 struct GeneratedVisitor;
10278
10279 impl serde::de::Visitor<'_> for GeneratedVisitor {
10280 type Value = GeneratedField;
10281
10282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10283 write!(formatter, "expected one of: {:?}", &FIELDS)
10284 }
10285
10286 #[allow(unused_variables)]
10287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10288 where
10289 E: serde::de::Error,
10290 {
10291 match value {
10292 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
10293 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
10294 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10295 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
10296 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
10297 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
10298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10299 }
10300 }
10301 }
10302 deserializer.deserialize_identifier(GeneratedVisitor)
10303 }
10304 }
10305 struct GeneratedVisitor;
10306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10307 type Value = list_iceberg_tables_response::IcebergTable;
10308
10309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10310 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
10311 }
10312
10313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
10314 where
10315 V: serde::de::MapAccess<'de>,
10316 {
10317 let mut catalog_name__ = None;
10318 let mut table_namespace__ = None;
10319 let mut table_name__ = None;
10320 let mut metadata_location__ = None;
10321 let mut previous_metadata_location__ = None;
10322 let mut iceberg_type__ = None;
10323 while let Some(k) = map_.next_key()? {
10324 match k {
10325 GeneratedField::CatalogName => {
10326 if catalog_name__.is_some() {
10327 return Err(serde::de::Error::duplicate_field("catalogName"));
10328 }
10329 catalog_name__ = Some(map_.next_value()?);
10330 }
10331 GeneratedField::TableNamespace => {
10332 if table_namespace__.is_some() {
10333 return Err(serde::de::Error::duplicate_field("tableNamespace"));
10334 }
10335 table_namespace__ = Some(map_.next_value()?);
10336 }
10337 GeneratedField::TableName => {
10338 if table_name__.is_some() {
10339 return Err(serde::de::Error::duplicate_field("tableName"));
10340 }
10341 table_name__ = Some(map_.next_value()?);
10342 }
10343 GeneratedField::MetadataLocation => {
10344 if metadata_location__.is_some() {
10345 return Err(serde::de::Error::duplicate_field("metadataLocation"));
10346 }
10347 metadata_location__ = map_.next_value()?;
10348 }
10349 GeneratedField::PreviousMetadataLocation => {
10350 if previous_metadata_location__.is_some() {
10351 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
10352 }
10353 previous_metadata_location__ = map_.next_value()?;
10354 }
10355 GeneratedField::IcebergType => {
10356 if iceberg_type__.is_some() {
10357 return Err(serde::de::Error::duplicate_field("icebergType"));
10358 }
10359 iceberg_type__ = map_.next_value()?;
10360 }
10361 }
10362 }
10363 Ok(list_iceberg_tables_response::IcebergTable {
10364 catalog_name: catalog_name__.unwrap_or_default(),
10365 table_namespace: table_namespace__.unwrap_or_default(),
10366 table_name: table_name__.unwrap_or_default(),
10367 metadata_location: metadata_location__,
10368 previous_metadata_location: previous_metadata_location__,
10369 iceberg_type: iceberg_type__,
10370 })
10371 }
10372 }
10373 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
10374 }
10375}
10376impl serde::Serialize for ListObjectDependenciesRequest {
10377 #[allow(deprecated)]
10378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10379 where
10380 S: serde::Serializer,
10381 {
10382 use serde::ser::SerializeStruct;
10383 let len = 0;
10384 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
10385 struct_ser.end()
10386 }
10387}
10388impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
10389 #[allow(deprecated)]
10390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10391 where
10392 D: serde::Deserializer<'de>,
10393 {
10394 const FIELDS: &[&str] = &[
10395 ];
10396
10397 #[allow(clippy::enum_variant_names)]
10398 enum GeneratedField {
10399 }
10400 impl<'de> serde::Deserialize<'de> for GeneratedField {
10401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10402 where
10403 D: serde::Deserializer<'de>,
10404 {
10405 struct GeneratedVisitor;
10406
10407 impl serde::de::Visitor<'_> for GeneratedVisitor {
10408 type Value = GeneratedField;
10409
10410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10411 write!(formatter, "expected one of: {:?}", &FIELDS)
10412 }
10413
10414 #[allow(unused_variables)]
10415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10416 where
10417 E: serde::de::Error,
10418 {
10419 Err(serde::de::Error::unknown_field(value, FIELDS))
10420 }
10421 }
10422 deserializer.deserialize_identifier(GeneratedVisitor)
10423 }
10424 }
10425 struct GeneratedVisitor;
10426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10427 type Value = ListObjectDependenciesRequest;
10428
10429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10430 formatter.write_str("struct meta.ListObjectDependenciesRequest")
10431 }
10432
10433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
10434 where
10435 V: serde::de::MapAccess<'de>,
10436 {
10437 while map_.next_key::<GeneratedField>()?.is_some() {
10438 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10439 }
10440 Ok(ListObjectDependenciesRequest {
10441 })
10442 }
10443 }
10444 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
10445 }
10446}
10447impl serde::Serialize for ListObjectDependenciesResponse {
10448 #[allow(deprecated)]
10449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10450 where
10451 S: serde::Serializer,
10452 {
10453 use serde::ser::SerializeStruct;
10454 let mut len = 0;
10455 if !self.dependencies.is_empty() {
10456 len += 1;
10457 }
10458 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
10459 if !self.dependencies.is_empty() {
10460 struct_ser.serialize_field("dependencies", &self.dependencies)?;
10461 }
10462 struct_ser.end()
10463 }
10464}
10465impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
10466 #[allow(deprecated)]
10467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10468 where
10469 D: serde::Deserializer<'de>,
10470 {
10471 const FIELDS: &[&str] = &[
10472 "dependencies",
10473 ];
10474
10475 #[allow(clippy::enum_variant_names)]
10476 enum GeneratedField {
10477 Dependencies,
10478 }
10479 impl<'de> serde::Deserialize<'de> for GeneratedField {
10480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10481 where
10482 D: serde::Deserializer<'de>,
10483 {
10484 struct GeneratedVisitor;
10485
10486 impl serde::de::Visitor<'_> for GeneratedVisitor {
10487 type Value = GeneratedField;
10488
10489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10490 write!(formatter, "expected one of: {:?}", &FIELDS)
10491 }
10492
10493 #[allow(unused_variables)]
10494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10495 where
10496 E: serde::de::Error,
10497 {
10498 match value {
10499 "dependencies" => Ok(GeneratedField::Dependencies),
10500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10501 }
10502 }
10503 }
10504 deserializer.deserialize_identifier(GeneratedVisitor)
10505 }
10506 }
10507 struct GeneratedVisitor;
10508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10509 type Value = ListObjectDependenciesResponse;
10510
10511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10512 formatter.write_str("struct meta.ListObjectDependenciesResponse")
10513 }
10514
10515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
10516 where
10517 V: serde::de::MapAccess<'de>,
10518 {
10519 let mut dependencies__ = None;
10520 while let Some(k) = map_.next_key()? {
10521 match k {
10522 GeneratedField::Dependencies => {
10523 if dependencies__.is_some() {
10524 return Err(serde::de::Error::duplicate_field("dependencies"));
10525 }
10526 dependencies__ = Some(map_.next_value()?);
10527 }
10528 }
10529 }
10530 Ok(ListObjectDependenciesResponse {
10531 dependencies: dependencies__.unwrap_or_default(),
10532 })
10533 }
10534 }
10535 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
10536 }
10537}
10538impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
10539 #[allow(deprecated)]
10540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10541 where
10542 S: serde::Serializer,
10543 {
10544 use serde::ser::SerializeStruct;
10545 let mut len = 0;
10546 if self.object_id != 0 {
10547 len += 1;
10548 }
10549 if self.referenced_object_id != 0 {
10550 len += 1;
10551 }
10552 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
10553 if self.object_id != 0 {
10554 struct_ser.serialize_field("objectId", &self.object_id)?;
10555 }
10556 if self.referenced_object_id != 0 {
10557 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
10558 }
10559 struct_ser.end()
10560 }
10561}
10562impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
10563 #[allow(deprecated)]
10564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10565 where
10566 D: serde::Deserializer<'de>,
10567 {
10568 const FIELDS: &[&str] = &[
10569 "object_id",
10570 "objectId",
10571 "referenced_object_id",
10572 "referencedObjectId",
10573 ];
10574
10575 #[allow(clippy::enum_variant_names)]
10576 enum GeneratedField {
10577 ObjectId,
10578 ReferencedObjectId,
10579 }
10580 impl<'de> serde::Deserialize<'de> for GeneratedField {
10581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10582 where
10583 D: serde::Deserializer<'de>,
10584 {
10585 struct GeneratedVisitor;
10586
10587 impl serde::de::Visitor<'_> for GeneratedVisitor {
10588 type Value = GeneratedField;
10589
10590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10591 write!(formatter, "expected one of: {:?}", &FIELDS)
10592 }
10593
10594 #[allow(unused_variables)]
10595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10596 where
10597 E: serde::de::Error,
10598 {
10599 match value {
10600 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
10601 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
10602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10603 }
10604 }
10605 }
10606 deserializer.deserialize_identifier(GeneratedVisitor)
10607 }
10608 }
10609 struct GeneratedVisitor;
10610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10611 type Value = list_object_dependencies_response::ObjectDependencies;
10612
10613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10614 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
10615 }
10616
10617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
10618 where
10619 V: serde::de::MapAccess<'de>,
10620 {
10621 let mut object_id__ = None;
10622 let mut referenced_object_id__ = None;
10623 while let Some(k) = map_.next_key()? {
10624 match k {
10625 GeneratedField::ObjectId => {
10626 if object_id__.is_some() {
10627 return Err(serde::de::Error::duplicate_field("objectId"));
10628 }
10629 object_id__ =
10630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10631 ;
10632 }
10633 GeneratedField::ReferencedObjectId => {
10634 if referenced_object_id__.is_some() {
10635 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
10636 }
10637 referenced_object_id__ =
10638 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10639 ;
10640 }
10641 }
10642 }
10643 Ok(list_object_dependencies_response::ObjectDependencies {
10644 object_id: object_id__.unwrap_or_default(),
10645 referenced_object_id: referenced_object_id__.unwrap_or_default(),
10646 })
10647 }
10648 }
10649 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
10650 }
10651}
10652impl serde::Serialize for ListRateLimitsRequest {
10653 #[allow(deprecated)]
10654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10655 where
10656 S: serde::Serializer,
10657 {
10658 use serde::ser::SerializeStruct;
10659 let len = 0;
10660 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10661 struct_ser.end()
10662 }
10663}
10664impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10665 #[allow(deprecated)]
10666 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10667 where
10668 D: serde::Deserializer<'de>,
10669 {
10670 const FIELDS: &[&str] = &[
10671 ];
10672
10673 #[allow(clippy::enum_variant_names)]
10674 enum GeneratedField {
10675 }
10676 impl<'de> serde::Deserialize<'de> for GeneratedField {
10677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10678 where
10679 D: serde::Deserializer<'de>,
10680 {
10681 struct GeneratedVisitor;
10682
10683 impl serde::de::Visitor<'_> for GeneratedVisitor {
10684 type Value = GeneratedField;
10685
10686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10687 write!(formatter, "expected one of: {:?}", &FIELDS)
10688 }
10689
10690 #[allow(unused_variables)]
10691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10692 where
10693 E: serde::de::Error,
10694 {
10695 Err(serde::de::Error::unknown_field(value, FIELDS))
10696 }
10697 }
10698 deserializer.deserialize_identifier(GeneratedVisitor)
10699 }
10700 }
10701 struct GeneratedVisitor;
10702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10703 type Value = ListRateLimitsRequest;
10704
10705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10706 formatter.write_str("struct meta.ListRateLimitsRequest")
10707 }
10708
10709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10710 where
10711 V: serde::de::MapAccess<'de>,
10712 {
10713 while map_.next_key::<GeneratedField>()?.is_some() {
10714 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10715 }
10716 Ok(ListRateLimitsRequest {
10717 })
10718 }
10719 }
10720 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10721 }
10722}
10723impl serde::Serialize for ListRateLimitsResponse {
10724 #[allow(deprecated)]
10725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10726 where
10727 S: serde::Serializer,
10728 {
10729 use serde::ser::SerializeStruct;
10730 let mut len = 0;
10731 if !self.rate_limits.is_empty() {
10732 len += 1;
10733 }
10734 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10735 if !self.rate_limits.is_empty() {
10736 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10737 }
10738 struct_ser.end()
10739 }
10740}
10741impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10742 #[allow(deprecated)]
10743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10744 where
10745 D: serde::Deserializer<'de>,
10746 {
10747 const FIELDS: &[&str] = &[
10748 "rate_limits",
10749 "rateLimits",
10750 ];
10751
10752 #[allow(clippy::enum_variant_names)]
10753 enum GeneratedField {
10754 RateLimits,
10755 }
10756 impl<'de> serde::Deserialize<'de> for GeneratedField {
10757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10758 where
10759 D: serde::Deserializer<'de>,
10760 {
10761 struct GeneratedVisitor;
10762
10763 impl serde::de::Visitor<'_> for GeneratedVisitor {
10764 type Value = GeneratedField;
10765
10766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10767 write!(formatter, "expected one of: {:?}", &FIELDS)
10768 }
10769
10770 #[allow(unused_variables)]
10771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10772 where
10773 E: serde::de::Error,
10774 {
10775 match value {
10776 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10778 }
10779 }
10780 }
10781 deserializer.deserialize_identifier(GeneratedVisitor)
10782 }
10783 }
10784 struct GeneratedVisitor;
10785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10786 type Value = ListRateLimitsResponse;
10787
10788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10789 formatter.write_str("struct meta.ListRateLimitsResponse")
10790 }
10791
10792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10793 where
10794 V: serde::de::MapAccess<'de>,
10795 {
10796 let mut rate_limits__ = None;
10797 while let Some(k) = map_.next_key()? {
10798 match k {
10799 GeneratedField::RateLimits => {
10800 if rate_limits__.is_some() {
10801 return Err(serde::de::Error::duplicate_field("rateLimits"));
10802 }
10803 rate_limits__ = Some(map_.next_value()?);
10804 }
10805 }
10806 }
10807 Ok(ListRateLimitsResponse {
10808 rate_limits: rate_limits__.unwrap_or_default(),
10809 })
10810 }
10811 }
10812 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10813 }
10814}
10815impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10816 #[allow(deprecated)]
10817 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10818 where
10819 S: serde::Serializer,
10820 {
10821 use serde::ser::SerializeStruct;
10822 let mut len = 0;
10823 if self.fragment_id != 0 {
10824 len += 1;
10825 }
10826 if self.job_id != 0 {
10827 len += 1;
10828 }
10829 if self.fragment_type_mask != 0 {
10830 len += 1;
10831 }
10832 if self.rate_limit != 0 {
10833 len += 1;
10834 }
10835 if !self.node_name.is_empty() {
10836 len += 1;
10837 }
10838 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10839 if self.fragment_id != 0 {
10840 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10841 }
10842 if self.job_id != 0 {
10843 struct_ser.serialize_field("jobId", &self.job_id)?;
10844 }
10845 if self.fragment_type_mask != 0 {
10846 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10847 }
10848 if self.rate_limit != 0 {
10849 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10850 }
10851 if !self.node_name.is_empty() {
10852 struct_ser.serialize_field("nodeName", &self.node_name)?;
10853 }
10854 struct_ser.end()
10855 }
10856}
10857impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10858 #[allow(deprecated)]
10859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10860 where
10861 D: serde::Deserializer<'de>,
10862 {
10863 const FIELDS: &[&str] = &[
10864 "fragment_id",
10865 "fragmentId",
10866 "job_id",
10867 "jobId",
10868 "fragment_type_mask",
10869 "fragmentTypeMask",
10870 "rate_limit",
10871 "rateLimit",
10872 "node_name",
10873 "nodeName",
10874 ];
10875
10876 #[allow(clippy::enum_variant_names)]
10877 enum GeneratedField {
10878 FragmentId,
10879 JobId,
10880 FragmentTypeMask,
10881 RateLimit,
10882 NodeName,
10883 }
10884 impl<'de> serde::Deserialize<'de> for GeneratedField {
10885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10886 where
10887 D: serde::Deserializer<'de>,
10888 {
10889 struct GeneratedVisitor;
10890
10891 impl serde::de::Visitor<'_> for GeneratedVisitor {
10892 type Value = GeneratedField;
10893
10894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10895 write!(formatter, "expected one of: {:?}", &FIELDS)
10896 }
10897
10898 #[allow(unused_variables)]
10899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10900 where
10901 E: serde::de::Error,
10902 {
10903 match value {
10904 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10905 "jobId" | "job_id" => Ok(GeneratedField::JobId),
10906 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10907 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10908 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10910 }
10911 }
10912 }
10913 deserializer.deserialize_identifier(GeneratedVisitor)
10914 }
10915 }
10916 struct GeneratedVisitor;
10917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10918 type Value = list_rate_limits_response::RateLimitInfo;
10919
10920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10921 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10922 }
10923
10924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10925 where
10926 V: serde::de::MapAccess<'de>,
10927 {
10928 let mut fragment_id__ = None;
10929 let mut job_id__ = None;
10930 let mut fragment_type_mask__ = None;
10931 let mut rate_limit__ = None;
10932 let mut node_name__ = None;
10933 while let Some(k) = map_.next_key()? {
10934 match k {
10935 GeneratedField::FragmentId => {
10936 if fragment_id__.is_some() {
10937 return Err(serde::de::Error::duplicate_field("fragmentId"));
10938 }
10939 fragment_id__ =
10940 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10941 ;
10942 }
10943 GeneratedField::JobId => {
10944 if job_id__.is_some() {
10945 return Err(serde::de::Error::duplicate_field("jobId"));
10946 }
10947 job_id__ =
10948 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10949 ;
10950 }
10951 GeneratedField::FragmentTypeMask => {
10952 if fragment_type_mask__.is_some() {
10953 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10954 }
10955 fragment_type_mask__ =
10956 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10957 ;
10958 }
10959 GeneratedField::RateLimit => {
10960 if rate_limit__.is_some() {
10961 return Err(serde::de::Error::duplicate_field("rateLimit"));
10962 }
10963 rate_limit__ =
10964 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10965 ;
10966 }
10967 GeneratedField::NodeName => {
10968 if node_name__.is_some() {
10969 return Err(serde::de::Error::duplicate_field("nodeName"));
10970 }
10971 node_name__ = Some(map_.next_value()?);
10972 }
10973 }
10974 }
10975 Ok(list_rate_limits_response::RateLimitInfo {
10976 fragment_id: fragment_id__.unwrap_or_default(),
10977 job_id: job_id__.unwrap_or_default(),
10978 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10979 rate_limit: rate_limit__.unwrap_or_default(),
10980 node_name: node_name__.unwrap_or_default(),
10981 })
10982 }
10983 }
10984 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10985 }
10986}
10987impl serde::Serialize for ListRefreshTableStatesRequest {
10988 #[allow(deprecated)]
10989 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10990 where
10991 S: serde::Serializer,
10992 {
10993 use serde::ser::SerializeStruct;
10994 let len = 0;
10995 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
10996 struct_ser.end()
10997 }
10998}
10999impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11000 #[allow(deprecated)]
11001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11002 where
11003 D: serde::Deserializer<'de>,
11004 {
11005 const FIELDS: &[&str] = &[
11006 ];
11007
11008 #[allow(clippy::enum_variant_names)]
11009 enum GeneratedField {
11010 }
11011 impl<'de> serde::Deserialize<'de> for GeneratedField {
11012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11013 where
11014 D: serde::Deserializer<'de>,
11015 {
11016 struct GeneratedVisitor;
11017
11018 impl serde::de::Visitor<'_> for GeneratedVisitor {
11019 type Value = GeneratedField;
11020
11021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11022 write!(formatter, "expected one of: {:?}", &FIELDS)
11023 }
11024
11025 #[allow(unused_variables)]
11026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11027 where
11028 E: serde::de::Error,
11029 {
11030 Err(serde::de::Error::unknown_field(value, FIELDS))
11031 }
11032 }
11033 deserializer.deserialize_identifier(GeneratedVisitor)
11034 }
11035 }
11036 struct GeneratedVisitor;
11037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11038 type Value = ListRefreshTableStatesRequest;
11039
11040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11041 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11042 }
11043
11044 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11045 where
11046 V: serde::de::MapAccess<'de>,
11047 {
11048 while map_.next_key::<GeneratedField>()?.is_some() {
11049 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11050 }
11051 Ok(ListRefreshTableStatesRequest {
11052 })
11053 }
11054 }
11055 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11056 }
11057}
11058impl serde::Serialize for ListRefreshTableStatesResponse {
11059 #[allow(deprecated)]
11060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11061 where
11062 S: serde::Serializer,
11063 {
11064 use serde::ser::SerializeStruct;
11065 let mut len = 0;
11066 if !self.states.is_empty() {
11067 len += 1;
11068 }
11069 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11070 if !self.states.is_empty() {
11071 struct_ser.serialize_field("states", &self.states)?;
11072 }
11073 struct_ser.end()
11074 }
11075}
11076impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11077 #[allow(deprecated)]
11078 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11079 where
11080 D: serde::Deserializer<'de>,
11081 {
11082 const FIELDS: &[&str] = &[
11083 "states",
11084 ];
11085
11086 #[allow(clippy::enum_variant_names)]
11087 enum GeneratedField {
11088 States,
11089 }
11090 impl<'de> serde::Deserialize<'de> for GeneratedField {
11091 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11092 where
11093 D: serde::Deserializer<'de>,
11094 {
11095 struct GeneratedVisitor;
11096
11097 impl serde::de::Visitor<'_> for GeneratedVisitor {
11098 type Value = GeneratedField;
11099
11100 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11101 write!(formatter, "expected one of: {:?}", &FIELDS)
11102 }
11103
11104 #[allow(unused_variables)]
11105 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11106 where
11107 E: serde::de::Error,
11108 {
11109 match value {
11110 "states" => Ok(GeneratedField::States),
11111 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11112 }
11113 }
11114 }
11115 deserializer.deserialize_identifier(GeneratedVisitor)
11116 }
11117 }
11118 struct GeneratedVisitor;
11119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11120 type Value = ListRefreshTableStatesResponse;
11121
11122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11123 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11124 }
11125
11126 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11127 where
11128 V: serde::de::MapAccess<'de>,
11129 {
11130 let mut states__ = None;
11131 while let Some(k) = map_.next_key()? {
11132 match k {
11133 GeneratedField::States => {
11134 if states__.is_some() {
11135 return Err(serde::de::Error::duplicate_field("states"));
11136 }
11137 states__ = Some(map_.next_value()?);
11138 }
11139 }
11140 }
11141 Ok(ListRefreshTableStatesResponse {
11142 states: states__.unwrap_or_default(),
11143 })
11144 }
11145 }
11146 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11147 }
11148}
11149impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11150 #[allow(deprecated)]
11151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11152 where
11153 S: serde::Serializer,
11154 {
11155 use serde::ser::SerializeStruct;
11156 let mut len = 0;
11157 if self.table_id != 0 {
11158 len += 1;
11159 }
11160 if !self.current_status.is_empty() {
11161 len += 1;
11162 }
11163 if self.last_trigger_time.is_some() {
11164 len += 1;
11165 }
11166 if self.trigger_interval_secs.is_some() {
11167 len += 1;
11168 }
11169 if self.last_success_time.is_some() {
11170 len += 1;
11171 }
11172 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11173 if self.table_id != 0 {
11174 struct_ser.serialize_field("tableId", &self.table_id)?;
11175 }
11176 if !self.current_status.is_empty() {
11177 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11178 }
11179 if let Some(v) = self.last_trigger_time.as_ref() {
11180 struct_ser.serialize_field("lastTriggerTime", v)?;
11181 }
11182 if let Some(v) = self.trigger_interval_secs.as_ref() {
11183 #[allow(clippy::needless_borrow)]
11184 #[allow(clippy::needless_borrows_for_generic_args)]
11185 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11186 }
11187 if let Some(v) = self.last_success_time.as_ref() {
11188 struct_ser.serialize_field("lastSuccessTime", v)?;
11189 }
11190 struct_ser.end()
11191 }
11192}
11193impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11194 #[allow(deprecated)]
11195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11196 where
11197 D: serde::Deserializer<'de>,
11198 {
11199 const FIELDS: &[&str] = &[
11200 "table_id",
11201 "tableId",
11202 "current_status",
11203 "currentStatus",
11204 "last_trigger_time",
11205 "lastTriggerTime",
11206 "trigger_interval_secs",
11207 "triggerIntervalSecs",
11208 "last_success_time",
11209 "lastSuccessTime",
11210 ];
11211
11212 #[allow(clippy::enum_variant_names)]
11213 enum GeneratedField {
11214 TableId,
11215 CurrentStatus,
11216 LastTriggerTime,
11217 TriggerIntervalSecs,
11218 LastSuccessTime,
11219 }
11220 impl<'de> serde::Deserialize<'de> for GeneratedField {
11221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11222 where
11223 D: serde::Deserializer<'de>,
11224 {
11225 struct GeneratedVisitor;
11226
11227 impl serde::de::Visitor<'_> for GeneratedVisitor {
11228 type Value = GeneratedField;
11229
11230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11231 write!(formatter, "expected one of: {:?}", &FIELDS)
11232 }
11233
11234 #[allow(unused_variables)]
11235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11236 where
11237 E: serde::de::Error,
11238 {
11239 match value {
11240 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11241 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11242 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11243 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11244 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11246 }
11247 }
11248 }
11249 deserializer.deserialize_identifier(GeneratedVisitor)
11250 }
11251 }
11252 struct GeneratedVisitor;
11253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11254 type Value = list_refresh_table_states_response::RefreshTableState;
11255
11256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11257 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11258 }
11259
11260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11261 where
11262 V: serde::de::MapAccess<'de>,
11263 {
11264 let mut table_id__ = None;
11265 let mut current_status__ = None;
11266 let mut last_trigger_time__ = None;
11267 let mut trigger_interval_secs__ = None;
11268 let mut last_success_time__ = None;
11269 while let Some(k) = map_.next_key()? {
11270 match k {
11271 GeneratedField::TableId => {
11272 if table_id__.is_some() {
11273 return Err(serde::de::Error::duplicate_field("tableId"));
11274 }
11275 table_id__ =
11276 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11277 ;
11278 }
11279 GeneratedField::CurrentStatus => {
11280 if current_status__.is_some() {
11281 return Err(serde::de::Error::duplicate_field("currentStatus"));
11282 }
11283 current_status__ = Some(map_.next_value()?);
11284 }
11285 GeneratedField::LastTriggerTime => {
11286 if last_trigger_time__.is_some() {
11287 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11288 }
11289 last_trigger_time__ = map_.next_value()?;
11290 }
11291 GeneratedField::TriggerIntervalSecs => {
11292 if trigger_interval_secs__.is_some() {
11293 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11294 }
11295 trigger_interval_secs__ =
11296 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11297 ;
11298 }
11299 GeneratedField::LastSuccessTime => {
11300 if last_success_time__.is_some() {
11301 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11302 }
11303 last_success_time__ = map_.next_value()?;
11304 }
11305 }
11306 }
11307 Ok(list_refresh_table_states_response::RefreshTableState {
11308 table_id: table_id__.unwrap_or_default(),
11309 current_status: current_status__.unwrap_or_default(),
11310 last_trigger_time: last_trigger_time__,
11311 trigger_interval_secs: trigger_interval_secs__,
11312 last_success_time: last_success_time__,
11313 })
11314 }
11315 }
11316 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11317 }
11318}
11319impl serde::Serialize for ListStreamingJobStatesRequest {
11320 #[allow(deprecated)]
11321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11322 where
11323 S: serde::Serializer,
11324 {
11325 use serde::ser::SerializeStruct;
11326 let len = 0;
11327 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
11328 struct_ser.end()
11329 }
11330}
11331impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
11332 #[allow(deprecated)]
11333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11334 where
11335 D: serde::Deserializer<'de>,
11336 {
11337 const FIELDS: &[&str] = &[
11338 ];
11339
11340 #[allow(clippy::enum_variant_names)]
11341 enum GeneratedField {
11342 }
11343 impl<'de> serde::Deserialize<'de> for GeneratedField {
11344 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11345 where
11346 D: serde::Deserializer<'de>,
11347 {
11348 struct GeneratedVisitor;
11349
11350 impl serde::de::Visitor<'_> for GeneratedVisitor {
11351 type Value = GeneratedField;
11352
11353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11354 write!(formatter, "expected one of: {:?}", &FIELDS)
11355 }
11356
11357 #[allow(unused_variables)]
11358 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11359 where
11360 E: serde::de::Error,
11361 {
11362 Err(serde::de::Error::unknown_field(value, FIELDS))
11363 }
11364 }
11365 deserializer.deserialize_identifier(GeneratedVisitor)
11366 }
11367 }
11368 struct GeneratedVisitor;
11369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11370 type Value = ListStreamingJobStatesRequest;
11371
11372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11373 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
11374 }
11375
11376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
11377 where
11378 V: serde::de::MapAccess<'de>,
11379 {
11380 while map_.next_key::<GeneratedField>()?.is_some() {
11381 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11382 }
11383 Ok(ListStreamingJobStatesRequest {
11384 })
11385 }
11386 }
11387 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
11388 }
11389}
11390impl serde::Serialize for ListStreamingJobStatesResponse {
11391 #[allow(deprecated)]
11392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11393 where
11394 S: serde::Serializer,
11395 {
11396 use serde::ser::SerializeStruct;
11397 let mut len = 0;
11398 if !self.states.is_empty() {
11399 len += 1;
11400 }
11401 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
11402 if !self.states.is_empty() {
11403 struct_ser.serialize_field("states", &self.states)?;
11404 }
11405 struct_ser.end()
11406 }
11407}
11408impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
11409 #[allow(deprecated)]
11410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11411 where
11412 D: serde::Deserializer<'de>,
11413 {
11414 const FIELDS: &[&str] = &[
11415 "states",
11416 ];
11417
11418 #[allow(clippy::enum_variant_names)]
11419 enum GeneratedField {
11420 States,
11421 }
11422 impl<'de> serde::Deserialize<'de> for GeneratedField {
11423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11424 where
11425 D: serde::Deserializer<'de>,
11426 {
11427 struct GeneratedVisitor;
11428
11429 impl serde::de::Visitor<'_> for GeneratedVisitor {
11430 type Value = GeneratedField;
11431
11432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11433 write!(formatter, "expected one of: {:?}", &FIELDS)
11434 }
11435
11436 #[allow(unused_variables)]
11437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11438 where
11439 E: serde::de::Error,
11440 {
11441 match value {
11442 "states" => Ok(GeneratedField::States),
11443 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11444 }
11445 }
11446 }
11447 deserializer.deserialize_identifier(GeneratedVisitor)
11448 }
11449 }
11450 struct GeneratedVisitor;
11451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11452 type Value = ListStreamingJobStatesResponse;
11453
11454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11455 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
11456 }
11457
11458 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
11459 where
11460 V: serde::de::MapAccess<'de>,
11461 {
11462 let mut states__ = None;
11463 while let Some(k) = map_.next_key()? {
11464 match k {
11465 GeneratedField::States => {
11466 if states__.is_some() {
11467 return Err(serde::de::Error::duplicate_field("states"));
11468 }
11469 states__ = Some(map_.next_value()?);
11470 }
11471 }
11472 }
11473 Ok(ListStreamingJobStatesResponse {
11474 states: states__.unwrap_or_default(),
11475 })
11476 }
11477 }
11478 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
11479 }
11480}
11481impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
11482 #[allow(deprecated)]
11483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11484 where
11485 S: serde::Serializer,
11486 {
11487 use serde::ser::SerializeStruct;
11488 let mut len = 0;
11489 if self.table_id != 0 {
11490 len += 1;
11491 }
11492 if self.state != 0 {
11493 len += 1;
11494 }
11495 if self.parallelism.is_some() {
11496 len += 1;
11497 }
11498 if self.max_parallelism != 0 {
11499 len += 1;
11500 }
11501 if !self.name.is_empty() {
11502 len += 1;
11503 }
11504 if !self.resource_group.is_empty() {
11505 len += 1;
11506 }
11507 if !self.config_override.is_empty() {
11508 len += 1;
11509 }
11510 if self.database_id != 0 {
11511 len += 1;
11512 }
11513 if self.schema_id != 0 {
11514 len += 1;
11515 }
11516 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
11517 if self.table_id != 0 {
11518 struct_ser.serialize_field("tableId", &self.table_id)?;
11519 }
11520 if self.state != 0 {
11521 let v = table_fragments::State::try_from(self.state)
11522 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
11523 struct_ser.serialize_field("state", &v)?;
11524 }
11525 if let Some(v) = self.parallelism.as_ref() {
11526 struct_ser.serialize_field("parallelism", v)?;
11527 }
11528 if self.max_parallelism != 0 {
11529 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11530 }
11531 if !self.name.is_empty() {
11532 struct_ser.serialize_field("name", &self.name)?;
11533 }
11534 if !self.resource_group.is_empty() {
11535 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
11536 }
11537 if !self.config_override.is_empty() {
11538 struct_ser.serialize_field("configOverride", &self.config_override)?;
11539 }
11540 if self.database_id != 0 {
11541 struct_ser.serialize_field("databaseId", &self.database_id)?;
11542 }
11543 if self.schema_id != 0 {
11544 struct_ser.serialize_field("schemaId", &self.schema_id)?;
11545 }
11546 struct_ser.end()
11547 }
11548}
11549impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
11550 #[allow(deprecated)]
11551 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11552 where
11553 D: serde::Deserializer<'de>,
11554 {
11555 const FIELDS: &[&str] = &[
11556 "table_id",
11557 "tableId",
11558 "state",
11559 "parallelism",
11560 "max_parallelism",
11561 "maxParallelism",
11562 "name",
11563 "resource_group",
11564 "resourceGroup",
11565 "config_override",
11566 "configOverride",
11567 "database_id",
11568 "databaseId",
11569 "schema_id",
11570 "schemaId",
11571 ];
11572
11573 #[allow(clippy::enum_variant_names)]
11574 enum GeneratedField {
11575 TableId,
11576 State,
11577 Parallelism,
11578 MaxParallelism,
11579 Name,
11580 ResourceGroup,
11581 ConfigOverride,
11582 DatabaseId,
11583 SchemaId,
11584 }
11585 impl<'de> serde::Deserialize<'de> for GeneratedField {
11586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11587 where
11588 D: serde::Deserializer<'de>,
11589 {
11590 struct GeneratedVisitor;
11591
11592 impl serde::de::Visitor<'_> for GeneratedVisitor {
11593 type Value = GeneratedField;
11594
11595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11596 write!(formatter, "expected one of: {:?}", &FIELDS)
11597 }
11598
11599 #[allow(unused_variables)]
11600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11601 where
11602 E: serde::de::Error,
11603 {
11604 match value {
11605 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11606 "state" => Ok(GeneratedField::State),
11607 "parallelism" => Ok(GeneratedField::Parallelism),
11608 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11609 "name" => Ok(GeneratedField::Name),
11610 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
11611 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11612 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
11613 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
11614 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11615 }
11616 }
11617 }
11618 deserializer.deserialize_identifier(GeneratedVisitor)
11619 }
11620 }
11621 struct GeneratedVisitor;
11622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11623 type Value = list_streaming_job_states_response::StreamingJobState;
11624
11625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11626 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
11627 }
11628
11629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
11630 where
11631 V: serde::de::MapAccess<'de>,
11632 {
11633 let mut table_id__ = None;
11634 let mut state__ = None;
11635 let mut parallelism__ = None;
11636 let mut max_parallelism__ = None;
11637 let mut name__ = None;
11638 let mut resource_group__ = None;
11639 let mut config_override__ = None;
11640 let mut database_id__ = None;
11641 let mut schema_id__ = None;
11642 while let Some(k) = map_.next_key()? {
11643 match k {
11644 GeneratedField::TableId => {
11645 if table_id__.is_some() {
11646 return Err(serde::de::Error::duplicate_field("tableId"));
11647 }
11648 table_id__ =
11649 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11650 ;
11651 }
11652 GeneratedField::State => {
11653 if state__.is_some() {
11654 return Err(serde::de::Error::duplicate_field("state"));
11655 }
11656 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
11657 }
11658 GeneratedField::Parallelism => {
11659 if parallelism__.is_some() {
11660 return Err(serde::de::Error::duplicate_field("parallelism"));
11661 }
11662 parallelism__ = map_.next_value()?;
11663 }
11664 GeneratedField::MaxParallelism => {
11665 if max_parallelism__.is_some() {
11666 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11667 }
11668 max_parallelism__ =
11669 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11670 ;
11671 }
11672 GeneratedField::Name => {
11673 if name__.is_some() {
11674 return Err(serde::de::Error::duplicate_field("name"));
11675 }
11676 name__ = Some(map_.next_value()?);
11677 }
11678 GeneratedField::ResourceGroup => {
11679 if resource_group__.is_some() {
11680 return Err(serde::de::Error::duplicate_field("resourceGroup"));
11681 }
11682 resource_group__ = Some(map_.next_value()?);
11683 }
11684 GeneratedField::ConfigOverride => {
11685 if config_override__.is_some() {
11686 return Err(serde::de::Error::duplicate_field("configOverride"));
11687 }
11688 config_override__ = Some(map_.next_value()?);
11689 }
11690 GeneratedField::DatabaseId => {
11691 if database_id__.is_some() {
11692 return Err(serde::de::Error::duplicate_field("databaseId"));
11693 }
11694 database_id__ =
11695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11696 ;
11697 }
11698 GeneratedField::SchemaId => {
11699 if schema_id__.is_some() {
11700 return Err(serde::de::Error::duplicate_field("schemaId"));
11701 }
11702 schema_id__ =
11703 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11704 ;
11705 }
11706 }
11707 }
11708 Ok(list_streaming_job_states_response::StreamingJobState {
11709 table_id: table_id__.unwrap_or_default(),
11710 state: state__.unwrap_or_default(),
11711 parallelism: parallelism__,
11712 max_parallelism: max_parallelism__.unwrap_or_default(),
11713 name: name__.unwrap_or_default(),
11714 resource_group: resource_group__.unwrap_or_default(),
11715 config_override: config_override__.unwrap_or_default(),
11716 database_id: database_id__.unwrap_or_default(),
11717 schema_id: schema_id__.unwrap_or_default(),
11718 })
11719 }
11720 }
11721 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
11722 }
11723}
11724impl serde::Serialize for ListTableFragmentsRequest {
11725 #[allow(deprecated)]
11726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11727 where
11728 S: serde::Serializer,
11729 {
11730 use serde::ser::SerializeStruct;
11731 let mut len = 0;
11732 if !self.table_ids.is_empty() {
11733 len += 1;
11734 }
11735 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
11736 if !self.table_ids.is_empty() {
11737 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11738 }
11739 struct_ser.end()
11740 }
11741}
11742impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
11743 #[allow(deprecated)]
11744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11745 where
11746 D: serde::Deserializer<'de>,
11747 {
11748 const FIELDS: &[&str] = &[
11749 "table_ids",
11750 "tableIds",
11751 ];
11752
11753 #[allow(clippy::enum_variant_names)]
11754 enum GeneratedField {
11755 TableIds,
11756 }
11757 impl<'de> serde::Deserialize<'de> for GeneratedField {
11758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11759 where
11760 D: serde::Deserializer<'de>,
11761 {
11762 struct GeneratedVisitor;
11763
11764 impl serde::de::Visitor<'_> for GeneratedVisitor {
11765 type Value = GeneratedField;
11766
11767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11768 write!(formatter, "expected one of: {:?}", &FIELDS)
11769 }
11770
11771 #[allow(unused_variables)]
11772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11773 where
11774 E: serde::de::Error,
11775 {
11776 match value {
11777 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11779 }
11780 }
11781 }
11782 deserializer.deserialize_identifier(GeneratedVisitor)
11783 }
11784 }
11785 struct GeneratedVisitor;
11786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11787 type Value = ListTableFragmentsRequest;
11788
11789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11790 formatter.write_str("struct meta.ListTableFragmentsRequest")
11791 }
11792
11793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
11794 where
11795 V: serde::de::MapAccess<'de>,
11796 {
11797 let mut table_ids__ = None;
11798 while let Some(k) = map_.next_key()? {
11799 match k {
11800 GeneratedField::TableIds => {
11801 if table_ids__.is_some() {
11802 return Err(serde::de::Error::duplicate_field("tableIds"));
11803 }
11804 table_ids__ =
11805 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11806 .into_iter().map(|x| x.0).collect())
11807 ;
11808 }
11809 }
11810 }
11811 Ok(ListTableFragmentsRequest {
11812 table_ids: table_ids__.unwrap_or_default(),
11813 })
11814 }
11815 }
11816 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
11817 }
11818}
11819impl serde::Serialize for ListTableFragmentsResponse {
11820 #[allow(deprecated)]
11821 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11822 where
11823 S: serde::Serializer,
11824 {
11825 use serde::ser::SerializeStruct;
11826 let mut len = 0;
11827 if !self.table_fragments.is_empty() {
11828 len += 1;
11829 }
11830 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
11831 if !self.table_fragments.is_empty() {
11832 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
11833 }
11834 struct_ser.end()
11835 }
11836}
11837impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
11838 #[allow(deprecated)]
11839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11840 where
11841 D: serde::Deserializer<'de>,
11842 {
11843 const FIELDS: &[&str] = &[
11844 "table_fragments",
11845 "tableFragments",
11846 ];
11847
11848 #[allow(clippy::enum_variant_names)]
11849 enum GeneratedField {
11850 TableFragments,
11851 }
11852 impl<'de> serde::Deserialize<'de> for GeneratedField {
11853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11854 where
11855 D: serde::Deserializer<'de>,
11856 {
11857 struct GeneratedVisitor;
11858
11859 impl serde::de::Visitor<'_> for GeneratedVisitor {
11860 type Value = GeneratedField;
11861
11862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11863 write!(formatter, "expected one of: {:?}", &FIELDS)
11864 }
11865
11866 #[allow(unused_variables)]
11867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11868 where
11869 E: serde::de::Error,
11870 {
11871 match value {
11872 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
11873 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11874 }
11875 }
11876 }
11877 deserializer.deserialize_identifier(GeneratedVisitor)
11878 }
11879 }
11880 struct GeneratedVisitor;
11881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11882 type Value = ListTableFragmentsResponse;
11883
11884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11885 formatter.write_str("struct meta.ListTableFragmentsResponse")
11886 }
11887
11888 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
11889 where
11890 V: serde::de::MapAccess<'de>,
11891 {
11892 let mut table_fragments__ = None;
11893 while let Some(k) = map_.next_key()? {
11894 match k {
11895 GeneratedField::TableFragments => {
11896 if table_fragments__.is_some() {
11897 return Err(serde::de::Error::duplicate_field("tableFragments"));
11898 }
11899 table_fragments__ = Some(
11900 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11901 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11902 );
11903 }
11904 }
11905 }
11906 Ok(ListTableFragmentsResponse {
11907 table_fragments: table_fragments__.unwrap_or_default(),
11908 })
11909 }
11910 }
11911 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
11912 }
11913}
11914impl serde::Serialize for list_table_fragments_response::ActorInfo {
11915 #[allow(deprecated)]
11916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11917 where
11918 S: serde::Serializer,
11919 {
11920 use serde::ser::SerializeStruct;
11921 let mut len = 0;
11922 if self.id != 0 {
11923 len += 1;
11924 }
11925 if self.node.is_some() {
11926 len += 1;
11927 }
11928 if !self.dispatcher.is_empty() {
11929 len += 1;
11930 }
11931 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
11932 if self.id != 0 {
11933 struct_ser.serialize_field("id", &self.id)?;
11934 }
11935 if let Some(v) = self.node.as_ref() {
11936 struct_ser.serialize_field("node", v)?;
11937 }
11938 if !self.dispatcher.is_empty() {
11939 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11940 }
11941 struct_ser.end()
11942 }
11943}
11944impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
11945 #[allow(deprecated)]
11946 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11947 where
11948 D: serde::Deserializer<'de>,
11949 {
11950 const FIELDS: &[&str] = &[
11951 "id",
11952 "node",
11953 "dispatcher",
11954 ];
11955
11956 #[allow(clippy::enum_variant_names)]
11957 enum GeneratedField {
11958 Id,
11959 Node,
11960 Dispatcher,
11961 }
11962 impl<'de> serde::Deserialize<'de> for GeneratedField {
11963 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11964 where
11965 D: serde::Deserializer<'de>,
11966 {
11967 struct GeneratedVisitor;
11968
11969 impl serde::de::Visitor<'_> for GeneratedVisitor {
11970 type Value = GeneratedField;
11971
11972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11973 write!(formatter, "expected one of: {:?}", &FIELDS)
11974 }
11975
11976 #[allow(unused_variables)]
11977 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11978 where
11979 E: serde::de::Error,
11980 {
11981 match value {
11982 "id" => Ok(GeneratedField::Id),
11983 "node" => Ok(GeneratedField::Node),
11984 "dispatcher" => Ok(GeneratedField::Dispatcher),
11985 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11986 }
11987 }
11988 }
11989 deserializer.deserialize_identifier(GeneratedVisitor)
11990 }
11991 }
11992 struct GeneratedVisitor;
11993 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11994 type Value = list_table_fragments_response::ActorInfo;
11995
11996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11997 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
11998 }
11999
12000 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12001 where
12002 V: serde::de::MapAccess<'de>,
12003 {
12004 let mut id__ = None;
12005 let mut node__ = None;
12006 let mut dispatcher__ = None;
12007 while let Some(k) = map_.next_key()? {
12008 match k {
12009 GeneratedField::Id => {
12010 if id__.is_some() {
12011 return Err(serde::de::Error::duplicate_field("id"));
12012 }
12013 id__ =
12014 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12015 ;
12016 }
12017 GeneratedField::Node => {
12018 if node__.is_some() {
12019 return Err(serde::de::Error::duplicate_field("node"));
12020 }
12021 node__ = map_.next_value()?;
12022 }
12023 GeneratedField::Dispatcher => {
12024 if dispatcher__.is_some() {
12025 return Err(serde::de::Error::duplicate_field("dispatcher"));
12026 }
12027 dispatcher__ = Some(map_.next_value()?);
12028 }
12029 }
12030 }
12031 Ok(list_table_fragments_response::ActorInfo {
12032 id: id__.unwrap_or_default(),
12033 node: node__,
12034 dispatcher: dispatcher__.unwrap_or_default(),
12035 })
12036 }
12037 }
12038 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12039 }
12040}
12041impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12042 #[allow(deprecated)]
12043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12044 where
12045 S: serde::Serializer,
12046 {
12047 use serde::ser::SerializeStruct;
12048 let mut len = 0;
12049 if self.id != 0 {
12050 len += 1;
12051 }
12052 if !self.actors.is_empty() {
12053 len += 1;
12054 }
12055 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12056 if self.id != 0 {
12057 struct_ser.serialize_field("id", &self.id)?;
12058 }
12059 if !self.actors.is_empty() {
12060 struct_ser.serialize_field("actors", &self.actors)?;
12061 }
12062 struct_ser.end()
12063 }
12064}
12065impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12066 #[allow(deprecated)]
12067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12068 where
12069 D: serde::Deserializer<'de>,
12070 {
12071 const FIELDS: &[&str] = &[
12072 "id",
12073 "actors",
12074 ];
12075
12076 #[allow(clippy::enum_variant_names)]
12077 enum GeneratedField {
12078 Id,
12079 Actors,
12080 }
12081 impl<'de> serde::Deserialize<'de> for GeneratedField {
12082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12083 where
12084 D: serde::Deserializer<'de>,
12085 {
12086 struct GeneratedVisitor;
12087
12088 impl serde::de::Visitor<'_> for GeneratedVisitor {
12089 type Value = GeneratedField;
12090
12091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12092 write!(formatter, "expected one of: {:?}", &FIELDS)
12093 }
12094
12095 #[allow(unused_variables)]
12096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12097 where
12098 E: serde::de::Error,
12099 {
12100 match value {
12101 "id" => Ok(GeneratedField::Id),
12102 "actors" => Ok(GeneratedField::Actors),
12103 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12104 }
12105 }
12106 }
12107 deserializer.deserialize_identifier(GeneratedVisitor)
12108 }
12109 }
12110 struct GeneratedVisitor;
12111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12112 type Value = list_table_fragments_response::FragmentInfo;
12113
12114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12115 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
12116 }
12117
12118 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
12119 where
12120 V: serde::de::MapAccess<'de>,
12121 {
12122 let mut id__ = None;
12123 let mut actors__ = None;
12124 while let Some(k) = map_.next_key()? {
12125 match k {
12126 GeneratedField::Id => {
12127 if id__.is_some() {
12128 return Err(serde::de::Error::duplicate_field("id"));
12129 }
12130 id__ =
12131 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12132 ;
12133 }
12134 GeneratedField::Actors => {
12135 if actors__.is_some() {
12136 return Err(serde::de::Error::duplicate_field("actors"));
12137 }
12138 actors__ = Some(map_.next_value()?);
12139 }
12140 }
12141 }
12142 Ok(list_table_fragments_response::FragmentInfo {
12143 id: id__.unwrap_or_default(),
12144 actors: actors__.unwrap_or_default(),
12145 })
12146 }
12147 }
12148 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
12149 }
12150}
12151impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
12152 #[allow(deprecated)]
12153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12154 where
12155 S: serde::Serializer,
12156 {
12157 use serde::ser::SerializeStruct;
12158 let mut len = 0;
12159 if !self.fragments.is_empty() {
12160 len += 1;
12161 }
12162 if self.ctx.is_some() {
12163 len += 1;
12164 }
12165 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
12166 if !self.fragments.is_empty() {
12167 struct_ser.serialize_field("fragments", &self.fragments)?;
12168 }
12169 if let Some(v) = self.ctx.as_ref() {
12170 struct_ser.serialize_field("ctx", v)?;
12171 }
12172 struct_ser.end()
12173 }
12174}
12175impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
12176 #[allow(deprecated)]
12177 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12178 where
12179 D: serde::Deserializer<'de>,
12180 {
12181 const FIELDS: &[&str] = &[
12182 "fragments",
12183 "ctx",
12184 ];
12185
12186 #[allow(clippy::enum_variant_names)]
12187 enum GeneratedField {
12188 Fragments,
12189 Ctx,
12190 }
12191 impl<'de> serde::Deserialize<'de> for GeneratedField {
12192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12193 where
12194 D: serde::Deserializer<'de>,
12195 {
12196 struct GeneratedVisitor;
12197
12198 impl serde::de::Visitor<'_> for GeneratedVisitor {
12199 type Value = GeneratedField;
12200
12201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12202 write!(formatter, "expected one of: {:?}", &FIELDS)
12203 }
12204
12205 #[allow(unused_variables)]
12206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12207 where
12208 E: serde::de::Error,
12209 {
12210 match value {
12211 "fragments" => Ok(GeneratedField::Fragments),
12212 "ctx" => Ok(GeneratedField::Ctx),
12213 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12214 }
12215 }
12216 }
12217 deserializer.deserialize_identifier(GeneratedVisitor)
12218 }
12219 }
12220 struct GeneratedVisitor;
12221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12222 type Value = list_table_fragments_response::TableFragmentInfo;
12223
12224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12225 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
12226 }
12227
12228 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
12229 where
12230 V: serde::de::MapAccess<'de>,
12231 {
12232 let mut fragments__ = None;
12233 let mut ctx__ = None;
12234 while let Some(k) = map_.next_key()? {
12235 match k {
12236 GeneratedField::Fragments => {
12237 if fragments__.is_some() {
12238 return Err(serde::de::Error::duplicate_field("fragments"));
12239 }
12240 fragments__ = Some(map_.next_value()?);
12241 }
12242 GeneratedField::Ctx => {
12243 if ctx__.is_some() {
12244 return Err(serde::de::Error::duplicate_field("ctx"));
12245 }
12246 ctx__ = map_.next_value()?;
12247 }
12248 }
12249 }
12250 Ok(list_table_fragments_response::TableFragmentInfo {
12251 fragments: fragments__.unwrap_or_default(),
12252 ctx: ctx__,
12253 })
12254 }
12255 }
12256 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
12257 }
12258}
12259impl serde::Serialize for ListUnmigratedTablesRequest {
12260 #[allow(deprecated)]
12261 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12262 where
12263 S: serde::Serializer,
12264 {
12265 use serde::ser::SerializeStruct;
12266 let len = 0;
12267 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
12268 struct_ser.end()
12269 }
12270}
12271impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
12272 #[allow(deprecated)]
12273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12274 where
12275 D: serde::Deserializer<'de>,
12276 {
12277 const FIELDS: &[&str] = &[
12278 ];
12279
12280 #[allow(clippy::enum_variant_names)]
12281 enum GeneratedField {
12282 }
12283 impl<'de> serde::Deserialize<'de> for GeneratedField {
12284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12285 where
12286 D: serde::Deserializer<'de>,
12287 {
12288 struct GeneratedVisitor;
12289
12290 impl serde::de::Visitor<'_> for GeneratedVisitor {
12291 type Value = GeneratedField;
12292
12293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12294 write!(formatter, "expected one of: {:?}", &FIELDS)
12295 }
12296
12297 #[allow(unused_variables)]
12298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12299 where
12300 E: serde::de::Error,
12301 {
12302 Err(serde::de::Error::unknown_field(value, FIELDS))
12303 }
12304 }
12305 deserializer.deserialize_identifier(GeneratedVisitor)
12306 }
12307 }
12308 struct GeneratedVisitor;
12309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12310 type Value = ListUnmigratedTablesRequest;
12311
12312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12313 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
12314 }
12315
12316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
12317 where
12318 V: serde::de::MapAccess<'de>,
12319 {
12320 while map_.next_key::<GeneratedField>()?.is_some() {
12321 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12322 }
12323 Ok(ListUnmigratedTablesRequest {
12324 })
12325 }
12326 }
12327 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
12328 }
12329}
12330impl serde::Serialize for ListUnmigratedTablesResponse {
12331 #[allow(deprecated)]
12332 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12333 where
12334 S: serde::Serializer,
12335 {
12336 use serde::ser::SerializeStruct;
12337 let mut len = 0;
12338 if !self.tables.is_empty() {
12339 len += 1;
12340 }
12341 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
12342 if !self.tables.is_empty() {
12343 struct_ser.serialize_field("tables", &self.tables)?;
12344 }
12345 struct_ser.end()
12346 }
12347}
12348impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
12349 #[allow(deprecated)]
12350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12351 where
12352 D: serde::Deserializer<'de>,
12353 {
12354 const FIELDS: &[&str] = &[
12355 "tables",
12356 ];
12357
12358 #[allow(clippy::enum_variant_names)]
12359 enum GeneratedField {
12360 Tables,
12361 }
12362 impl<'de> serde::Deserialize<'de> for GeneratedField {
12363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12364 where
12365 D: serde::Deserializer<'de>,
12366 {
12367 struct GeneratedVisitor;
12368
12369 impl serde::de::Visitor<'_> for GeneratedVisitor {
12370 type Value = GeneratedField;
12371
12372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12373 write!(formatter, "expected one of: {:?}", &FIELDS)
12374 }
12375
12376 #[allow(unused_variables)]
12377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12378 where
12379 E: serde::de::Error,
12380 {
12381 match value {
12382 "tables" => Ok(GeneratedField::Tables),
12383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12384 }
12385 }
12386 }
12387 deserializer.deserialize_identifier(GeneratedVisitor)
12388 }
12389 }
12390 struct GeneratedVisitor;
12391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12392 type Value = ListUnmigratedTablesResponse;
12393
12394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12395 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
12396 }
12397
12398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
12399 where
12400 V: serde::de::MapAccess<'de>,
12401 {
12402 let mut tables__ = None;
12403 while let Some(k) = map_.next_key()? {
12404 match k {
12405 GeneratedField::Tables => {
12406 if tables__.is_some() {
12407 return Err(serde::de::Error::duplicate_field("tables"));
12408 }
12409 tables__ = Some(map_.next_value()?);
12410 }
12411 }
12412 }
12413 Ok(ListUnmigratedTablesResponse {
12414 tables: tables__.unwrap_or_default(),
12415 })
12416 }
12417 }
12418 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
12419 }
12420}
12421impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
12422 #[allow(deprecated)]
12423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12424 where
12425 S: serde::Serializer,
12426 {
12427 use serde::ser::SerializeStruct;
12428 let mut len = 0;
12429 if self.table_id != 0 {
12430 len += 1;
12431 }
12432 if !self.table_name.is_empty() {
12433 len += 1;
12434 }
12435 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
12436 if self.table_id != 0 {
12437 struct_ser.serialize_field("tableId", &self.table_id)?;
12438 }
12439 if !self.table_name.is_empty() {
12440 struct_ser.serialize_field("tableName", &self.table_name)?;
12441 }
12442 struct_ser.end()
12443 }
12444}
12445impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
12446 #[allow(deprecated)]
12447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12448 where
12449 D: serde::Deserializer<'de>,
12450 {
12451 const FIELDS: &[&str] = &[
12452 "table_id",
12453 "tableId",
12454 "table_name",
12455 "tableName",
12456 ];
12457
12458 #[allow(clippy::enum_variant_names)]
12459 enum GeneratedField {
12460 TableId,
12461 TableName,
12462 }
12463 impl<'de> serde::Deserialize<'de> for GeneratedField {
12464 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12465 where
12466 D: serde::Deserializer<'de>,
12467 {
12468 struct GeneratedVisitor;
12469
12470 impl serde::de::Visitor<'_> for GeneratedVisitor {
12471 type Value = GeneratedField;
12472
12473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12474 write!(formatter, "expected one of: {:?}", &FIELDS)
12475 }
12476
12477 #[allow(unused_variables)]
12478 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12479 where
12480 E: serde::de::Error,
12481 {
12482 match value {
12483 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12484 "tableName" | "table_name" => Ok(GeneratedField::TableName),
12485 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12486 }
12487 }
12488 }
12489 deserializer.deserialize_identifier(GeneratedVisitor)
12490 }
12491 }
12492 struct GeneratedVisitor;
12493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12494 type Value = list_unmigrated_tables_response::UnmigratedTable;
12495
12496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12497 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
12498 }
12499
12500 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
12501 where
12502 V: serde::de::MapAccess<'de>,
12503 {
12504 let mut table_id__ = None;
12505 let mut table_name__ = None;
12506 while let Some(k) = map_.next_key()? {
12507 match k {
12508 GeneratedField::TableId => {
12509 if table_id__.is_some() {
12510 return Err(serde::de::Error::duplicate_field("tableId"));
12511 }
12512 table_id__ =
12513 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12514 ;
12515 }
12516 GeneratedField::TableName => {
12517 if table_name__.is_some() {
12518 return Err(serde::de::Error::duplicate_field("tableName"));
12519 }
12520 table_name__ = Some(map_.next_value()?);
12521 }
12522 }
12523 }
12524 Ok(list_unmigrated_tables_response::UnmigratedTable {
12525 table_id: table_id__.unwrap_or_default(),
12526 table_name: table_name__.unwrap_or_default(),
12527 })
12528 }
12529 }
12530 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
12531 }
12532}
12533impl serde::Serialize for MembersRequest {
12534 #[allow(deprecated)]
12535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12536 where
12537 S: serde::Serializer,
12538 {
12539 use serde::ser::SerializeStruct;
12540 let len = 0;
12541 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
12542 struct_ser.end()
12543 }
12544}
12545impl<'de> serde::Deserialize<'de> for MembersRequest {
12546 #[allow(deprecated)]
12547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12548 where
12549 D: serde::Deserializer<'de>,
12550 {
12551 const FIELDS: &[&str] = &[
12552 ];
12553
12554 #[allow(clippy::enum_variant_names)]
12555 enum GeneratedField {
12556 }
12557 impl<'de> serde::Deserialize<'de> for GeneratedField {
12558 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12559 where
12560 D: serde::Deserializer<'de>,
12561 {
12562 struct GeneratedVisitor;
12563
12564 impl serde::de::Visitor<'_> for GeneratedVisitor {
12565 type Value = GeneratedField;
12566
12567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12568 write!(formatter, "expected one of: {:?}", &FIELDS)
12569 }
12570
12571 #[allow(unused_variables)]
12572 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12573 where
12574 E: serde::de::Error,
12575 {
12576 Err(serde::de::Error::unknown_field(value, FIELDS))
12577 }
12578 }
12579 deserializer.deserialize_identifier(GeneratedVisitor)
12580 }
12581 }
12582 struct GeneratedVisitor;
12583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12584 type Value = MembersRequest;
12585
12586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12587 formatter.write_str("struct meta.MembersRequest")
12588 }
12589
12590 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
12591 where
12592 V: serde::de::MapAccess<'de>,
12593 {
12594 while map_.next_key::<GeneratedField>()?.is_some() {
12595 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12596 }
12597 Ok(MembersRequest {
12598 })
12599 }
12600 }
12601 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
12602 }
12603}
12604impl serde::Serialize for MembersResponse {
12605 #[allow(deprecated)]
12606 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12607 where
12608 S: serde::Serializer,
12609 {
12610 use serde::ser::SerializeStruct;
12611 let mut len = 0;
12612 if !self.members.is_empty() {
12613 len += 1;
12614 }
12615 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
12616 if !self.members.is_empty() {
12617 struct_ser.serialize_field("members", &self.members)?;
12618 }
12619 struct_ser.end()
12620 }
12621}
12622impl<'de> serde::Deserialize<'de> for MembersResponse {
12623 #[allow(deprecated)]
12624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12625 where
12626 D: serde::Deserializer<'de>,
12627 {
12628 const FIELDS: &[&str] = &[
12629 "members",
12630 ];
12631
12632 #[allow(clippy::enum_variant_names)]
12633 enum GeneratedField {
12634 Members,
12635 }
12636 impl<'de> serde::Deserialize<'de> for GeneratedField {
12637 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12638 where
12639 D: serde::Deserializer<'de>,
12640 {
12641 struct GeneratedVisitor;
12642
12643 impl serde::de::Visitor<'_> for GeneratedVisitor {
12644 type Value = GeneratedField;
12645
12646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12647 write!(formatter, "expected one of: {:?}", &FIELDS)
12648 }
12649
12650 #[allow(unused_variables)]
12651 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12652 where
12653 E: serde::de::Error,
12654 {
12655 match value {
12656 "members" => Ok(GeneratedField::Members),
12657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12658 }
12659 }
12660 }
12661 deserializer.deserialize_identifier(GeneratedVisitor)
12662 }
12663 }
12664 struct GeneratedVisitor;
12665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12666 type Value = MembersResponse;
12667
12668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12669 formatter.write_str("struct meta.MembersResponse")
12670 }
12671
12672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
12673 where
12674 V: serde::de::MapAccess<'de>,
12675 {
12676 let mut members__ = None;
12677 while let Some(k) = map_.next_key()? {
12678 match k {
12679 GeneratedField::Members => {
12680 if members__.is_some() {
12681 return Err(serde::de::Error::duplicate_field("members"));
12682 }
12683 members__ = Some(map_.next_value()?);
12684 }
12685 }
12686 }
12687 Ok(MembersResponse {
12688 members: members__.unwrap_or_default(),
12689 })
12690 }
12691 }
12692 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
12693 }
12694}
12695impl serde::Serialize for MetaMember {
12696 #[allow(deprecated)]
12697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12698 where
12699 S: serde::Serializer,
12700 {
12701 use serde::ser::SerializeStruct;
12702 let mut len = 0;
12703 if self.address.is_some() {
12704 len += 1;
12705 }
12706 if self.is_leader {
12707 len += 1;
12708 }
12709 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
12710 if let Some(v) = self.address.as_ref() {
12711 struct_ser.serialize_field("address", v)?;
12712 }
12713 if self.is_leader {
12714 struct_ser.serialize_field("isLeader", &self.is_leader)?;
12715 }
12716 struct_ser.end()
12717 }
12718}
12719impl<'de> serde::Deserialize<'de> for MetaMember {
12720 #[allow(deprecated)]
12721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12722 where
12723 D: serde::Deserializer<'de>,
12724 {
12725 const FIELDS: &[&str] = &[
12726 "address",
12727 "is_leader",
12728 "isLeader",
12729 ];
12730
12731 #[allow(clippy::enum_variant_names)]
12732 enum GeneratedField {
12733 Address,
12734 IsLeader,
12735 }
12736 impl<'de> serde::Deserialize<'de> for GeneratedField {
12737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12738 where
12739 D: serde::Deserializer<'de>,
12740 {
12741 struct GeneratedVisitor;
12742
12743 impl serde::de::Visitor<'_> for GeneratedVisitor {
12744 type Value = GeneratedField;
12745
12746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12747 write!(formatter, "expected one of: {:?}", &FIELDS)
12748 }
12749
12750 #[allow(unused_variables)]
12751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12752 where
12753 E: serde::de::Error,
12754 {
12755 match value {
12756 "address" => Ok(GeneratedField::Address),
12757 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
12758 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12759 }
12760 }
12761 }
12762 deserializer.deserialize_identifier(GeneratedVisitor)
12763 }
12764 }
12765 struct GeneratedVisitor;
12766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12767 type Value = MetaMember;
12768
12769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12770 formatter.write_str("struct meta.MetaMember")
12771 }
12772
12773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
12774 where
12775 V: serde::de::MapAccess<'de>,
12776 {
12777 let mut address__ = None;
12778 let mut is_leader__ = None;
12779 while let Some(k) = map_.next_key()? {
12780 match k {
12781 GeneratedField::Address => {
12782 if address__.is_some() {
12783 return Err(serde::de::Error::duplicate_field("address"));
12784 }
12785 address__ = map_.next_value()?;
12786 }
12787 GeneratedField::IsLeader => {
12788 if is_leader__.is_some() {
12789 return Err(serde::de::Error::duplicate_field("isLeader"));
12790 }
12791 is_leader__ = Some(map_.next_value()?);
12792 }
12793 }
12794 }
12795 Ok(MetaMember {
12796 address: address__,
12797 is_leader: is_leader__.unwrap_or_default(),
12798 })
12799 }
12800 }
12801 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
12802 }
12803}
12804impl serde::Serialize for MetaSnapshot {
12805 #[allow(deprecated)]
12806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12807 where
12808 S: serde::Serializer,
12809 {
12810 use serde::ser::SerializeStruct;
12811 let mut len = 0;
12812 if !self.databases.is_empty() {
12813 len += 1;
12814 }
12815 if !self.schemas.is_empty() {
12816 len += 1;
12817 }
12818 if !self.sources.is_empty() {
12819 len += 1;
12820 }
12821 if !self.sinks.is_empty() {
12822 len += 1;
12823 }
12824 if !self.tables.is_empty() {
12825 len += 1;
12826 }
12827 if !self.indexes.is_empty() {
12828 len += 1;
12829 }
12830 if !self.views.is_empty() {
12831 len += 1;
12832 }
12833 if !self.functions.is_empty() {
12834 len += 1;
12835 }
12836 if !self.connections.is_empty() {
12837 len += 1;
12838 }
12839 if !self.subscriptions.is_empty() {
12840 len += 1;
12841 }
12842 if !self.users.is_empty() {
12843 len += 1;
12844 }
12845 if self.session_params.is_some() {
12846 len += 1;
12847 }
12848 if !self.secrets.is_empty() {
12849 len += 1;
12850 }
12851 if self.cluster_resource.is_some() {
12852 len += 1;
12853 }
12854 if !self.nodes.is_empty() {
12855 len += 1;
12856 }
12857 if self.hummock_version.is_some() {
12858 len += 1;
12859 }
12860 if self.meta_backup_manifest_id.is_some() {
12861 len += 1;
12862 }
12863 if self.hummock_write_limits.is_some() {
12864 len += 1;
12865 }
12866 if !self.streaming_worker_slot_mappings.is_empty() {
12867 len += 1;
12868 }
12869 if !self.serving_worker_slot_mappings.is_empty() {
12870 len += 1;
12871 }
12872 if self.version.is_some() {
12873 len += 1;
12874 }
12875 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
12876 if !self.databases.is_empty() {
12877 struct_ser.serialize_field("databases", &self.databases)?;
12878 }
12879 if !self.schemas.is_empty() {
12880 struct_ser.serialize_field("schemas", &self.schemas)?;
12881 }
12882 if !self.sources.is_empty() {
12883 struct_ser.serialize_field("sources", &self.sources)?;
12884 }
12885 if !self.sinks.is_empty() {
12886 struct_ser.serialize_field("sinks", &self.sinks)?;
12887 }
12888 if !self.tables.is_empty() {
12889 struct_ser.serialize_field("tables", &self.tables)?;
12890 }
12891 if !self.indexes.is_empty() {
12892 struct_ser.serialize_field("indexes", &self.indexes)?;
12893 }
12894 if !self.views.is_empty() {
12895 struct_ser.serialize_field("views", &self.views)?;
12896 }
12897 if !self.functions.is_empty() {
12898 struct_ser.serialize_field("functions", &self.functions)?;
12899 }
12900 if !self.connections.is_empty() {
12901 struct_ser.serialize_field("connections", &self.connections)?;
12902 }
12903 if !self.subscriptions.is_empty() {
12904 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
12905 }
12906 if !self.users.is_empty() {
12907 struct_ser.serialize_field("users", &self.users)?;
12908 }
12909 if let Some(v) = self.session_params.as_ref() {
12910 struct_ser.serialize_field("sessionParams", v)?;
12911 }
12912 if !self.secrets.is_empty() {
12913 struct_ser.serialize_field("secrets", &self.secrets)?;
12914 }
12915 if let Some(v) = self.cluster_resource.as_ref() {
12916 struct_ser.serialize_field("clusterResource", v)?;
12917 }
12918 if !self.nodes.is_empty() {
12919 struct_ser.serialize_field("nodes", &self.nodes)?;
12920 }
12921 if let Some(v) = self.hummock_version.as_ref() {
12922 struct_ser.serialize_field("hummockVersion", v)?;
12923 }
12924 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
12925 struct_ser.serialize_field("metaBackupManifestId", v)?;
12926 }
12927 if let Some(v) = self.hummock_write_limits.as_ref() {
12928 struct_ser.serialize_field("hummockWriteLimits", v)?;
12929 }
12930 if !self.streaming_worker_slot_mappings.is_empty() {
12931 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
12932 }
12933 if !self.serving_worker_slot_mappings.is_empty() {
12934 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
12935 }
12936 if let Some(v) = self.version.as_ref() {
12937 struct_ser.serialize_field("version", v)?;
12938 }
12939 struct_ser.end()
12940 }
12941}
12942impl<'de> serde::Deserialize<'de> for MetaSnapshot {
12943 #[allow(deprecated)]
12944 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12945 where
12946 D: serde::Deserializer<'de>,
12947 {
12948 const FIELDS: &[&str] = &[
12949 "databases",
12950 "schemas",
12951 "sources",
12952 "sinks",
12953 "tables",
12954 "indexes",
12955 "views",
12956 "functions",
12957 "connections",
12958 "subscriptions",
12959 "users",
12960 "session_params",
12961 "sessionParams",
12962 "secrets",
12963 "cluster_resource",
12964 "clusterResource",
12965 "nodes",
12966 "hummock_version",
12967 "hummockVersion",
12968 "meta_backup_manifest_id",
12969 "metaBackupManifestId",
12970 "hummock_write_limits",
12971 "hummockWriteLimits",
12972 "streaming_worker_slot_mappings",
12973 "streamingWorkerSlotMappings",
12974 "serving_worker_slot_mappings",
12975 "servingWorkerSlotMappings",
12976 "version",
12977 ];
12978
12979 #[allow(clippy::enum_variant_names)]
12980 enum GeneratedField {
12981 Databases,
12982 Schemas,
12983 Sources,
12984 Sinks,
12985 Tables,
12986 Indexes,
12987 Views,
12988 Functions,
12989 Connections,
12990 Subscriptions,
12991 Users,
12992 SessionParams,
12993 Secrets,
12994 ClusterResource,
12995 Nodes,
12996 HummockVersion,
12997 MetaBackupManifestId,
12998 HummockWriteLimits,
12999 StreamingWorkerSlotMappings,
13000 ServingWorkerSlotMappings,
13001 Version,
13002 }
13003 impl<'de> serde::Deserialize<'de> for GeneratedField {
13004 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13005 where
13006 D: serde::Deserializer<'de>,
13007 {
13008 struct GeneratedVisitor;
13009
13010 impl serde::de::Visitor<'_> for GeneratedVisitor {
13011 type Value = GeneratedField;
13012
13013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13014 write!(formatter, "expected one of: {:?}", &FIELDS)
13015 }
13016
13017 #[allow(unused_variables)]
13018 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13019 where
13020 E: serde::de::Error,
13021 {
13022 match value {
13023 "databases" => Ok(GeneratedField::Databases),
13024 "schemas" => Ok(GeneratedField::Schemas),
13025 "sources" => Ok(GeneratedField::Sources),
13026 "sinks" => Ok(GeneratedField::Sinks),
13027 "tables" => Ok(GeneratedField::Tables),
13028 "indexes" => Ok(GeneratedField::Indexes),
13029 "views" => Ok(GeneratedField::Views),
13030 "functions" => Ok(GeneratedField::Functions),
13031 "connections" => Ok(GeneratedField::Connections),
13032 "subscriptions" => Ok(GeneratedField::Subscriptions),
13033 "users" => Ok(GeneratedField::Users),
13034 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13035 "secrets" => Ok(GeneratedField::Secrets),
13036 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13037 "nodes" => Ok(GeneratedField::Nodes),
13038 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13039 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13040 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13041 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13042 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13043 "version" => Ok(GeneratedField::Version),
13044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13045 }
13046 }
13047 }
13048 deserializer.deserialize_identifier(GeneratedVisitor)
13049 }
13050 }
13051 struct GeneratedVisitor;
13052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13053 type Value = MetaSnapshot;
13054
13055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13056 formatter.write_str("struct meta.MetaSnapshot")
13057 }
13058
13059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13060 where
13061 V: serde::de::MapAccess<'de>,
13062 {
13063 let mut databases__ = None;
13064 let mut schemas__ = None;
13065 let mut sources__ = None;
13066 let mut sinks__ = None;
13067 let mut tables__ = None;
13068 let mut indexes__ = None;
13069 let mut views__ = None;
13070 let mut functions__ = None;
13071 let mut connections__ = None;
13072 let mut subscriptions__ = None;
13073 let mut users__ = None;
13074 let mut session_params__ = None;
13075 let mut secrets__ = None;
13076 let mut cluster_resource__ = None;
13077 let mut nodes__ = None;
13078 let mut hummock_version__ = None;
13079 let mut meta_backup_manifest_id__ = None;
13080 let mut hummock_write_limits__ = None;
13081 let mut streaming_worker_slot_mappings__ = None;
13082 let mut serving_worker_slot_mappings__ = None;
13083 let mut version__ = None;
13084 while let Some(k) = map_.next_key()? {
13085 match k {
13086 GeneratedField::Databases => {
13087 if databases__.is_some() {
13088 return Err(serde::de::Error::duplicate_field("databases"));
13089 }
13090 databases__ = Some(map_.next_value()?);
13091 }
13092 GeneratedField::Schemas => {
13093 if schemas__.is_some() {
13094 return Err(serde::de::Error::duplicate_field("schemas"));
13095 }
13096 schemas__ = Some(map_.next_value()?);
13097 }
13098 GeneratedField::Sources => {
13099 if sources__.is_some() {
13100 return Err(serde::de::Error::duplicate_field("sources"));
13101 }
13102 sources__ = Some(map_.next_value()?);
13103 }
13104 GeneratedField::Sinks => {
13105 if sinks__.is_some() {
13106 return Err(serde::de::Error::duplicate_field("sinks"));
13107 }
13108 sinks__ = Some(map_.next_value()?);
13109 }
13110 GeneratedField::Tables => {
13111 if tables__.is_some() {
13112 return Err(serde::de::Error::duplicate_field("tables"));
13113 }
13114 tables__ = Some(map_.next_value()?);
13115 }
13116 GeneratedField::Indexes => {
13117 if indexes__.is_some() {
13118 return Err(serde::de::Error::duplicate_field("indexes"));
13119 }
13120 indexes__ = Some(map_.next_value()?);
13121 }
13122 GeneratedField::Views => {
13123 if views__.is_some() {
13124 return Err(serde::de::Error::duplicate_field("views"));
13125 }
13126 views__ = Some(map_.next_value()?);
13127 }
13128 GeneratedField::Functions => {
13129 if functions__.is_some() {
13130 return Err(serde::de::Error::duplicate_field("functions"));
13131 }
13132 functions__ = Some(map_.next_value()?);
13133 }
13134 GeneratedField::Connections => {
13135 if connections__.is_some() {
13136 return Err(serde::de::Error::duplicate_field("connections"));
13137 }
13138 connections__ = Some(map_.next_value()?);
13139 }
13140 GeneratedField::Subscriptions => {
13141 if subscriptions__.is_some() {
13142 return Err(serde::de::Error::duplicate_field("subscriptions"));
13143 }
13144 subscriptions__ = Some(map_.next_value()?);
13145 }
13146 GeneratedField::Users => {
13147 if users__.is_some() {
13148 return Err(serde::de::Error::duplicate_field("users"));
13149 }
13150 users__ = Some(map_.next_value()?);
13151 }
13152 GeneratedField::SessionParams => {
13153 if session_params__.is_some() {
13154 return Err(serde::de::Error::duplicate_field("sessionParams"));
13155 }
13156 session_params__ = map_.next_value()?;
13157 }
13158 GeneratedField::Secrets => {
13159 if secrets__.is_some() {
13160 return Err(serde::de::Error::duplicate_field("secrets"));
13161 }
13162 secrets__ = Some(map_.next_value()?);
13163 }
13164 GeneratedField::ClusterResource => {
13165 if cluster_resource__.is_some() {
13166 return Err(serde::de::Error::duplicate_field("clusterResource"));
13167 }
13168 cluster_resource__ = map_.next_value()?;
13169 }
13170 GeneratedField::Nodes => {
13171 if nodes__.is_some() {
13172 return Err(serde::de::Error::duplicate_field("nodes"));
13173 }
13174 nodes__ = Some(map_.next_value()?);
13175 }
13176 GeneratedField::HummockVersion => {
13177 if hummock_version__.is_some() {
13178 return Err(serde::de::Error::duplicate_field("hummockVersion"));
13179 }
13180 hummock_version__ = map_.next_value()?;
13181 }
13182 GeneratedField::MetaBackupManifestId => {
13183 if meta_backup_manifest_id__.is_some() {
13184 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
13185 }
13186 meta_backup_manifest_id__ = map_.next_value()?;
13187 }
13188 GeneratedField::HummockWriteLimits => {
13189 if hummock_write_limits__.is_some() {
13190 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
13191 }
13192 hummock_write_limits__ = map_.next_value()?;
13193 }
13194 GeneratedField::StreamingWorkerSlotMappings => {
13195 if streaming_worker_slot_mappings__.is_some() {
13196 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
13197 }
13198 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
13199 }
13200 GeneratedField::ServingWorkerSlotMappings => {
13201 if serving_worker_slot_mappings__.is_some() {
13202 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
13203 }
13204 serving_worker_slot_mappings__ = Some(map_.next_value()?);
13205 }
13206 GeneratedField::Version => {
13207 if version__.is_some() {
13208 return Err(serde::de::Error::duplicate_field("version"));
13209 }
13210 version__ = map_.next_value()?;
13211 }
13212 }
13213 }
13214 Ok(MetaSnapshot {
13215 databases: databases__.unwrap_or_default(),
13216 schemas: schemas__.unwrap_or_default(),
13217 sources: sources__.unwrap_or_default(),
13218 sinks: sinks__.unwrap_or_default(),
13219 tables: tables__.unwrap_or_default(),
13220 indexes: indexes__.unwrap_or_default(),
13221 views: views__.unwrap_or_default(),
13222 functions: functions__.unwrap_or_default(),
13223 connections: connections__.unwrap_or_default(),
13224 subscriptions: subscriptions__.unwrap_or_default(),
13225 users: users__.unwrap_or_default(),
13226 session_params: session_params__,
13227 secrets: secrets__.unwrap_or_default(),
13228 cluster_resource: cluster_resource__,
13229 nodes: nodes__.unwrap_or_default(),
13230 hummock_version: hummock_version__,
13231 meta_backup_manifest_id: meta_backup_manifest_id__,
13232 hummock_write_limits: hummock_write_limits__,
13233 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
13234 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
13235 version: version__,
13236 })
13237 }
13238 }
13239 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
13240 }
13241}
13242impl serde::Serialize for meta_snapshot::SnapshotVersion {
13243 #[allow(deprecated)]
13244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13245 where
13246 S: serde::Serializer,
13247 {
13248 use serde::ser::SerializeStruct;
13249 let mut len = 0;
13250 if self.catalog_version != 0 {
13251 len += 1;
13252 }
13253 if self.worker_node_version != 0 {
13254 len += 1;
13255 }
13256 if self.streaming_worker_slot_mapping_version != 0 {
13257 len += 1;
13258 }
13259 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
13260 if self.catalog_version != 0 {
13261 #[allow(clippy::needless_borrow)]
13262 #[allow(clippy::needless_borrows_for_generic_args)]
13263 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13264 }
13265 if self.worker_node_version != 0 {
13266 #[allow(clippy::needless_borrow)]
13267 #[allow(clippy::needless_borrows_for_generic_args)]
13268 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
13269 }
13270 if self.streaming_worker_slot_mapping_version != 0 {
13271 #[allow(clippy::needless_borrow)]
13272 #[allow(clippy::needless_borrows_for_generic_args)]
13273 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
13274 }
13275 struct_ser.end()
13276 }
13277}
13278impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
13279 #[allow(deprecated)]
13280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13281 where
13282 D: serde::Deserializer<'de>,
13283 {
13284 const FIELDS: &[&str] = &[
13285 "catalog_version",
13286 "catalogVersion",
13287 "worker_node_version",
13288 "workerNodeVersion",
13289 "streaming_worker_slot_mapping_version",
13290 "streamingWorkerSlotMappingVersion",
13291 ];
13292
13293 #[allow(clippy::enum_variant_names)]
13294 enum GeneratedField {
13295 CatalogVersion,
13296 WorkerNodeVersion,
13297 StreamingWorkerSlotMappingVersion,
13298 }
13299 impl<'de> serde::Deserialize<'de> for GeneratedField {
13300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13301 where
13302 D: serde::Deserializer<'de>,
13303 {
13304 struct GeneratedVisitor;
13305
13306 impl serde::de::Visitor<'_> for GeneratedVisitor {
13307 type Value = GeneratedField;
13308
13309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13310 write!(formatter, "expected one of: {:?}", &FIELDS)
13311 }
13312
13313 #[allow(unused_variables)]
13314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13315 where
13316 E: serde::de::Error,
13317 {
13318 match value {
13319 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13320 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
13321 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
13322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13323 }
13324 }
13325 }
13326 deserializer.deserialize_identifier(GeneratedVisitor)
13327 }
13328 }
13329 struct GeneratedVisitor;
13330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13331 type Value = meta_snapshot::SnapshotVersion;
13332
13333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13334 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
13335 }
13336
13337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
13338 where
13339 V: serde::de::MapAccess<'de>,
13340 {
13341 let mut catalog_version__ = None;
13342 let mut worker_node_version__ = None;
13343 let mut streaming_worker_slot_mapping_version__ = None;
13344 while let Some(k) = map_.next_key()? {
13345 match k {
13346 GeneratedField::CatalogVersion => {
13347 if catalog_version__.is_some() {
13348 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13349 }
13350 catalog_version__ =
13351 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13352 ;
13353 }
13354 GeneratedField::WorkerNodeVersion => {
13355 if worker_node_version__.is_some() {
13356 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
13357 }
13358 worker_node_version__ =
13359 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13360 ;
13361 }
13362 GeneratedField::StreamingWorkerSlotMappingVersion => {
13363 if streaming_worker_slot_mapping_version__.is_some() {
13364 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
13365 }
13366 streaming_worker_slot_mapping_version__ =
13367 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13368 ;
13369 }
13370 }
13371 }
13372 Ok(meta_snapshot::SnapshotVersion {
13373 catalog_version: catalog_version__.unwrap_or_default(),
13374 worker_node_version: worker_node_version__.unwrap_or_default(),
13375 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
13376 })
13377 }
13378 }
13379 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
13380 }
13381}
13382impl serde::Serialize for MigrationPlan {
13383 #[allow(deprecated)]
13384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13385 where
13386 S: serde::Serializer,
13387 {
13388 use serde::ser::SerializeStruct;
13389 let mut len = 0;
13390 if !self.worker_slot_migration_plan.is_empty() {
13391 len += 1;
13392 }
13393 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
13394 if !self.worker_slot_migration_plan.is_empty() {
13395 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
13396 .map(|(k, v)| (k, v.to_string())).collect();
13397 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
13398 }
13399 struct_ser.end()
13400 }
13401}
13402impl<'de> serde::Deserialize<'de> for MigrationPlan {
13403 #[allow(deprecated)]
13404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13405 where
13406 D: serde::Deserializer<'de>,
13407 {
13408 const FIELDS: &[&str] = &[
13409 "worker_slot_migration_plan",
13410 "workerSlotMigrationPlan",
13411 ];
13412
13413 #[allow(clippy::enum_variant_names)]
13414 enum GeneratedField {
13415 WorkerSlotMigrationPlan,
13416 }
13417 impl<'de> serde::Deserialize<'de> for GeneratedField {
13418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13419 where
13420 D: serde::Deserializer<'de>,
13421 {
13422 struct GeneratedVisitor;
13423
13424 impl serde::de::Visitor<'_> for GeneratedVisitor {
13425 type Value = GeneratedField;
13426
13427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13428 write!(formatter, "expected one of: {:?}", &FIELDS)
13429 }
13430
13431 #[allow(unused_variables)]
13432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13433 where
13434 E: serde::de::Error,
13435 {
13436 match value {
13437 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
13438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13439 }
13440 }
13441 }
13442 deserializer.deserialize_identifier(GeneratedVisitor)
13443 }
13444 }
13445 struct GeneratedVisitor;
13446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13447 type Value = MigrationPlan;
13448
13449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13450 formatter.write_str("struct meta.MigrationPlan")
13451 }
13452
13453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
13454 where
13455 V: serde::de::MapAccess<'de>,
13456 {
13457 let mut worker_slot_migration_plan__ = None;
13458 while let Some(k) = map_.next_key()? {
13459 match k {
13460 GeneratedField::WorkerSlotMigrationPlan => {
13461 if worker_slot_migration_plan__.is_some() {
13462 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
13463 }
13464 worker_slot_migration_plan__ = Some(
13465 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
13466 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
13467 );
13468 }
13469 }
13470 }
13471 Ok(MigrationPlan {
13472 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
13473 })
13474 }
13475 }
13476 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
13477 }
13478}
13479impl serde::Serialize for Object {
13480 #[allow(deprecated)]
13481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13482 where
13483 S: serde::Serializer,
13484 {
13485 use serde::ser::SerializeStruct;
13486 let mut len = 0;
13487 if self.object_info.is_some() {
13488 len += 1;
13489 }
13490 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
13491 if let Some(v) = self.object_info.as_ref() {
13492 match v {
13493 object::ObjectInfo::Database(v) => {
13494 struct_ser.serialize_field("database", v)?;
13495 }
13496 object::ObjectInfo::Schema(v) => {
13497 struct_ser.serialize_field("schema", v)?;
13498 }
13499 object::ObjectInfo::Table(v) => {
13500 struct_ser.serialize_field("table", v)?;
13501 }
13502 object::ObjectInfo::Index(v) => {
13503 struct_ser.serialize_field("index", v)?;
13504 }
13505 object::ObjectInfo::Source(v) => {
13506 struct_ser.serialize_field("source", v)?;
13507 }
13508 object::ObjectInfo::Sink(v) => {
13509 struct_ser.serialize_field("sink", v)?;
13510 }
13511 object::ObjectInfo::View(v) => {
13512 struct_ser.serialize_field("view", v)?;
13513 }
13514 object::ObjectInfo::Function(v) => {
13515 struct_ser.serialize_field("function", v)?;
13516 }
13517 object::ObjectInfo::Connection(v) => {
13518 struct_ser.serialize_field("connection", v)?;
13519 }
13520 object::ObjectInfo::Subscription(v) => {
13521 struct_ser.serialize_field("subscription", v)?;
13522 }
13523 object::ObjectInfo::Secret(v) => {
13524 struct_ser.serialize_field("secret", v)?;
13525 }
13526 }
13527 }
13528 struct_ser.end()
13529 }
13530}
13531impl<'de> serde::Deserialize<'de> for Object {
13532 #[allow(deprecated)]
13533 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13534 where
13535 D: serde::Deserializer<'de>,
13536 {
13537 const FIELDS: &[&str] = &[
13538 "database",
13539 "schema",
13540 "table",
13541 "index",
13542 "source",
13543 "sink",
13544 "view",
13545 "function",
13546 "connection",
13547 "subscription",
13548 "secret",
13549 ];
13550
13551 #[allow(clippy::enum_variant_names)]
13552 enum GeneratedField {
13553 Database,
13554 Schema,
13555 Table,
13556 Index,
13557 Source,
13558 Sink,
13559 View,
13560 Function,
13561 Connection,
13562 Subscription,
13563 Secret,
13564 }
13565 impl<'de> serde::Deserialize<'de> for GeneratedField {
13566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13567 where
13568 D: serde::Deserializer<'de>,
13569 {
13570 struct GeneratedVisitor;
13571
13572 impl serde::de::Visitor<'_> for GeneratedVisitor {
13573 type Value = GeneratedField;
13574
13575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13576 write!(formatter, "expected one of: {:?}", &FIELDS)
13577 }
13578
13579 #[allow(unused_variables)]
13580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13581 where
13582 E: serde::de::Error,
13583 {
13584 match value {
13585 "database" => Ok(GeneratedField::Database),
13586 "schema" => Ok(GeneratedField::Schema),
13587 "table" => Ok(GeneratedField::Table),
13588 "index" => Ok(GeneratedField::Index),
13589 "source" => Ok(GeneratedField::Source),
13590 "sink" => Ok(GeneratedField::Sink),
13591 "view" => Ok(GeneratedField::View),
13592 "function" => Ok(GeneratedField::Function),
13593 "connection" => Ok(GeneratedField::Connection),
13594 "subscription" => Ok(GeneratedField::Subscription),
13595 "secret" => Ok(GeneratedField::Secret),
13596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13597 }
13598 }
13599 }
13600 deserializer.deserialize_identifier(GeneratedVisitor)
13601 }
13602 }
13603 struct GeneratedVisitor;
13604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13605 type Value = Object;
13606
13607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13608 formatter.write_str("struct meta.Object")
13609 }
13610
13611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
13612 where
13613 V: serde::de::MapAccess<'de>,
13614 {
13615 let mut object_info__ = None;
13616 while let Some(k) = map_.next_key()? {
13617 match k {
13618 GeneratedField::Database => {
13619 if object_info__.is_some() {
13620 return Err(serde::de::Error::duplicate_field("database"));
13621 }
13622 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
13623;
13624 }
13625 GeneratedField::Schema => {
13626 if object_info__.is_some() {
13627 return Err(serde::de::Error::duplicate_field("schema"));
13628 }
13629 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
13630;
13631 }
13632 GeneratedField::Table => {
13633 if object_info__.is_some() {
13634 return Err(serde::de::Error::duplicate_field("table"));
13635 }
13636 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
13637;
13638 }
13639 GeneratedField::Index => {
13640 if object_info__.is_some() {
13641 return Err(serde::de::Error::duplicate_field("index"));
13642 }
13643 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
13644;
13645 }
13646 GeneratedField::Source => {
13647 if object_info__.is_some() {
13648 return Err(serde::de::Error::duplicate_field("source"));
13649 }
13650 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
13651;
13652 }
13653 GeneratedField::Sink => {
13654 if object_info__.is_some() {
13655 return Err(serde::de::Error::duplicate_field("sink"));
13656 }
13657 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
13658;
13659 }
13660 GeneratedField::View => {
13661 if object_info__.is_some() {
13662 return Err(serde::de::Error::duplicate_field("view"));
13663 }
13664 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
13665;
13666 }
13667 GeneratedField::Function => {
13668 if object_info__.is_some() {
13669 return Err(serde::de::Error::duplicate_field("function"));
13670 }
13671 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
13672;
13673 }
13674 GeneratedField::Connection => {
13675 if object_info__.is_some() {
13676 return Err(serde::de::Error::duplicate_field("connection"));
13677 }
13678 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
13679;
13680 }
13681 GeneratedField::Subscription => {
13682 if object_info__.is_some() {
13683 return Err(serde::de::Error::duplicate_field("subscription"));
13684 }
13685 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
13686;
13687 }
13688 GeneratedField::Secret => {
13689 if object_info__.is_some() {
13690 return Err(serde::de::Error::duplicate_field("secret"));
13691 }
13692 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
13693;
13694 }
13695 }
13696 }
13697 Ok(Object {
13698 object_info: object_info__,
13699 })
13700 }
13701 }
13702 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
13703 }
13704}
13705impl serde::Serialize for ObjectGroup {
13706 #[allow(deprecated)]
13707 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13708 where
13709 S: serde::Serializer,
13710 {
13711 use serde::ser::SerializeStruct;
13712 let mut len = 0;
13713 if !self.objects.is_empty() {
13714 len += 1;
13715 }
13716 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
13717 if !self.objects.is_empty() {
13718 struct_ser.serialize_field("objects", &self.objects)?;
13719 }
13720 struct_ser.end()
13721 }
13722}
13723impl<'de> serde::Deserialize<'de> for ObjectGroup {
13724 #[allow(deprecated)]
13725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13726 where
13727 D: serde::Deserializer<'de>,
13728 {
13729 const FIELDS: &[&str] = &[
13730 "objects",
13731 ];
13732
13733 #[allow(clippy::enum_variant_names)]
13734 enum GeneratedField {
13735 Objects,
13736 }
13737 impl<'de> serde::Deserialize<'de> for GeneratedField {
13738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13739 where
13740 D: serde::Deserializer<'de>,
13741 {
13742 struct GeneratedVisitor;
13743
13744 impl serde::de::Visitor<'_> for GeneratedVisitor {
13745 type Value = GeneratedField;
13746
13747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13748 write!(formatter, "expected one of: {:?}", &FIELDS)
13749 }
13750
13751 #[allow(unused_variables)]
13752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13753 where
13754 E: serde::de::Error,
13755 {
13756 match value {
13757 "objects" => Ok(GeneratedField::Objects),
13758 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13759 }
13760 }
13761 }
13762 deserializer.deserialize_identifier(GeneratedVisitor)
13763 }
13764 }
13765 struct GeneratedVisitor;
13766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13767 type Value = ObjectGroup;
13768
13769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13770 formatter.write_str("struct meta.ObjectGroup")
13771 }
13772
13773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
13774 where
13775 V: serde::de::MapAccess<'de>,
13776 {
13777 let mut objects__ = None;
13778 while let Some(k) = map_.next_key()? {
13779 match k {
13780 GeneratedField::Objects => {
13781 if objects__.is_some() {
13782 return Err(serde::de::Error::duplicate_field("objects"));
13783 }
13784 objects__ = Some(map_.next_value()?);
13785 }
13786 }
13787 }
13788 Ok(ObjectGroup {
13789 objects: objects__.unwrap_or_default(),
13790 })
13791 }
13792 }
13793 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
13794 }
13795}
13796impl serde::Serialize for PauseRequest {
13797 #[allow(deprecated)]
13798 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13799 where
13800 S: serde::Serializer,
13801 {
13802 use serde::ser::SerializeStruct;
13803 let len = 0;
13804 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
13805 struct_ser.end()
13806 }
13807}
13808impl<'de> serde::Deserialize<'de> for PauseRequest {
13809 #[allow(deprecated)]
13810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13811 where
13812 D: serde::Deserializer<'de>,
13813 {
13814 const FIELDS: &[&str] = &[
13815 ];
13816
13817 #[allow(clippy::enum_variant_names)]
13818 enum GeneratedField {
13819 }
13820 impl<'de> serde::Deserialize<'de> for GeneratedField {
13821 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13822 where
13823 D: serde::Deserializer<'de>,
13824 {
13825 struct GeneratedVisitor;
13826
13827 impl serde::de::Visitor<'_> for GeneratedVisitor {
13828 type Value = GeneratedField;
13829
13830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13831 write!(formatter, "expected one of: {:?}", &FIELDS)
13832 }
13833
13834 #[allow(unused_variables)]
13835 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13836 where
13837 E: serde::de::Error,
13838 {
13839 Err(serde::de::Error::unknown_field(value, FIELDS))
13840 }
13841 }
13842 deserializer.deserialize_identifier(GeneratedVisitor)
13843 }
13844 }
13845 struct GeneratedVisitor;
13846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13847 type Value = PauseRequest;
13848
13849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13850 formatter.write_str("struct meta.PauseRequest")
13851 }
13852
13853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
13854 where
13855 V: serde::de::MapAccess<'de>,
13856 {
13857 while map_.next_key::<GeneratedField>()?.is_some() {
13858 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13859 }
13860 Ok(PauseRequest {
13861 })
13862 }
13863 }
13864 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
13865 }
13866}
13867impl serde::Serialize for PauseResponse {
13868 #[allow(deprecated)]
13869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13870 where
13871 S: serde::Serializer,
13872 {
13873 use serde::ser::SerializeStruct;
13874 let len = 0;
13875 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
13876 struct_ser.end()
13877 }
13878}
13879impl<'de> serde::Deserialize<'de> for PauseResponse {
13880 #[allow(deprecated)]
13881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13882 where
13883 D: serde::Deserializer<'de>,
13884 {
13885 const FIELDS: &[&str] = &[
13886 ];
13887
13888 #[allow(clippy::enum_variant_names)]
13889 enum GeneratedField {
13890 }
13891 impl<'de> serde::Deserialize<'de> for GeneratedField {
13892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13893 where
13894 D: serde::Deserializer<'de>,
13895 {
13896 struct GeneratedVisitor;
13897
13898 impl serde::de::Visitor<'_> for GeneratedVisitor {
13899 type Value = GeneratedField;
13900
13901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13902 write!(formatter, "expected one of: {:?}", &FIELDS)
13903 }
13904
13905 #[allow(unused_variables)]
13906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13907 where
13908 E: serde::de::Error,
13909 {
13910 Err(serde::de::Error::unknown_field(value, FIELDS))
13911 }
13912 }
13913 deserializer.deserialize_identifier(GeneratedVisitor)
13914 }
13915 }
13916 struct GeneratedVisitor;
13917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13918 type Value = PauseResponse;
13919
13920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13921 formatter.write_str("struct meta.PauseResponse")
13922 }
13923
13924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
13925 where
13926 V: serde::de::MapAccess<'de>,
13927 {
13928 while map_.next_key::<GeneratedField>()?.is_some() {
13929 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13930 }
13931 Ok(PauseResponse {
13932 })
13933 }
13934 }
13935 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
13936 }
13937}
13938impl serde::Serialize for RecoverRequest {
13939 #[allow(deprecated)]
13940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13941 where
13942 S: serde::Serializer,
13943 {
13944 use serde::ser::SerializeStruct;
13945 let len = 0;
13946 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
13947 struct_ser.end()
13948 }
13949}
13950impl<'de> serde::Deserialize<'de> for RecoverRequest {
13951 #[allow(deprecated)]
13952 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13953 where
13954 D: serde::Deserializer<'de>,
13955 {
13956 const FIELDS: &[&str] = &[
13957 ];
13958
13959 #[allow(clippy::enum_variant_names)]
13960 enum GeneratedField {
13961 }
13962 impl<'de> serde::Deserialize<'de> for GeneratedField {
13963 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13964 where
13965 D: serde::Deserializer<'de>,
13966 {
13967 struct GeneratedVisitor;
13968
13969 impl serde::de::Visitor<'_> for GeneratedVisitor {
13970 type Value = GeneratedField;
13971
13972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13973 write!(formatter, "expected one of: {:?}", &FIELDS)
13974 }
13975
13976 #[allow(unused_variables)]
13977 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13978 where
13979 E: serde::de::Error,
13980 {
13981 Err(serde::de::Error::unknown_field(value, FIELDS))
13982 }
13983 }
13984 deserializer.deserialize_identifier(GeneratedVisitor)
13985 }
13986 }
13987 struct GeneratedVisitor;
13988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13989 type Value = RecoverRequest;
13990
13991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13992 formatter.write_str("struct meta.RecoverRequest")
13993 }
13994
13995 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
13996 where
13997 V: serde::de::MapAccess<'de>,
13998 {
13999 while map_.next_key::<GeneratedField>()?.is_some() {
14000 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14001 }
14002 Ok(RecoverRequest {
14003 })
14004 }
14005 }
14006 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
14007 }
14008}
14009impl serde::Serialize for RecoverResponse {
14010 #[allow(deprecated)]
14011 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14012 where
14013 S: serde::Serializer,
14014 {
14015 use serde::ser::SerializeStruct;
14016 let len = 0;
14017 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
14018 struct_ser.end()
14019 }
14020}
14021impl<'de> serde::Deserialize<'de> for RecoverResponse {
14022 #[allow(deprecated)]
14023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14024 where
14025 D: serde::Deserializer<'de>,
14026 {
14027 const FIELDS: &[&str] = &[
14028 ];
14029
14030 #[allow(clippy::enum_variant_names)]
14031 enum GeneratedField {
14032 }
14033 impl<'de> serde::Deserialize<'de> for GeneratedField {
14034 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14035 where
14036 D: serde::Deserializer<'de>,
14037 {
14038 struct GeneratedVisitor;
14039
14040 impl serde::de::Visitor<'_> for GeneratedVisitor {
14041 type Value = GeneratedField;
14042
14043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14044 write!(formatter, "expected one of: {:?}", &FIELDS)
14045 }
14046
14047 #[allow(unused_variables)]
14048 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14049 where
14050 E: serde::de::Error,
14051 {
14052 Err(serde::de::Error::unknown_field(value, FIELDS))
14053 }
14054 }
14055 deserializer.deserialize_identifier(GeneratedVisitor)
14056 }
14057 }
14058 struct GeneratedVisitor;
14059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14060 type Value = RecoverResponse;
14061
14062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14063 formatter.write_str("struct meta.RecoverResponse")
14064 }
14065
14066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
14067 where
14068 V: serde::de::MapAccess<'de>,
14069 {
14070 while map_.next_key::<GeneratedField>()?.is_some() {
14071 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14072 }
14073 Ok(RecoverResponse {
14074 })
14075 }
14076 }
14077 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
14078 }
14079}
14080impl serde::Serialize for Recovery {
14081 #[allow(deprecated)]
14082 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14083 where
14084 S: serde::Serializer,
14085 {
14086 use serde::ser::SerializeStruct;
14087 let len = 0;
14088 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
14089 struct_ser.end()
14090 }
14091}
14092impl<'de> serde::Deserialize<'de> for Recovery {
14093 #[allow(deprecated)]
14094 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14095 where
14096 D: serde::Deserializer<'de>,
14097 {
14098 const FIELDS: &[&str] = &[
14099 ];
14100
14101 #[allow(clippy::enum_variant_names)]
14102 enum GeneratedField {
14103 }
14104 impl<'de> serde::Deserialize<'de> for GeneratedField {
14105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14106 where
14107 D: serde::Deserializer<'de>,
14108 {
14109 struct GeneratedVisitor;
14110
14111 impl serde::de::Visitor<'_> for GeneratedVisitor {
14112 type Value = GeneratedField;
14113
14114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14115 write!(formatter, "expected one of: {:?}", &FIELDS)
14116 }
14117
14118 #[allow(unused_variables)]
14119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14120 where
14121 E: serde::de::Error,
14122 {
14123 Err(serde::de::Error::unknown_field(value, FIELDS))
14124 }
14125 }
14126 deserializer.deserialize_identifier(GeneratedVisitor)
14127 }
14128 }
14129 struct GeneratedVisitor;
14130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14131 type Value = Recovery;
14132
14133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14134 formatter.write_str("struct meta.Recovery")
14135 }
14136
14137 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
14138 where
14139 V: serde::de::MapAccess<'de>,
14140 {
14141 while map_.next_key::<GeneratedField>()?.is_some() {
14142 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14143 }
14144 Ok(Recovery {
14145 })
14146 }
14147 }
14148 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
14149 }
14150}
14151impl serde::Serialize for RecoveryStatus {
14152 #[allow(deprecated)]
14153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14154 where
14155 S: serde::Serializer,
14156 {
14157 let variant = match self {
14158 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
14159 Self::StatusStarting => "STATUS_STARTING",
14160 Self::StatusRecovering => "STATUS_RECOVERING",
14161 Self::StatusRunning => "STATUS_RUNNING",
14162 };
14163 serializer.serialize_str(variant)
14164 }
14165}
14166impl<'de> serde::Deserialize<'de> for RecoveryStatus {
14167 #[allow(deprecated)]
14168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14169 where
14170 D: serde::Deserializer<'de>,
14171 {
14172 const FIELDS: &[&str] = &[
14173 "STATUS_UNSPECIFIED",
14174 "STATUS_STARTING",
14175 "STATUS_RECOVERING",
14176 "STATUS_RUNNING",
14177 ];
14178
14179 struct GeneratedVisitor;
14180
14181 impl serde::de::Visitor<'_> for GeneratedVisitor {
14182 type Value = RecoveryStatus;
14183
14184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14185 write!(formatter, "expected one of: {:?}", &FIELDS)
14186 }
14187
14188 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14189 where
14190 E: serde::de::Error,
14191 {
14192 i32::try_from(v)
14193 .ok()
14194 .and_then(|x| x.try_into().ok())
14195 .ok_or_else(|| {
14196 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14197 })
14198 }
14199
14200 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14201 where
14202 E: serde::de::Error,
14203 {
14204 i32::try_from(v)
14205 .ok()
14206 .and_then(|x| x.try_into().ok())
14207 .ok_or_else(|| {
14208 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14209 })
14210 }
14211
14212 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14213 where
14214 E: serde::de::Error,
14215 {
14216 match value {
14217 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
14218 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
14219 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
14220 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
14221 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14222 }
14223 }
14224 }
14225 deserializer.deserialize_any(GeneratedVisitor)
14226 }
14227}
14228impl serde::Serialize for RefreshRequest {
14229 #[allow(deprecated)]
14230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14231 where
14232 S: serde::Serializer,
14233 {
14234 use serde::ser::SerializeStruct;
14235 let mut len = 0;
14236 if self.table_id != 0 {
14237 len += 1;
14238 }
14239 if self.associated_source_id != 0 {
14240 len += 1;
14241 }
14242 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
14243 if self.table_id != 0 {
14244 struct_ser.serialize_field("tableId", &self.table_id)?;
14245 }
14246 if self.associated_source_id != 0 {
14247 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
14248 }
14249 struct_ser.end()
14250 }
14251}
14252impl<'de> serde::Deserialize<'de> for RefreshRequest {
14253 #[allow(deprecated)]
14254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14255 where
14256 D: serde::Deserializer<'de>,
14257 {
14258 const FIELDS: &[&str] = &[
14259 "table_id",
14260 "tableId",
14261 "associated_source_id",
14262 "associatedSourceId",
14263 ];
14264
14265 #[allow(clippy::enum_variant_names)]
14266 enum GeneratedField {
14267 TableId,
14268 AssociatedSourceId,
14269 }
14270 impl<'de> serde::Deserialize<'de> for GeneratedField {
14271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14272 where
14273 D: serde::Deserializer<'de>,
14274 {
14275 struct GeneratedVisitor;
14276
14277 impl serde::de::Visitor<'_> for GeneratedVisitor {
14278 type Value = GeneratedField;
14279
14280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14281 write!(formatter, "expected one of: {:?}", &FIELDS)
14282 }
14283
14284 #[allow(unused_variables)]
14285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14286 where
14287 E: serde::de::Error,
14288 {
14289 match value {
14290 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14291 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
14292 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14293 }
14294 }
14295 }
14296 deserializer.deserialize_identifier(GeneratedVisitor)
14297 }
14298 }
14299 struct GeneratedVisitor;
14300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14301 type Value = RefreshRequest;
14302
14303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14304 formatter.write_str("struct meta.RefreshRequest")
14305 }
14306
14307 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
14308 where
14309 V: serde::de::MapAccess<'de>,
14310 {
14311 let mut table_id__ = None;
14312 let mut associated_source_id__ = None;
14313 while let Some(k) = map_.next_key()? {
14314 match k {
14315 GeneratedField::TableId => {
14316 if table_id__.is_some() {
14317 return Err(serde::de::Error::duplicate_field("tableId"));
14318 }
14319 table_id__ =
14320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14321 ;
14322 }
14323 GeneratedField::AssociatedSourceId => {
14324 if associated_source_id__.is_some() {
14325 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
14326 }
14327 associated_source_id__ =
14328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14329 ;
14330 }
14331 }
14332 }
14333 Ok(RefreshRequest {
14334 table_id: table_id__.unwrap_or_default(),
14335 associated_source_id: associated_source_id__.unwrap_or_default(),
14336 })
14337 }
14338 }
14339 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
14340 }
14341}
14342impl serde::Serialize for RefreshResponse {
14343 #[allow(deprecated)]
14344 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14345 where
14346 S: serde::Serializer,
14347 {
14348 use serde::ser::SerializeStruct;
14349 let mut len = 0;
14350 if self.status.is_some() {
14351 len += 1;
14352 }
14353 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
14354 if let Some(v) = self.status.as_ref() {
14355 struct_ser.serialize_field("status", v)?;
14356 }
14357 struct_ser.end()
14358 }
14359}
14360impl<'de> serde::Deserialize<'de> for RefreshResponse {
14361 #[allow(deprecated)]
14362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14363 where
14364 D: serde::Deserializer<'de>,
14365 {
14366 const FIELDS: &[&str] = &[
14367 "status",
14368 ];
14369
14370 #[allow(clippy::enum_variant_names)]
14371 enum GeneratedField {
14372 Status,
14373 }
14374 impl<'de> serde::Deserialize<'de> for GeneratedField {
14375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14376 where
14377 D: serde::Deserializer<'de>,
14378 {
14379 struct GeneratedVisitor;
14380
14381 impl serde::de::Visitor<'_> for GeneratedVisitor {
14382 type Value = GeneratedField;
14383
14384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14385 write!(formatter, "expected one of: {:?}", &FIELDS)
14386 }
14387
14388 #[allow(unused_variables)]
14389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14390 where
14391 E: serde::de::Error,
14392 {
14393 match value {
14394 "status" => Ok(GeneratedField::Status),
14395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14396 }
14397 }
14398 }
14399 deserializer.deserialize_identifier(GeneratedVisitor)
14400 }
14401 }
14402 struct GeneratedVisitor;
14403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14404 type Value = RefreshResponse;
14405
14406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14407 formatter.write_str("struct meta.RefreshResponse")
14408 }
14409
14410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
14411 where
14412 V: serde::de::MapAccess<'de>,
14413 {
14414 let mut status__ = None;
14415 while let Some(k) = map_.next_key()? {
14416 match k {
14417 GeneratedField::Status => {
14418 if status__.is_some() {
14419 return Err(serde::de::Error::duplicate_field("status"));
14420 }
14421 status__ = map_.next_value()?;
14422 }
14423 }
14424 }
14425 Ok(RefreshResponse {
14426 status: status__,
14427 })
14428 }
14429 }
14430 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
14431 }
14432}
14433impl serde::Serialize for RelationIdInfos {
14434 #[allow(deprecated)]
14435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14436 where
14437 S: serde::Serializer,
14438 {
14439 use serde::ser::SerializeStruct;
14440 let mut len = 0;
14441 if !self.map.is_empty() {
14442 len += 1;
14443 }
14444 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
14445 if !self.map.is_empty() {
14446 struct_ser.serialize_field("map", &self.map)?;
14447 }
14448 struct_ser.end()
14449 }
14450}
14451impl<'de> serde::Deserialize<'de> for RelationIdInfos {
14452 #[allow(deprecated)]
14453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14454 where
14455 D: serde::Deserializer<'de>,
14456 {
14457 const FIELDS: &[&str] = &[
14458 "map",
14459 ];
14460
14461 #[allow(clippy::enum_variant_names)]
14462 enum GeneratedField {
14463 Map,
14464 }
14465 impl<'de> serde::Deserialize<'de> for GeneratedField {
14466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14467 where
14468 D: serde::Deserializer<'de>,
14469 {
14470 struct GeneratedVisitor;
14471
14472 impl serde::de::Visitor<'_> for GeneratedVisitor {
14473 type Value = GeneratedField;
14474
14475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14476 write!(formatter, "expected one of: {:?}", &FIELDS)
14477 }
14478
14479 #[allow(unused_variables)]
14480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14481 where
14482 E: serde::de::Error,
14483 {
14484 match value {
14485 "map" => Ok(GeneratedField::Map),
14486 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14487 }
14488 }
14489 }
14490 deserializer.deserialize_identifier(GeneratedVisitor)
14491 }
14492 }
14493 struct GeneratedVisitor;
14494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14495 type Value = RelationIdInfos;
14496
14497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14498 formatter.write_str("struct meta.RelationIdInfos")
14499 }
14500
14501 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
14502 where
14503 V: serde::de::MapAccess<'de>,
14504 {
14505 let mut map__ = None;
14506 while let Some(k) = map_.next_key()? {
14507 match k {
14508 GeneratedField::Map => {
14509 if map__.is_some() {
14510 return Err(serde::de::Error::duplicate_field("map"));
14511 }
14512 map__ = Some(
14513 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14514 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14515 );
14516 }
14517 }
14518 }
14519 Ok(RelationIdInfos {
14520 map: map__.unwrap_or_default(),
14521 })
14522 }
14523 }
14524 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
14525 }
14526}
14527impl serde::Serialize for RescheduleRequest {
14528 #[allow(deprecated)]
14529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14530 where
14531 S: serde::Serializer,
14532 {
14533 use serde::ser::SerializeStruct;
14534 let mut len = 0;
14535 if self.revision != 0 {
14536 len += 1;
14537 }
14538 if self.resolve_no_shuffle_upstream {
14539 len += 1;
14540 }
14541 if !self.worker_reschedules.is_empty() {
14542 len += 1;
14543 }
14544 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
14545 if self.revision != 0 {
14546 #[allow(clippy::needless_borrow)]
14547 #[allow(clippy::needless_borrows_for_generic_args)]
14548 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
14549 }
14550 if self.resolve_no_shuffle_upstream {
14551 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
14552 }
14553 if !self.worker_reschedules.is_empty() {
14554 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
14555 }
14556 struct_ser.end()
14557 }
14558}
14559impl<'de> serde::Deserialize<'de> for RescheduleRequest {
14560 #[allow(deprecated)]
14561 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14562 where
14563 D: serde::Deserializer<'de>,
14564 {
14565 const FIELDS: &[&str] = &[
14566 "revision",
14567 "resolve_no_shuffle_upstream",
14568 "resolveNoShuffleUpstream",
14569 "worker_reschedules",
14570 "workerReschedules",
14571 ];
14572
14573 #[allow(clippy::enum_variant_names)]
14574 enum GeneratedField {
14575 Revision,
14576 ResolveNoShuffleUpstream,
14577 WorkerReschedules,
14578 }
14579 impl<'de> serde::Deserialize<'de> for GeneratedField {
14580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14581 where
14582 D: serde::Deserializer<'de>,
14583 {
14584 struct GeneratedVisitor;
14585
14586 impl serde::de::Visitor<'_> for GeneratedVisitor {
14587 type Value = GeneratedField;
14588
14589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14590 write!(formatter, "expected one of: {:?}", &FIELDS)
14591 }
14592
14593 #[allow(unused_variables)]
14594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14595 where
14596 E: serde::de::Error,
14597 {
14598 match value {
14599 "revision" => Ok(GeneratedField::Revision),
14600 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
14601 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
14602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14603 }
14604 }
14605 }
14606 deserializer.deserialize_identifier(GeneratedVisitor)
14607 }
14608 }
14609 struct GeneratedVisitor;
14610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14611 type Value = RescheduleRequest;
14612
14613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14614 formatter.write_str("struct meta.RescheduleRequest")
14615 }
14616
14617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
14618 where
14619 V: serde::de::MapAccess<'de>,
14620 {
14621 let mut revision__ = None;
14622 let mut resolve_no_shuffle_upstream__ = None;
14623 let mut worker_reschedules__ = None;
14624 while let Some(k) = map_.next_key()? {
14625 match k {
14626 GeneratedField::Revision => {
14627 if revision__.is_some() {
14628 return Err(serde::de::Error::duplicate_field("revision"));
14629 }
14630 revision__ =
14631 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14632 ;
14633 }
14634 GeneratedField::ResolveNoShuffleUpstream => {
14635 if resolve_no_shuffle_upstream__.is_some() {
14636 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
14637 }
14638 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
14639 }
14640 GeneratedField::WorkerReschedules => {
14641 if worker_reschedules__.is_some() {
14642 return Err(serde::de::Error::duplicate_field("workerReschedules"));
14643 }
14644 worker_reschedules__ = Some(
14645 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14646 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14647 );
14648 }
14649 }
14650 }
14651 Ok(RescheduleRequest {
14652 revision: revision__.unwrap_or_default(),
14653 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
14654 worker_reschedules: worker_reschedules__.unwrap_or_default(),
14655 })
14656 }
14657 }
14658 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
14659 }
14660}
14661impl serde::Serialize for RescheduleResponse {
14662 #[allow(deprecated)]
14663 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14664 where
14665 S: serde::Serializer,
14666 {
14667 use serde::ser::SerializeStruct;
14668 let mut len = 0;
14669 if self.success {
14670 len += 1;
14671 }
14672 if self.revision != 0 {
14673 len += 1;
14674 }
14675 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
14676 if self.success {
14677 struct_ser.serialize_field("success", &self.success)?;
14678 }
14679 if self.revision != 0 {
14680 #[allow(clippy::needless_borrow)]
14681 #[allow(clippy::needless_borrows_for_generic_args)]
14682 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
14683 }
14684 struct_ser.end()
14685 }
14686}
14687impl<'de> serde::Deserialize<'de> for RescheduleResponse {
14688 #[allow(deprecated)]
14689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14690 where
14691 D: serde::Deserializer<'de>,
14692 {
14693 const FIELDS: &[&str] = &[
14694 "success",
14695 "revision",
14696 ];
14697
14698 #[allow(clippy::enum_variant_names)]
14699 enum GeneratedField {
14700 Success,
14701 Revision,
14702 }
14703 impl<'de> serde::Deserialize<'de> for GeneratedField {
14704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14705 where
14706 D: serde::Deserializer<'de>,
14707 {
14708 struct GeneratedVisitor;
14709
14710 impl serde::de::Visitor<'_> for GeneratedVisitor {
14711 type Value = GeneratedField;
14712
14713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14714 write!(formatter, "expected one of: {:?}", &FIELDS)
14715 }
14716
14717 #[allow(unused_variables)]
14718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14719 where
14720 E: serde::de::Error,
14721 {
14722 match value {
14723 "success" => Ok(GeneratedField::Success),
14724 "revision" => Ok(GeneratedField::Revision),
14725 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14726 }
14727 }
14728 }
14729 deserializer.deserialize_identifier(GeneratedVisitor)
14730 }
14731 }
14732 struct GeneratedVisitor;
14733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14734 type Value = RescheduleResponse;
14735
14736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14737 formatter.write_str("struct meta.RescheduleResponse")
14738 }
14739
14740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
14741 where
14742 V: serde::de::MapAccess<'de>,
14743 {
14744 let mut success__ = None;
14745 let mut revision__ = None;
14746 while let Some(k) = map_.next_key()? {
14747 match k {
14748 GeneratedField::Success => {
14749 if success__.is_some() {
14750 return Err(serde::de::Error::duplicate_field("success"));
14751 }
14752 success__ = Some(map_.next_value()?);
14753 }
14754 GeneratedField::Revision => {
14755 if revision__.is_some() {
14756 return Err(serde::de::Error::duplicate_field("revision"));
14757 }
14758 revision__ =
14759 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14760 ;
14761 }
14762 }
14763 }
14764 Ok(RescheduleResponse {
14765 success: success__.unwrap_or_default(),
14766 revision: revision__.unwrap_or_default(),
14767 })
14768 }
14769 }
14770 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
14771 }
14772}
14773impl serde::Serialize for ResumeRequest {
14774 #[allow(deprecated)]
14775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14776 where
14777 S: serde::Serializer,
14778 {
14779 use serde::ser::SerializeStruct;
14780 let len = 0;
14781 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
14782 struct_ser.end()
14783 }
14784}
14785impl<'de> serde::Deserialize<'de> for ResumeRequest {
14786 #[allow(deprecated)]
14787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14788 where
14789 D: serde::Deserializer<'de>,
14790 {
14791 const FIELDS: &[&str] = &[
14792 ];
14793
14794 #[allow(clippy::enum_variant_names)]
14795 enum GeneratedField {
14796 }
14797 impl<'de> serde::Deserialize<'de> for GeneratedField {
14798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14799 where
14800 D: serde::Deserializer<'de>,
14801 {
14802 struct GeneratedVisitor;
14803
14804 impl serde::de::Visitor<'_> for GeneratedVisitor {
14805 type Value = GeneratedField;
14806
14807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14808 write!(formatter, "expected one of: {:?}", &FIELDS)
14809 }
14810
14811 #[allow(unused_variables)]
14812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14813 where
14814 E: serde::de::Error,
14815 {
14816 Err(serde::de::Error::unknown_field(value, FIELDS))
14817 }
14818 }
14819 deserializer.deserialize_identifier(GeneratedVisitor)
14820 }
14821 }
14822 struct GeneratedVisitor;
14823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14824 type Value = ResumeRequest;
14825
14826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14827 formatter.write_str("struct meta.ResumeRequest")
14828 }
14829
14830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
14831 where
14832 V: serde::de::MapAccess<'de>,
14833 {
14834 while map_.next_key::<GeneratedField>()?.is_some() {
14835 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14836 }
14837 Ok(ResumeRequest {
14838 })
14839 }
14840 }
14841 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
14842 }
14843}
14844impl serde::Serialize for ResumeResponse {
14845 #[allow(deprecated)]
14846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14847 where
14848 S: serde::Serializer,
14849 {
14850 use serde::ser::SerializeStruct;
14851 let len = 0;
14852 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
14853 struct_ser.end()
14854 }
14855}
14856impl<'de> serde::Deserialize<'de> for ResumeResponse {
14857 #[allow(deprecated)]
14858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14859 where
14860 D: serde::Deserializer<'de>,
14861 {
14862 const FIELDS: &[&str] = &[
14863 ];
14864
14865 #[allow(clippy::enum_variant_names)]
14866 enum GeneratedField {
14867 }
14868 impl<'de> serde::Deserialize<'de> for GeneratedField {
14869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14870 where
14871 D: serde::Deserializer<'de>,
14872 {
14873 struct GeneratedVisitor;
14874
14875 impl serde::de::Visitor<'_> for GeneratedVisitor {
14876 type Value = GeneratedField;
14877
14878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14879 write!(formatter, "expected one of: {:?}", &FIELDS)
14880 }
14881
14882 #[allow(unused_variables)]
14883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14884 where
14885 E: serde::de::Error,
14886 {
14887 Err(serde::de::Error::unknown_field(value, FIELDS))
14888 }
14889 }
14890 deserializer.deserialize_identifier(GeneratedVisitor)
14891 }
14892 }
14893 struct GeneratedVisitor;
14894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14895 type Value = ResumeResponse;
14896
14897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14898 formatter.write_str("struct meta.ResumeResponse")
14899 }
14900
14901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
14902 where
14903 V: serde::de::MapAccess<'de>,
14904 {
14905 while map_.next_key::<GeneratedField>()?.is_some() {
14906 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14907 }
14908 Ok(ResumeResponse {
14909 })
14910 }
14911 }
14912 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
14913 }
14914}
14915impl serde::Serialize for SetSessionParamRequest {
14916 #[allow(deprecated)]
14917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14918 where
14919 S: serde::Serializer,
14920 {
14921 use serde::ser::SerializeStruct;
14922 let mut len = 0;
14923 if !self.param.is_empty() {
14924 len += 1;
14925 }
14926 if self.value.is_some() {
14927 len += 1;
14928 }
14929 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
14930 if !self.param.is_empty() {
14931 struct_ser.serialize_field("param", &self.param)?;
14932 }
14933 if let Some(v) = self.value.as_ref() {
14934 struct_ser.serialize_field("value", v)?;
14935 }
14936 struct_ser.end()
14937 }
14938}
14939impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
14940 #[allow(deprecated)]
14941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14942 where
14943 D: serde::Deserializer<'de>,
14944 {
14945 const FIELDS: &[&str] = &[
14946 "param",
14947 "value",
14948 ];
14949
14950 #[allow(clippy::enum_variant_names)]
14951 enum GeneratedField {
14952 Param,
14953 Value,
14954 }
14955 impl<'de> serde::Deserialize<'de> for GeneratedField {
14956 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14957 where
14958 D: serde::Deserializer<'de>,
14959 {
14960 struct GeneratedVisitor;
14961
14962 impl serde::de::Visitor<'_> for GeneratedVisitor {
14963 type Value = GeneratedField;
14964
14965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14966 write!(formatter, "expected one of: {:?}", &FIELDS)
14967 }
14968
14969 #[allow(unused_variables)]
14970 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14971 where
14972 E: serde::de::Error,
14973 {
14974 match value {
14975 "param" => Ok(GeneratedField::Param),
14976 "value" => Ok(GeneratedField::Value),
14977 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14978 }
14979 }
14980 }
14981 deserializer.deserialize_identifier(GeneratedVisitor)
14982 }
14983 }
14984 struct GeneratedVisitor;
14985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14986 type Value = SetSessionParamRequest;
14987
14988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14989 formatter.write_str("struct meta.SetSessionParamRequest")
14990 }
14991
14992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
14993 where
14994 V: serde::de::MapAccess<'de>,
14995 {
14996 let mut param__ = None;
14997 let mut value__ = None;
14998 while let Some(k) = map_.next_key()? {
14999 match k {
15000 GeneratedField::Param => {
15001 if param__.is_some() {
15002 return Err(serde::de::Error::duplicate_field("param"));
15003 }
15004 param__ = Some(map_.next_value()?);
15005 }
15006 GeneratedField::Value => {
15007 if value__.is_some() {
15008 return Err(serde::de::Error::duplicate_field("value"));
15009 }
15010 value__ = map_.next_value()?;
15011 }
15012 }
15013 }
15014 Ok(SetSessionParamRequest {
15015 param: param__.unwrap_or_default(),
15016 value: value__,
15017 })
15018 }
15019 }
15020 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
15021 }
15022}
15023impl serde::Serialize for SetSessionParamResponse {
15024 #[allow(deprecated)]
15025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15026 where
15027 S: serde::Serializer,
15028 {
15029 use serde::ser::SerializeStruct;
15030 let mut len = 0;
15031 if !self.param.is_empty() {
15032 len += 1;
15033 }
15034 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
15035 if !self.param.is_empty() {
15036 struct_ser.serialize_field("param", &self.param)?;
15037 }
15038 struct_ser.end()
15039 }
15040}
15041impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
15042 #[allow(deprecated)]
15043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15044 where
15045 D: serde::Deserializer<'de>,
15046 {
15047 const FIELDS: &[&str] = &[
15048 "param",
15049 ];
15050
15051 #[allow(clippy::enum_variant_names)]
15052 enum GeneratedField {
15053 Param,
15054 }
15055 impl<'de> serde::Deserialize<'de> for GeneratedField {
15056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15057 where
15058 D: serde::Deserializer<'de>,
15059 {
15060 struct GeneratedVisitor;
15061
15062 impl serde::de::Visitor<'_> for GeneratedVisitor {
15063 type Value = GeneratedField;
15064
15065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15066 write!(formatter, "expected one of: {:?}", &FIELDS)
15067 }
15068
15069 #[allow(unused_variables)]
15070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15071 where
15072 E: serde::de::Error,
15073 {
15074 match value {
15075 "param" => Ok(GeneratedField::Param),
15076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15077 }
15078 }
15079 }
15080 deserializer.deserialize_identifier(GeneratedVisitor)
15081 }
15082 }
15083 struct GeneratedVisitor;
15084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15085 type Value = SetSessionParamResponse;
15086
15087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15088 formatter.write_str("struct meta.SetSessionParamResponse")
15089 }
15090
15091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
15092 where
15093 V: serde::de::MapAccess<'de>,
15094 {
15095 let mut param__ = None;
15096 while let Some(k) = map_.next_key()? {
15097 match k {
15098 GeneratedField::Param => {
15099 if param__.is_some() {
15100 return Err(serde::de::Error::duplicate_field("param"));
15101 }
15102 param__ = Some(map_.next_value()?);
15103 }
15104 }
15105 }
15106 Ok(SetSessionParamResponse {
15107 param: param__.unwrap_or_default(),
15108 })
15109 }
15110 }
15111 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
15112 }
15113}
15114impl serde::Serialize for SetSyncLogStoreAlignedRequest {
15115 #[allow(deprecated)]
15116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15117 where
15118 S: serde::Serializer,
15119 {
15120 use serde::ser::SerializeStruct;
15121 let mut len = 0;
15122 if self.job_id != 0 {
15123 len += 1;
15124 }
15125 if self.aligned {
15126 len += 1;
15127 }
15128 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
15129 if self.job_id != 0 {
15130 struct_ser.serialize_field("jobId", &self.job_id)?;
15131 }
15132 if self.aligned {
15133 struct_ser.serialize_field("aligned", &self.aligned)?;
15134 }
15135 struct_ser.end()
15136 }
15137}
15138impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
15139 #[allow(deprecated)]
15140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15141 where
15142 D: serde::Deserializer<'de>,
15143 {
15144 const FIELDS: &[&str] = &[
15145 "job_id",
15146 "jobId",
15147 "aligned",
15148 ];
15149
15150 #[allow(clippy::enum_variant_names)]
15151 enum GeneratedField {
15152 JobId,
15153 Aligned,
15154 }
15155 impl<'de> serde::Deserialize<'de> for GeneratedField {
15156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15157 where
15158 D: serde::Deserializer<'de>,
15159 {
15160 struct GeneratedVisitor;
15161
15162 impl serde::de::Visitor<'_> for GeneratedVisitor {
15163 type Value = GeneratedField;
15164
15165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15166 write!(formatter, "expected one of: {:?}", &FIELDS)
15167 }
15168
15169 #[allow(unused_variables)]
15170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15171 where
15172 E: serde::de::Error,
15173 {
15174 match value {
15175 "jobId" | "job_id" => Ok(GeneratedField::JobId),
15176 "aligned" => Ok(GeneratedField::Aligned),
15177 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15178 }
15179 }
15180 }
15181 deserializer.deserialize_identifier(GeneratedVisitor)
15182 }
15183 }
15184 struct GeneratedVisitor;
15185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15186 type Value = SetSyncLogStoreAlignedRequest;
15187
15188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15189 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
15190 }
15191
15192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
15193 where
15194 V: serde::de::MapAccess<'de>,
15195 {
15196 let mut job_id__ = None;
15197 let mut aligned__ = None;
15198 while let Some(k) = map_.next_key()? {
15199 match k {
15200 GeneratedField::JobId => {
15201 if job_id__.is_some() {
15202 return Err(serde::de::Error::duplicate_field("jobId"));
15203 }
15204 job_id__ =
15205 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15206 ;
15207 }
15208 GeneratedField::Aligned => {
15209 if aligned__.is_some() {
15210 return Err(serde::de::Error::duplicate_field("aligned"));
15211 }
15212 aligned__ = Some(map_.next_value()?);
15213 }
15214 }
15215 }
15216 Ok(SetSyncLogStoreAlignedRequest {
15217 job_id: job_id__.unwrap_or_default(),
15218 aligned: aligned__.unwrap_or_default(),
15219 })
15220 }
15221 }
15222 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
15223 }
15224}
15225impl serde::Serialize for SetSyncLogStoreAlignedResponse {
15226 #[allow(deprecated)]
15227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15228 where
15229 S: serde::Serializer,
15230 {
15231 use serde::ser::SerializeStruct;
15232 let len = 0;
15233 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
15234 struct_ser.end()
15235 }
15236}
15237impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
15238 #[allow(deprecated)]
15239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15240 where
15241 D: serde::Deserializer<'de>,
15242 {
15243 const FIELDS: &[&str] = &[
15244 ];
15245
15246 #[allow(clippy::enum_variant_names)]
15247 enum GeneratedField {
15248 }
15249 impl<'de> serde::Deserialize<'de> for GeneratedField {
15250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15251 where
15252 D: serde::Deserializer<'de>,
15253 {
15254 struct GeneratedVisitor;
15255
15256 impl serde::de::Visitor<'_> for GeneratedVisitor {
15257 type Value = GeneratedField;
15258
15259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15260 write!(formatter, "expected one of: {:?}", &FIELDS)
15261 }
15262
15263 #[allow(unused_variables)]
15264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15265 where
15266 E: serde::de::Error,
15267 {
15268 Err(serde::de::Error::unknown_field(value, FIELDS))
15269 }
15270 }
15271 deserializer.deserialize_identifier(GeneratedVisitor)
15272 }
15273 }
15274 struct GeneratedVisitor;
15275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15276 type Value = SetSyncLogStoreAlignedResponse;
15277
15278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15279 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
15280 }
15281
15282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
15283 where
15284 V: serde::de::MapAccess<'de>,
15285 {
15286 while map_.next_key::<GeneratedField>()?.is_some() {
15287 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15288 }
15289 Ok(SetSyncLogStoreAlignedResponse {
15290 })
15291 }
15292 }
15293 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
15294 }
15295}
15296impl serde::Serialize for SetSystemParamRequest {
15297 #[allow(deprecated)]
15298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15299 where
15300 S: serde::Serializer,
15301 {
15302 use serde::ser::SerializeStruct;
15303 let mut len = 0;
15304 if !self.param.is_empty() {
15305 len += 1;
15306 }
15307 if self.value.is_some() {
15308 len += 1;
15309 }
15310 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
15311 if !self.param.is_empty() {
15312 struct_ser.serialize_field("param", &self.param)?;
15313 }
15314 if let Some(v) = self.value.as_ref() {
15315 struct_ser.serialize_field("value", v)?;
15316 }
15317 struct_ser.end()
15318 }
15319}
15320impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
15321 #[allow(deprecated)]
15322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15323 where
15324 D: serde::Deserializer<'de>,
15325 {
15326 const FIELDS: &[&str] = &[
15327 "param",
15328 "value",
15329 ];
15330
15331 #[allow(clippy::enum_variant_names)]
15332 enum GeneratedField {
15333 Param,
15334 Value,
15335 }
15336 impl<'de> serde::Deserialize<'de> for GeneratedField {
15337 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15338 where
15339 D: serde::Deserializer<'de>,
15340 {
15341 struct GeneratedVisitor;
15342
15343 impl serde::de::Visitor<'_> for GeneratedVisitor {
15344 type Value = GeneratedField;
15345
15346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15347 write!(formatter, "expected one of: {:?}", &FIELDS)
15348 }
15349
15350 #[allow(unused_variables)]
15351 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15352 where
15353 E: serde::de::Error,
15354 {
15355 match value {
15356 "param" => Ok(GeneratedField::Param),
15357 "value" => Ok(GeneratedField::Value),
15358 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15359 }
15360 }
15361 }
15362 deserializer.deserialize_identifier(GeneratedVisitor)
15363 }
15364 }
15365 struct GeneratedVisitor;
15366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15367 type Value = SetSystemParamRequest;
15368
15369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15370 formatter.write_str("struct meta.SetSystemParamRequest")
15371 }
15372
15373 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
15374 where
15375 V: serde::de::MapAccess<'de>,
15376 {
15377 let mut param__ = None;
15378 let mut value__ = None;
15379 while let Some(k) = map_.next_key()? {
15380 match k {
15381 GeneratedField::Param => {
15382 if param__.is_some() {
15383 return Err(serde::de::Error::duplicate_field("param"));
15384 }
15385 param__ = Some(map_.next_value()?);
15386 }
15387 GeneratedField::Value => {
15388 if value__.is_some() {
15389 return Err(serde::de::Error::duplicate_field("value"));
15390 }
15391 value__ = map_.next_value()?;
15392 }
15393 }
15394 }
15395 Ok(SetSystemParamRequest {
15396 param: param__.unwrap_or_default(),
15397 value: value__,
15398 })
15399 }
15400 }
15401 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
15402 }
15403}
15404impl serde::Serialize for SetSystemParamResponse {
15405 #[allow(deprecated)]
15406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15407 where
15408 S: serde::Serializer,
15409 {
15410 use serde::ser::SerializeStruct;
15411 let mut len = 0;
15412 if self.params.is_some() {
15413 len += 1;
15414 }
15415 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
15416 if let Some(v) = self.params.as_ref() {
15417 struct_ser.serialize_field("params", v)?;
15418 }
15419 struct_ser.end()
15420 }
15421}
15422impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
15423 #[allow(deprecated)]
15424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15425 where
15426 D: serde::Deserializer<'de>,
15427 {
15428 const FIELDS: &[&str] = &[
15429 "params",
15430 ];
15431
15432 #[allow(clippy::enum_variant_names)]
15433 enum GeneratedField {
15434 Params,
15435 }
15436 impl<'de> serde::Deserialize<'de> for GeneratedField {
15437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15438 where
15439 D: serde::Deserializer<'de>,
15440 {
15441 struct GeneratedVisitor;
15442
15443 impl serde::de::Visitor<'_> for GeneratedVisitor {
15444 type Value = GeneratedField;
15445
15446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15447 write!(formatter, "expected one of: {:?}", &FIELDS)
15448 }
15449
15450 #[allow(unused_variables)]
15451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15452 where
15453 E: serde::de::Error,
15454 {
15455 match value {
15456 "params" => Ok(GeneratedField::Params),
15457 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15458 }
15459 }
15460 }
15461 deserializer.deserialize_identifier(GeneratedVisitor)
15462 }
15463 }
15464 struct GeneratedVisitor;
15465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15466 type Value = SetSystemParamResponse;
15467
15468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15469 formatter.write_str("struct meta.SetSystemParamResponse")
15470 }
15471
15472 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
15473 where
15474 V: serde::de::MapAccess<'de>,
15475 {
15476 let mut params__ = None;
15477 while let Some(k) = map_.next_key()? {
15478 match k {
15479 GeneratedField::Params => {
15480 if params__.is_some() {
15481 return Err(serde::de::Error::duplicate_field("params"));
15482 }
15483 params__ = map_.next_value()?;
15484 }
15485 }
15486 }
15487 Ok(SetSystemParamResponse {
15488 params: params__,
15489 })
15490 }
15491 }
15492 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
15493 }
15494}
15495impl serde::Serialize for SubscribeRequest {
15496 #[allow(deprecated)]
15497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15498 where
15499 S: serde::Serializer,
15500 {
15501 use serde::ser::SerializeStruct;
15502 let mut len = 0;
15503 if self.subscribe_type != 0 {
15504 len += 1;
15505 }
15506 if self.host.is_some() {
15507 len += 1;
15508 }
15509 if self.worker_id != 0 {
15510 len += 1;
15511 }
15512 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
15513 if self.subscribe_type != 0 {
15514 let v = SubscribeType::try_from(self.subscribe_type)
15515 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
15516 struct_ser.serialize_field("subscribeType", &v)?;
15517 }
15518 if let Some(v) = self.host.as_ref() {
15519 struct_ser.serialize_field("host", v)?;
15520 }
15521 if self.worker_id != 0 {
15522 struct_ser.serialize_field("workerId", &self.worker_id)?;
15523 }
15524 struct_ser.end()
15525 }
15526}
15527impl<'de> serde::Deserialize<'de> for SubscribeRequest {
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 "subscribe_type",
15535 "subscribeType",
15536 "host",
15537 "worker_id",
15538 "workerId",
15539 ];
15540
15541 #[allow(clippy::enum_variant_names)]
15542 enum GeneratedField {
15543 SubscribeType,
15544 Host,
15545 WorkerId,
15546 }
15547 impl<'de> serde::Deserialize<'de> for GeneratedField {
15548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15549 where
15550 D: serde::Deserializer<'de>,
15551 {
15552 struct GeneratedVisitor;
15553
15554 impl serde::de::Visitor<'_> for GeneratedVisitor {
15555 type Value = GeneratedField;
15556
15557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15558 write!(formatter, "expected one of: {:?}", &FIELDS)
15559 }
15560
15561 #[allow(unused_variables)]
15562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15563 where
15564 E: serde::de::Error,
15565 {
15566 match value {
15567 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
15568 "host" => Ok(GeneratedField::Host),
15569 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
15570 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15571 }
15572 }
15573 }
15574 deserializer.deserialize_identifier(GeneratedVisitor)
15575 }
15576 }
15577 struct GeneratedVisitor;
15578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15579 type Value = SubscribeRequest;
15580
15581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15582 formatter.write_str("struct meta.SubscribeRequest")
15583 }
15584
15585 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
15586 where
15587 V: serde::de::MapAccess<'de>,
15588 {
15589 let mut subscribe_type__ = None;
15590 let mut host__ = None;
15591 let mut worker_id__ = None;
15592 while let Some(k) = map_.next_key()? {
15593 match k {
15594 GeneratedField::SubscribeType => {
15595 if subscribe_type__.is_some() {
15596 return Err(serde::de::Error::duplicate_field("subscribeType"));
15597 }
15598 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
15599 }
15600 GeneratedField::Host => {
15601 if host__.is_some() {
15602 return Err(serde::de::Error::duplicate_field("host"));
15603 }
15604 host__ = map_.next_value()?;
15605 }
15606 GeneratedField::WorkerId => {
15607 if worker_id__.is_some() {
15608 return Err(serde::de::Error::duplicate_field("workerId"));
15609 }
15610 worker_id__ =
15611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15612 ;
15613 }
15614 }
15615 }
15616 Ok(SubscribeRequest {
15617 subscribe_type: subscribe_type__.unwrap_or_default(),
15618 host: host__,
15619 worker_id: worker_id__.unwrap_or_default(),
15620 })
15621 }
15622 }
15623 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
15624 }
15625}
15626impl serde::Serialize for SubscribeResponse {
15627 #[allow(deprecated)]
15628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15629 where
15630 S: serde::Serializer,
15631 {
15632 use serde::ser::SerializeStruct;
15633 let mut len = 0;
15634 if self.status.is_some() {
15635 len += 1;
15636 }
15637 if self.operation != 0 {
15638 len += 1;
15639 }
15640 if self.version != 0 {
15641 len += 1;
15642 }
15643 if self.info.is_some() {
15644 len += 1;
15645 }
15646 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
15647 if let Some(v) = self.status.as_ref() {
15648 struct_ser.serialize_field("status", v)?;
15649 }
15650 if self.operation != 0 {
15651 let v = subscribe_response::Operation::try_from(self.operation)
15652 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
15653 struct_ser.serialize_field("operation", &v)?;
15654 }
15655 if self.version != 0 {
15656 #[allow(clippy::needless_borrow)]
15657 #[allow(clippy::needless_borrows_for_generic_args)]
15658 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
15659 }
15660 if let Some(v) = self.info.as_ref() {
15661 match v {
15662 subscribe_response::Info::Database(v) => {
15663 struct_ser.serialize_field("database", v)?;
15664 }
15665 subscribe_response::Info::Schema(v) => {
15666 struct_ser.serialize_field("schema", v)?;
15667 }
15668 subscribe_response::Info::Function(v) => {
15669 struct_ser.serialize_field("function", v)?;
15670 }
15671 subscribe_response::Info::User(v) => {
15672 struct_ser.serialize_field("user", v)?;
15673 }
15674 subscribe_response::Info::SessionParam(v) => {
15675 struct_ser.serialize_field("sessionParam", v)?;
15676 }
15677 subscribe_response::Info::Node(v) => {
15678 struct_ser.serialize_field("node", v)?;
15679 }
15680 subscribe_response::Info::HummockVersionDeltas(v) => {
15681 struct_ser.serialize_field("hummockVersionDeltas", v)?;
15682 }
15683 subscribe_response::Info::Snapshot(v) => {
15684 struct_ser.serialize_field("snapshot", v)?;
15685 }
15686 subscribe_response::Info::MetaBackupManifestId(v) => {
15687 struct_ser.serialize_field("metaBackupManifestId", v)?;
15688 }
15689 subscribe_response::Info::SystemParams(v) => {
15690 struct_ser.serialize_field("systemParams", v)?;
15691 }
15692 subscribe_response::Info::HummockWriteLimits(v) => {
15693 struct_ser.serialize_field("hummockWriteLimits", v)?;
15694 }
15695 subscribe_response::Info::ObjectGroup(v) => {
15696 struct_ser.serialize_field("objectGroup", v)?;
15697 }
15698 subscribe_response::Info::Connection(v) => {
15699 struct_ser.serialize_field("connection", v)?;
15700 }
15701 subscribe_response::Info::HummockStats(v) => {
15702 struct_ser.serialize_field("hummockStats", v)?;
15703 }
15704 subscribe_response::Info::Recovery(v) => {
15705 struct_ser.serialize_field("recovery", v)?;
15706 }
15707 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
15708 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
15709 }
15710 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
15711 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
15712 }
15713 subscribe_response::Info::Secret(v) => {
15714 struct_ser.serialize_field("secret", v)?;
15715 }
15716 subscribe_response::Info::ClusterResource(v) => {
15717 struct_ser.serialize_field("clusterResource", v)?;
15718 }
15719 }
15720 }
15721 struct_ser.end()
15722 }
15723}
15724impl<'de> serde::Deserialize<'de> for SubscribeResponse {
15725 #[allow(deprecated)]
15726 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15727 where
15728 D: serde::Deserializer<'de>,
15729 {
15730 const FIELDS: &[&str] = &[
15731 "status",
15732 "operation",
15733 "version",
15734 "database",
15735 "schema",
15736 "function",
15737 "user",
15738 "session_param",
15739 "sessionParam",
15740 "node",
15741 "hummock_version_deltas",
15742 "hummockVersionDeltas",
15743 "snapshot",
15744 "meta_backup_manifest_id",
15745 "metaBackupManifestId",
15746 "system_params",
15747 "systemParams",
15748 "hummock_write_limits",
15749 "hummockWriteLimits",
15750 "object_group",
15751 "objectGroup",
15752 "connection",
15753 "hummock_stats",
15754 "hummockStats",
15755 "recovery",
15756 "streaming_worker_slot_mapping",
15757 "streamingWorkerSlotMapping",
15758 "serving_worker_slot_mappings",
15759 "servingWorkerSlotMappings",
15760 "secret",
15761 "cluster_resource",
15762 "clusterResource",
15763 ];
15764
15765 #[allow(clippy::enum_variant_names)]
15766 enum GeneratedField {
15767 Status,
15768 Operation,
15769 Version,
15770 Database,
15771 Schema,
15772 Function,
15773 User,
15774 SessionParam,
15775 Node,
15776 HummockVersionDeltas,
15777 Snapshot,
15778 MetaBackupManifestId,
15779 SystemParams,
15780 HummockWriteLimits,
15781 ObjectGroup,
15782 Connection,
15783 HummockStats,
15784 Recovery,
15785 StreamingWorkerSlotMapping,
15786 ServingWorkerSlotMappings,
15787 Secret,
15788 ClusterResource,
15789 }
15790 impl<'de> serde::Deserialize<'de> for GeneratedField {
15791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15792 where
15793 D: serde::Deserializer<'de>,
15794 {
15795 struct GeneratedVisitor;
15796
15797 impl serde::de::Visitor<'_> for GeneratedVisitor {
15798 type Value = GeneratedField;
15799
15800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15801 write!(formatter, "expected one of: {:?}", &FIELDS)
15802 }
15803
15804 #[allow(unused_variables)]
15805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15806 where
15807 E: serde::de::Error,
15808 {
15809 match value {
15810 "status" => Ok(GeneratedField::Status),
15811 "operation" => Ok(GeneratedField::Operation),
15812 "version" => Ok(GeneratedField::Version),
15813 "database" => Ok(GeneratedField::Database),
15814 "schema" => Ok(GeneratedField::Schema),
15815 "function" => Ok(GeneratedField::Function),
15816 "user" => Ok(GeneratedField::User),
15817 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
15818 "node" => Ok(GeneratedField::Node),
15819 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
15820 "snapshot" => Ok(GeneratedField::Snapshot),
15821 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
15822 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
15823 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
15824 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
15825 "connection" => Ok(GeneratedField::Connection),
15826 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
15827 "recovery" => Ok(GeneratedField::Recovery),
15828 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
15829 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
15830 "secret" => Ok(GeneratedField::Secret),
15831 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
15832 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15833 }
15834 }
15835 }
15836 deserializer.deserialize_identifier(GeneratedVisitor)
15837 }
15838 }
15839 struct GeneratedVisitor;
15840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15841 type Value = SubscribeResponse;
15842
15843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15844 formatter.write_str("struct meta.SubscribeResponse")
15845 }
15846
15847 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
15848 where
15849 V: serde::de::MapAccess<'de>,
15850 {
15851 let mut status__ = None;
15852 let mut operation__ = None;
15853 let mut version__ = None;
15854 let mut info__ = None;
15855 while let Some(k) = map_.next_key()? {
15856 match k {
15857 GeneratedField::Status => {
15858 if status__.is_some() {
15859 return Err(serde::de::Error::duplicate_field("status"));
15860 }
15861 status__ = map_.next_value()?;
15862 }
15863 GeneratedField::Operation => {
15864 if operation__.is_some() {
15865 return Err(serde::de::Error::duplicate_field("operation"));
15866 }
15867 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
15868 }
15869 GeneratedField::Version => {
15870 if version__.is_some() {
15871 return Err(serde::de::Error::duplicate_field("version"));
15872 }
15873 version__ =
15874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15875 ;
15876 }
15877 GeneratedField::Database => {
15878 if info__.is_some() {
15879 return Err(serde::de::Error::duplicate_field("database"));
15880 }
15881 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
15882;
15883 }
15884 GeneratedField::Schema => {
15885 if info__.is_some() {
15886 return Err(serde::de::Error::duplicate_field("schema"));
15887 }
15888 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
15889;
15890 }
15891 GeneratedField::Function => {
15892 if info__.is_some() {
15893 return Err(serde::de::Error::duplicate_field("function"));
15894 }
15895 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
15896;
15897 }
15898 GeneratedField::User => {
15899 if info__.is_some() {
15900 return Err(serde::de::Error::duplicate_field("user"));
15901 }
15902 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
15903;
15904 }
15905 GeneratedField::SessionParam => {
15906 if info__.is_some() {
15907 return Err(serde::de::Error::duplicate_field("sessionParam"));
15908 }
15909 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
15910;
15911 }
15912 GeneratedField::Node => {
15913 if info__.is_some() {
15914 return Err(serde::de::Error::duplicate_field("node"));
15915 }
15916 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
15917;
15918 }
15919 GeneratedField::HummockVersionDeltas => {
15920 if info__.is_some() {
15921 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
15922 }
15923 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
15924;
15925 }
15926 GeneratedField::Snapshot => {
15927 if info__.is_some() {
15928 return Err(serde::de::Error::duplicate_field("snapshot"));
15929 }
15930 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
15931;
15932 }
15933 GeneratedField::MetaBackupManifestId => {
15934 if info__.is_some() {
15935 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
15936 }
15937 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
15938;
15939 }
15940 GeneratedField::SystemParams => {
15941 if info__.is_some() {
15942 return Err(serde::de::Error::duplicate_field("systemParams"));
15943 }
15944 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
15945;
15946 }
15947 GeneratedField::HummockWriteLimits => {
15948 if info__.is_some() {
15949 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
15950 }
15951 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
15952;
15953 }
15954 GeneratedField::ObjectGroup => {
15955 if info__.is_some() {
15956 return Err(serde::de::Error::duplicate_field("objectGroup"));
15957 }
15958 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
15959;
15960 }
15961 GeneratedField::Connection => {
15962 if info__.is_some() {
15963 return Err(serde::de::Error::duplicate_field("connection"));
15964 }
15965 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
15966;
15967 }
15968 GeneratedField::HummockStats => {
15969 if info__.is_some() {
15970 return Err(serde::de::Error::duplicate_field("hummockStats"));
15971 }
15972 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
15973;
15974 }
15975 GeneratedField::Recovery => {
15976 if info__.is_some() {
15977 return Err(serde::de::Error::duplicate_field("recovery"));
15978 }
15979 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
15980;
15981 }
15982 GeneratedField::StreamingWorkerSlotMapping => {
15983 if info__.is_some() {
15984 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
15985 }
15986 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
15987;
15988 }
15989 GeneratedField::ServingWorkerSlotMappings => {
15990 if info__.is_some() {
15991 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
15992 }
15993 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
15994;
15995 }
15996 GeneratedField::Secret => {
15997 if info__.is_some() {
15998 return Err(serde::de::Error::duplicate_field("secret"));
15999 }
16000 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
16001;
16002 }
16003 GeneratedField::ClusterResource => {
16004 if info__.is_some() {
16005 return Err(serde::de::Error::duplicate_field("clusterResource"));
16006 }
16007 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
16008;
16009 }
16010 }
16011 }
16012 Ok(SubscribeResponse {
16013 status: status__,
16014 operation: operation__.unwrap_or_default(),
16015 version: version__.unwrap_or_default(),
16016 info: info__,
16017 })
16018 }
16019 }
16020 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
16021 }
16022}
16023impl serde::Serialize for subscribe_response::Operation {
16024 #[allow(deprecated)]
16025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16026 where
16027 S: serde::Serializer,
16028 {
16029 let variant = match self {
16030 Self::Unspecified => "UNSPECIFIED",
16031 Self::Add => "ADD",
16032 Self::Delete => "DELETE",
16033 Self::Update => "UPDATE",
16034 Self::Snapshot => "SNAPSHOT",
16035 };
16036 serializer.serialize_str(variant)
16037 }
16038}
16039impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
16040 #[allow(deprecated)]
16041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16042 where
16043 D: serde::Deserializer<'de>,
16044 {
16045 const FIELDS: &[&str] = &[
16046 "UNSPECIFIED",
16047 "ADD",
16048 "DELETE",
16049 "UPDATE",
16050 "SNAPSHOT",
16051 ];
16052
16053 struct GeneratedVisitor;
16054
16055 impl serde::de::Visitor<'_> for GeneratedVisitor {
16056 type Value = subscribe_response::Operation;
16057
16058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16059 write!(formatter, "expected one of: {:?}", &FIELDS)
16060 }
16061
16062 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16063 where
16064 E: serde::de::Error,
16065 {
16066 i32::try_from(v)
16067 .ok()
16068 .and_then(|x| x.try_into().ok())
16069 .ok_or_else(|| {
16070 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16071 })
16072 }
16073
16074 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16075 where
16076 E: serde::de::Error,
16077 {
16078 i32::try_from(v)
16079 .ok()
16080 .and_then(|x| x.try_into().ok())
16081 .ok_or_else(|| {
16082 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16083 })
16084 }
16085
16086 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16087 where
16088 E: serde::de::Error,
16089 {
16090 match value {
16091 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
16092 "ADD" => Ok(subscribe_response::Operation::Add),
16093 "DELETE" => Ok(subscribe_response::Operation::Delete),
16094 "UPDATE" => Ok(subscribe_response::Operation::Update),
16095 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
16096 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16097 }
16098 }
16099 }
16100 deserializer.deserialize_any(GeneratedVisitor)
16101 }
16102}
16103impl serde::Serialize for SubscribeType {
16104 #[allow(deprecated)]
16105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16106 where
16107 S: serde::Serializer,
16108 {
16109 let variant = match self {
16110 Self::Unspecified => "UNSPECIFIED",
16111 Self::Frontend => "FRONTEND",
16112 Self::Hummock => "HUMMOCK",
16113 Self::Compactor => "COMPACTOR",
16114 Self::Compute => "COMPUTE",
16115 };
16116 serializer.serialize_str(variant)
16117 }
16118}
16119impl<'de> serde::Deserialize<'de> for SubscribeType {
16120 #[allow(deprecated)]
16121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16122 where
16123 D: serde::Deserializer<'de>,
16124 {
16125 const FIELDS: &[&str] = &[
16126 "UNSPECIFIED",
16127 "FRONTEND",
16128 "HUMMOCK",
16129 "COMPACTOR",
16130 "COMPUTE",
16131 ];
16132
16133 struct GeneratedVisitor;
16134
16135 impl serde::de::Visitor<'_> for GeneratedVisitor {
16136 type Value = SubscribeType;
16137
16138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16139 write!(formatter, "expected one of: {:?}", &FIELDS)
16140 }
16141
16142 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16143 where
16144 E: serde::de::Error,
16145 {
16146 i32::try_from(v)
16147 .ok()
16148 .and_then(|x| x.try_into().ok())
16149 .ok_or_else(|| {
16150 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16151 })
16152 }
16153
16154 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16155 where
16156 E: serde::de::Error,
16157 {
16158 i32::try_from(v)
16159 .ok()
16160 .and_then(|x| x.try_into().ok())
16161 .ok_or_else(|| {
16162 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16163 })
16164 }
16165
16166 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16167 where
16168 E: serde::de::Error,
16169 {
16170 match value {
16171 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
16172 "FRONTEND" => Ok(SubscribeType::Frontend),
16173 "HUMMOCK" => Ok(SubscribeType::Hummock),
16174 "COMPACTOR" => Ok(SubscribeType::Compactor),
16175 "COMPUTE" => Ok(SubscribeType::Compute),
16176 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16177 }
16178 }
16179 }
16180 deserializer.deserialize_any(GeneratedVisitor)
16181 }
16182}
16183impl serde::Serialize for SystemParams {
16184 #[allow(deprecated)]
16185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16186 where
16187 S: serde::Serializer,
16188 {
16189 use serde::ser::SerializeStruct;
16190 let mut len = 0;
16191 if self.barrier_interval_ms.is_some() {
16192 len += 1;
16193 }
16194 if self.checkpoint_frequency.is_some() {
16195 len += 1;
16196 }
16197 if self.sstable_size_mb.is_some() {
16198 len += 1;
16199 }
16200 if self.block_size_kb.is_some() {
16201 len += 1;
16202 }
16203 if self.bloom_false_positive.is_some() {
16204 len += 1;
16205 }
16206 if self.state_store.is_some() {
16207 len += 1;
16208 }
16209 if self.data_directory.is_some() {
16210 len += 1;
16211 }
16212 if self.backup_storage_url.is_some() {
16213 len += 1;
16214 }
16215 if self.backup_storage_directory.is_some() {
16216 len += 1;
16217 }
16218 if self.telemetry_enabled.is_some() {
16219 len += 1;
16220 }
16221 if self.parallel_compact_size_mb.is_some() {
16222 len += 1;
16223 }
16224 if self.max_concurrent_creating_streaming_jobs.is_some() {
16225 len += 1;
16226 }
16227 if self.pause_on_next_bootstrap.is_some() {
16228 len += 1;
16229 }
16230 if self.wasm_storage_url.is_some() {
16231 len += 1;
16232 }
16233 if self.enable_tracing.is_some() {
16234 len += 1;
16235 }
16236 if self.use_new_object_prefix_strategy.is_some() {
16237 len += 1;
16238 }
16239 if self.license_key.is_some() {
16240 len += 1;
16241 }
16242 if self.time_travel_retention_ms.is_some() {
16243 len += 1;
16244 }
16245 if self.adaptive_parallelism_strategy.is_some() {
16246 len += 1;
16247 }
16248 if self.per_database_isolation.is_some() {
16249 len += 1;
16250 }
16251 if self.enforce_secret.is_some() {
16252 len += 1;
16253 }
16254 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
16255 if let Some(v) = self.barrier_interval_ms.as_ref() {
16256 struct_ser.serialize_field("barrierIntervalMs", v)?;
16257 }
16258 if let Some(v) = self.checkpoint_frequency.as_ref() {
16259 #[allow(clippy::needless_borrow)]
16260 #[allow(clippy::needless_borrows_for_generic_args)]
16261 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
16262 }
16263 if let Some(v) = self.sstable_size_mb.as_ref() {
16264 struct_ser.serialize_field("sstableSizeMb", v)?;
16265 }
16266 if let Some(v) = self.block_size_kb.as_ref() {
16267 struct_ser.serialize_field("blockSizeKb", v)?;
16268 }
16269 if let Some(v) = self.bloom_false_positive.as_ref() {
16270 struct_ser.serialize_field("bloomFalsePositive", v)?;
16271 }
16272 if let Some(v) = self.state_store.as_ref() {
16273 struct_ser.serialize_field("stateStore", v)?;
16274 }
16275 if let Some(v) = self.data_directory.as_ref() {
16276 struct_ser.serialize_field("dataDirectory", v)?;
16277 }
16278 if let Some(v) = self.backup_storage_url.as_ref() {
16279 struct_ser.serialize_field("backupStorageUrl", v)?;
16280 }
16281 if let Some(v) = self.backup_storage_directory.as_ref() {
16282 struct_ser.serialize_field("backupStorageDirectory", v)?;
16283 }
16284 if let Some(v) = self.telemetry_enabled.as_ref() {
16285 struct_ser.serialize_field("telemetryEnabled", v)?;
16286 }
16287 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
16288 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
16289 }
16290 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
16291 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
16292 }
16293 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
16294 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
16295 }
16296 if let Some(v) = self.wasm_storage_url.as_ref() {
16297 struct_ser.serialize_field("wasmStorageUrl", v)?;
16298 }
16299 if let Some(v) = self.enable_tracing.as_ref() {
16300 struct_ser.serialize_field("enableTracing", v)?;
16301 }
16302 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
16303 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
16304 }
16305 if let Some(v) = self.license_key.as_ref() {
16306 struct_ser.serialize_field("licenseKey", v)?;
16307 }
16308 if let Some(v) = self.time_travel_retention_ms.as_ref() {
16309 #[allow(clippy::needless_borrow)]
16310 #[allow(clippy::needless_borrows_for_generic_args)]
16311 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
16312 }
16313 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
16314 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
16315 }
16316 if let Some(v) = self.per_database_isolation.as_ref() {
16317 struct_ser.serialize_field("perDatabaseIsolation", v)?;
16318 }
16319 if let Some(v) = self.enforce_secret.as_ref() {
16320 struct_ser.serialize_field("enforceSecret", v)?;
16321 }
16322 struct_ser.end()
16323 }
16324}
16325impl<'de> serde::Deserialize<'de> for SystemParams {
16326 #[allow(deprecated)]
16327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16328 where
16329 D: serde::Deserializer<'de>,
16330 {
16331 const FIELDS: &[&str] = &[
16332 "barrier_interval_ms",
16333 "barrierIntervalMs",
16334 "checkpoint_frequency",
16335 "checkpointFrequency",
16336 "sstable_size_mb",
16337 "sstableSizeMb",
16338 "block_size_kb",
16339 "blockSizeKb",
16340 "bloom_false_positive",
16341 "bloomFalsePositive",
16342 "state_store",
16343 "stateStore",
16344 "data_directory",
16345 "dataDirectory",
16346 "backup_storage_url",
16347 "backupStorageUrl",
16348 "backup_storage_directory",
16349 "backupStorageDirectory",
16350 "telemetry_enabled",
16351 "telemetryEnabled",
16352 "parallel_compact_size_mb",
16353 "parallelCompactSizeMb",
16354 "max_concurrent_creating_streaming_jobs",
16355 "maxConcurrentCreatingStreamingJobs",
16356 "pause_on_next_bootstrap",
16357 "pauseOnNextBootstrap",
16358 "wasm_storage_url",
16359 "wasmStorageUrl",
16360 "enable_tracing",
16361 "enableTracing",
16362 "use_new_object_prefix_strategy",
16363 "useNewObjectPrefixStrategy",
16364 "license_key",
16365 "licenseKey",
16366 "time_travel_retention_ms",
16367 "timeTravelRetentionMs",
16368 "adaptive_parallelism_strategy",
16369 "adaptiveParallelismStrategy",
16370 "per_database_isolation",
16371 "perDatabaseIsolation",
16372 "enforce_secret",
16373 "enforceSecret",
16374 ];
16375
16376 #[allow(clippy::enum_variant_names)]
16377 enum GeneratedField {
16378 BarrierIntervalMs,
16379 CheckpointFrequency,
16380 SstableSizeMb,
16381 BlockSizeKb,
16382 BloomFalsePositive,
16383 StateStore,
16384 DataDirectory,
16385 BackupStorageUrl,
16386 BackupStorageDirectory,
16387 TelemetryEnabled,
16388 ParallelCompactSizeMb,
16389 MaxConcurrentCreatingStreamingJobs,
16390 PauseOnNextBootstrap,
16391 WasmStorageUrl,
16392 EnableTracing,
16393 UseNewObjectPrefixStrategy,
16394 LicenseKey,
16395 TimeTravelRetentionMs,
16396 AdaptiveParallelismStrategy,
16397 PerDatabaseIsolation,
16398 EnforceSecret,
16399 }
16400 impl<'de> serde::Deserialize<'de> for GeneratedField {
16401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16402 where
16403 D: serde::Deserializer<'de>,
16404 {
16405 struct GeneratedVisitor;
16406
16407 impl serde::de::Visitor<'_> for GeneratedVisitor {
16408 type Value = GeneratedField;
16409
16410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16411 write!(formatter, "expected one of: {:?}", &FIELDS)
16412 }
16413
16414 #[allow(unused_variables)]
16415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16416 where
16417 E: serde::de::Error,
16418 {
16419 match value {
16420 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
16421 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
16422 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
16423 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
16424 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
16425 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
16426 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
16427 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
16428 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
16429 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
16430 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
16431 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
16432 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
16433 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
16434 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
16435 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
16436 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
16437 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
16438 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
16439 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
16440 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
16441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16442 }
16443 }
16444 }
16445 deserializer.deserialize_identifier(GeneratedVisitor)
16446 }
16447 }
16448 struct GeneratedVisitor;
16449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16450 type Value = SystemParams;
16451
16452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16453 formatter.write_str("struct meta.SystemParams")
16454 }
16455
16456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
16457 where
16458 V: serde::de::MapAccess<'de>,
16459 {
16460 let mut barrier_interval_ms__ = None;
16461 let mut checkpoint_frequency__ = None;
16462 let mut sstable_size_mb__ = None;
16463 let mut block_size_kb__ = None;
16464 let mut bloom_false_positive__ = None;
16465 let mut state_store__ = None;
16466 let mut data_directory__ = None;
16467 let mut backup_storage_url__ = None;
16468 let mut backup_storage_directory__ = None;
16469 let mut telemetry_enabled__ = None;
16470 let mut parallel_compact_size_mb__ = None;
16471 let mut max_concurrent_creating_streaming_jobs__ = None;
16472 let mut pause_on_next_bootstrap__ = None;
16473 let mut wasm_storage_url__ = None;
16474 let mut enable_tracing__ = None;
16475 let mut use_new_object_prefix_strategy__ = None;
16476 let mut license_key__ = None;
16477 let mut time_travel_retention_ms__ = None;
16478 let mut adaptive_parallelism_strategy__ = None;
16479 let mut per_database_isolation__ = None;
16480 let mut enforce_secret__ = None;
16481 while let Some(k) = map_.next_key()? {
16482 match k {
16483 GeneratedField::BarrierIntervalMs => {
16484 if barrier_interval_ms__.is_some() {
16485 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
16486 }
16487 barrier_interval_ms__ =
16488 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16489 ;
16490 }
16491 GeneratedField::CheckpointFrequency => {
16492 if checkpoint_frequency__.is_some() {
16493 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
16494 }
16495 checkpoint_frequency__ =
16496 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16497 ;
16498 }
16499 GeneratedField::SstableSizeMb => {
16500 if sstable_size_mb__.is_some() {
16501 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
16502 }
16503 sstable_size_mb__ =
16504 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16505 ;
16506 }
16507 GeneratedField::BlockSizeKb => {
16508 if block_size_kb__.is_some() {
16509 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
16510 }
16511 block_size_kb__ =
16512 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16513 ;
16514 }
16515 GeneratedField::BloomFalsePositive => {
16516 if bloom_false_positive__.is_some() {
16517 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
16518 }
16519 bloom_false_positive__ =
16520 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16521 ;
16522 }
16523 GeneratedField::StateStore => {
16524 if state_store__.is_some() {
16525 return Err(serde::de::Error::duplicate_field("stateStore"));
16526 }
16527 state_store__ = map_.next_value()?;
16528 }
16529 GeneratedField::DataDirectory => {
16530 if data_directory__.is_some() {
16531 return Err(serde::de::Error::duplicate_field("dataDirectory"));
16532 }
16533 data_directory__ = map_.next_value()?;
16534 }
16535 GeneratedField::BackupStorageUrl => {
16536 if backup_storage_url__.is_some() {
16537 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
16538 }
16539 backup_storage_url__ = map_.next_value()?;
16540 }
16541 GeneratedField::BackupStorageDirectory => {
16542 if backup_storage_directory__.is_some() {
16543 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
16544 }
16545 backup_storage_directory__ = map_.next_value()?;
16546 }
16547 GeneratedField::TelemetryEnabled => {
16548 if telemetry_enabled__.is_some() {
16549 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
16550 }
16551 telemetry_enabled__ = map_.next_value()?;
16552 }
16553 GeneratedField::ParallelCompactSizeMb => {
16554 if parallel_compact_size_mb__.is_some() {
16555 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
16556 }
16557 parallel_compact_size_mb__ =
16558 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16559 ;
16560 }
16561 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
16562 if max_concurrent_creating_streaming_jobs__.is_some() {
16563 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
16564 }
16565 max_concurrent_creating_streaming_jobs__ =
16566 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16567 ;
16568 }
16569 GeneratedField::PauseOnNextBootstrap => {
16570 if pause_on_next_bootstrap__.is_some() {
16571 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
16572 }
16573 pause_on_next_bootstrap__ = map_.next_value()?;
16574 }
16575 GeneratedField::WasmStorageUrl => {
16576 if wasm_storage_url__.is_some() {
16577 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
16578 }
16579 wasm_storage_url__ = map_.next_value()?;
16580 }
16581 GeneratedField::EnableTracing => {
16582 if enable_tracing__.is_some() {
16583 return Err(serde::de::Error::duplicate_field("enableTracing"));
16584 }
16585 enable_tracing__ = map_.next_value()?;
16586 }
16587 GeneratedField::UseNewObjectPrefixStrategy => {
16588 if use_new_object_prefix_strategy__.is_some() {
16589 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
16590 }
16591 use_new_object_prefix_strategy__ = map_.next_value()?;
16592 }
16593 GeneratedField::LicenseKey => {
16594 if license_key__.is_some() {
16595 return Err(serde::de::Error::duplicate_field("licenseKey"));
16596 }
16597 license_key__ = map_.next_value()?;
16598 }
16599 GeneratedField::TimeTravelRetentionMs => {
16600 if time_travel_retention_ms__.is_some() {
16601 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
16602 }
16603 time_travel_retention_ms__ =
16604 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16605 ;
16606 }
16607 GeneratedField::AdaptiveParallelismStrategy => {
16608 if adaptive_parallelism_strategy__.is_some() {
16609 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
16610 }
16611 adaptive_parallelism_strategy__ = map_.next_value()?;
16612 }
16613 GeneratedField::PerDatabaseIsolation => {
16614 if per_database_isolation__.is_some() {
16615 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
16616 }
16617 per_database_isolation__ = map_.next_value()?;
16618 }
16619 GeneratedField::EnforceSecret => {
16620 if enforce_secret__.is_some() {
16621 return Err(serde::de::Error::duplicate_field("enforceSecret"));
16622 }
16623 enforce_secret__ = map_.next_value()?;
16624 }
16625 }
16626 }
16627 Ok(SystemParams {
16628 barrier_interval_ms: barrier_interval_ms__,
16629 checkpoint_frequency: checkpoint_frequency__,
16630 sstable_size_mb: sstable_size_mb__,
16631 block_size_kb: block_size_kb__,
16632 bloom_false_positive: bloom_false_positive__,
16633 state_store: state_store__,
16634 data_directory: data_directory__,
16635 backup_storage_url: backup_storage_url__,
16636 backup_storage_directory: backup_storage_directory__,
16637 telemetry_enabled: telemetry_enabled__,
16638 parallel_compact_size_mb: parallel_compact_size_mb__,
16639 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
16640 pause_on_next_bootstrap: pause_on_next_bootstrap__,
16641 wasm_storage_url: wasm_storage_url__,
16642 enable_tracing: enable_tracing__,
16643 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
16644 license_key: license_key__,
16645 time_travel_retention_ms: time_travel_retention_ms__,
16646 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
16647 per_database_isolation: per_database_isolation__,
16648 enforce_secret: enforce_secret__,
16649 })
16650 }
16651 }
16652 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
16653 }
16654}
16655impl serde::Serialize for TableFragments {
16656 #[allow(deprecated)]
16657 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16658 where
16659 S: serde::Serializer,
16660 {
16661 use serde::ser::SerializeStruct;
16662 let mut len = 0;
16663 if self.table_id != 0 {
16664 len += 1;
16665 }
16666 if self.state != 0 {
16667 len += 1;
16668 }
16669 if !self.fragments.is_empty() {
16670 len += 1;
16671 }
16672 if !self.actor_status.is_empty() {
16673 len += 1;
16674 }
16675 if self.ctx.is_some() {
16676 len += 1;
16677 }
16678 if self.parallelism.is_some() {
16679 len += 1;
16680 }
16681 if self.max_parallelism.is_some() {
16682 len += 1;
16683 }
16684 if !self.node_label.is_empty() {
16685 len += 1;
16686 }
16687 if self.backfill_done {
16688 len += 1;
16689 }
16690 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
16691 if self.table_id != 0 {
16692 struct_ser.serialize_field("tableId", &self.table_id)?;
16693 }
16694 if self.state != 0 {
16695 let v = table_fragments::State::try_from(self.state)
16696 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
16697 struct_ser.serialize_field("state", &v)?;
16698 }
16699 if !self.fragments.is_empty() {
16700 struct_ser.serialize_field("fragments", &self.fragments)?;
16701 }
16702 if !self.actor_status.is_empty() {
16703 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
16704 }
16705 if let Some(v) = self.ctx.as_ref() {
16706 struct_ser.serialize_field("ctx", v)?;
16707 }
16708 if let Some(v) = self.parallelism.as_ref() {
16709 struct_ser.serialize_field("parallelism", v)?;
16710 }
16711 if let Some(v) = self.max_parallelism.as_ref() {
16712 struct_ser.serialize_field("maxParallelism", v)?;
16713 }
16714 if !self.node_label.is_empty() {
16715 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16716 }
16717 if self.backfill_done {
16718 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
16719 }
16720 struct_ser.end()
16721 }
16722}
16723impl<'de> serde::Deserialize<'de> for TableFragments {
16724 #[allow(deprecated)]
16725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16726 where
16727 D: serde::Deserializer<'de>,
16728 {
16729 const FIELDS: &[&str] = &[
16730 "table_id",
16731 "tableId",
16732 "state",
16733 "fragments",
16734 "actor_status",
16735 "actorStatus",
16736 "ctx",
16737 "parallelism",
16738 "max_parallelism",
16739 "maxParallelism",
16740 "node_label",
16741 "nodeLabel",
16742 "backfill_done",
16743 "backfillDone",
16744 ];
16745
16746 #[allow(clippy::enum_variant_names)]
16747 enum GeneratedField {
16748 TableId,
16749 State,
16750 Fragments,
16751 ActorStatus,
16752 Ctx,
16753 Parallelism,
16754 MaxParallelism,
16755 NodeLabel,
16756 BackfillDone,
16757 }
16758 impl<'de> serde::Deserialize<'de> for GeneratedField {
16759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16760 where
16761 D: serde::Deserializer<'de>,
16762 {
16763 struct GeneratedVisitor;
16764
16765 impl serde::de::Visitor<'_> for GeneratedVisitor {
16766 type Value = GeneratedField;
16767
16768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16769 write!(formatter, "expected one of: {:?}", &FIELDS)
16770 }
16771
16772 #[allow(unused_variables)]
16773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16774 where
16775 E: serde::de::Error,
16776 {
16777 match value {
16778 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16779 "state" => Ok(GeneratedField::State),
16780 "fragments" => Ok(GeneratedField::Fragments),
16781 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
16782 "ctx" => Ok(GeneratedField::Ctx),
16783 "parallelism" => Ok(GeneratedField::Parallelism),
16784 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
16785 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16786 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
16787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16788 }
16789 }
16790 }
16791 deserializer.deserialize_identifier(GeneratedVisitor)
16792 }
16793 }
16794 struct GeneratedVisitor;
16795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16796 type Value = TableFragments;
16797
16798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16799 formatter.write_str("struct meta.TableFragments")
16800 }
16801
16802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
16803 where
16804 V: serde::de::MapAccess<'de>,
16805 {
16806 let mut table_id__ = None;
16807 let mut state__ = None;
16808 let mut fragments__ = None;
16809 let mut actor_status__ = None;
16810 let mut ctx__ = None;
16811 let mut parallelism__ = None;
16812 let mut max_parallelism__ = None;
16813 let mut node_label__ = None;
16814 let mut backfill_done__ = None;
16815 while let Some(k) = map_.next_key()? {
16816 match k {
16817 GeneratedField::TableId => {
16818 if table_id__.is_some() {
16819 return Err(serde::de::Error::duplicate_field("tableId"));
16820 }
16821 table_id__ =
16822 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16823 ;
16824 }
16825 GeneratedField::State => {
16826 if state__.is_some() {
16827 return Err(serde::de::Error::duplicate_field("state"));
16828 }
16829 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
16830 }
16831 GeneratedField::Fragments => {
16832 if fragments__.is_some() {
16833 return Err(serde::de::Error::duplicate_field("fragments"));
16834 }
16835 fragments__ = Some(
16836 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16837 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16838 );
16839 }
16840 GeneratedField::ActorStatus => {
16841 if actor_status__.is_some() {
16842 return Err(serde::de::Error::duplicate_field("actorStatus"));
16843 }
16844 actor_status__ = Some(
16845 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16846 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16847 );
16848 }
16849 GeneratedField::Ctx => {
16850 if ctx__.is_some() {
16851 return Err(serde::de::Error::duplicate_field("ctx"));
16852 }
16853 ctx__ = map_.next_value()?;
16854 }
16855 GeneratedField::Parallelism => {
16856 if parallelism__.is_some() {
16857 return Err(serde::de::Error::duplicate_field("parallelism"));
16858 }
16859 parallelism__ = map_.next_value()?;
16860 }
16861 GeneratedField::MaxParallelism => {
16862 if max_parallelism__.is_some() {
16863 return Err(serde::de::Error::duplicate_field("maxParallelism"));
16864 }
16865 max_parallelism__ =
16866 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16867 ;
16868 }
16869 GeneratedField::NodeLabel => {
16870 if node_label__.is_some() {
16871 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16872 }
16873 node_label__ = Some(map_.next_value()?);
16874 }
16875 GeneratedField::BackfillDone => {
16876 if backfill_done__.is_some() {
16877 return Err(serde::de::Error::duplicate_field("backfillDone"));
16878 }
16879 backfill_done__ = Some(map_.next_value()?);
16880 }
16881 }
16882 }
16883 Ok(TableFragments {
16884 table_id: table_id__.unwrap_or_default(),
16885 state: state__.unwrap_or_default(),
16886 fragments: fragments__.unwrap_or_default(),
16887 actor_status: actor_status__.unwrap_or_default(),
16888 ctx: ctx__,
16889 parallelism: parallelism__,
16890 max_parallelism: max_parallelism__,
16891 node_label: node_label__.unwrap_or_default(),
16892 backfill_done: backfill_done__.unwrap_or_default(),
16893 })
16894 }
16895 }
16896 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
16897 }
16898}
16899impl serde::Serialize for table_fragments::ActorStatus {
16900 #[allow(deprecated)]
16901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16902 where
16903 S: serde::Serializer,
16904 {
16905 use serde::ser::SerializeStruct;
16906 let mut len = 0;
16907 if self.location.is_some() {
16908 len += 1;
16909 }
16910 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
16911 if let Some(v) = self.location.as_ref() {
16912 struct_ser.serialize_field("location", v)?;
16913 }
16914 struct_ser.end()
16915 }
16916}
16917impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
16918 #[allow(deprecated)]
16919 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16920 where
16921 D: serde::Deserializer<'de>,
16922 {
16923 const FIELDS: &[&str] = &[
16924 "location",
16925 ];
16926
16927 #[allow(clippy::enum_variant_names)]
16928 enum GeneratedField {
16929 Location,
16930 }
16931 impl<'de> serde::Deserialize<'de> for GeneratedField {
16932 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16933 where
16934 D: serde::Deserializer<'de>,
16935 {
16936 struct GeneratedVisitor;
16937
16938 impl serde::de::Visitor<'_> for GeneratedVisitor {
16939 type Value = GeneratedField;
16940
16941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16942 write!(formatter, "expected one of: {:?}", &FIELDS)
16943 }
16944
16945 #[allow(unused_variables)]
16946 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16947 where
16948 E: serde::de::Error,
16949 {
16950 match value {
16951 "location" => Ok(GeneratedField::Location),
16952 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16953 }
16954 }
16955 }
16956 deserializer.deserialize_identifier(GeneratedVisitor)
16957 }
16958 }
16959 struct GeneratedVisitor;
16960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16961 type Value = table_fragments::ActorStatus;
16962
16963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16964 formatter.write_str("struct meta.TableFragments.ActorStatus")
16965 }
16966
16967 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
16968 where
16969 V: serde::de::MapAccess<'de>,
16970 {
16971 let mut location__ = None;
16972 while let Some(k) = map_.next_key()? {
16973 match k {
16974 GeneratedField::Location => {
16975 if location__.is_some() {
16976 return Err(serde::de::Error::duplicate_field("location"));
16977 }
16978 location__ = map_.next_value()?;
16979 }
16980 }
16981 }
16982 Ok(table_fragments::ActorStatus {
16983 location: location__,
16984 })
16985 }
16986 }
16987 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
16988 }
16989}
16990impl serde::Serialize for table_fragments::Fragment {
16991 #[allow(deprecated)]
16992 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16993 where
16994 S: serde::Serializer,
16995 {
16996 use serde::ser::SerializeStruct;
16997 let mut len = 0;
16998 if self.fragment_id != 0 {
16999 len += 1;
17000 }
17001 if self.fragment_type_mask != 0 {
17002 len += 1;
17003 }
17004 if self.distribution_type != 0 {
17005 len += 1;
17006 }
17007 if !self.actors.is_empty() {
17008 len += 1;
17009 }
17010 if !self.state_table_ids.is_empty() {
17011 len += 1;
17012 }
17013 if !self.upstream_fragment_ids.is_empty() {
17014 len += 1;
17015 }
17016 if self.maybe_vnode_count.is_some() {
17017 len += 1;
17018 }
17019 if self.nodes.is_some() {
17020 len += 1;
17021 }
17022 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
17023 if self.fragment_id != 0 {
17024 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
17025 }
17026 if self.fragment_type_mask != 0 {
17027 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
17028 }
17029 if self.distribution_type != 0 {
17030 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
17031 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
17032 struct_ser.serialize_field("distributionType", &v)?;
17033 }
17034 if !self.actors.is_empty() {
17035 struct_ser.serialize_field("actors", &self.actors)?;
17036 }
17037 if !self.state_table_ids.is_empty() {
17038 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
17039 }
17040 if !self.upstream_fragment_ids.is_empty() {
17041 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
17042 }
17043 if let Some(v) = self.maybe_vnode_count.as_ref() {
17044 struct_ser.serialize_field("maybeVnodeCount", v)?;
17045 }
17046 if let Some(v) = self.nodes.as_ref() {
17047 struct_ser.serialize_field("nodes", v)?;
17048 }
17049 struct_ser.end()
17050 }
17051}
17052impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
17053 #[allow(deprecated)]
17054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17055 where
17056 D: serde::Deserializer<'de>,
17057 {
17058 const FIELDS: &[&str] = &[
17059 "fragment_id",
17060 "fragmentId",
17061 "fragment_type_mask",
17062 "fragmentTypeMask",
17063 "distribution_type",
17064 "distributionType",
17065 "actors",
17066 "state_table_ids",
17067 "stateTableIds",
17068 "upstream_fragment_ids",
17069 "upstreamFragmentIds",
17070 "maybe_vnode_count",
17071 "maybeVnodeCount",
17072 "nodes",
17073 ];
17074
17075 #[allow(clippy::enum_variant_names)]
17076 enum GeneratedField {
17077 FragmentId,
17078 FragmentTypeMask,
17079 DistributionType,
17080 Actors,
17081 StateTableIds,
17082 UpstreamFragmentIds,
17083 MaybeVnodeCount,
17084 Nodes,
17085 }
17086 impl<'de> serde::Deserialize<'de> for GeneratedField {
17087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17088 where
17089 D: serde::Deserializer<'de>,
17090 {
17091 struct GeneratedVisitor;
17092
17093 impl serde::de::Visitor<'_> for GeneratedVisitor {
17094 type Value = GeneratedField;
17095
17096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17097 write!(formatter, "expected one of: {:?}", &FIELDS)
17098 }
17099
17100 #[allow(unused_variables)]
17101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17102 where
17103 E: serde::de::Error,
17104 {
17105 match value {
17106 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
17107 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
17108 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
17109 "actors" => Ok(GeneratedField::Actors),
17110 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
17111 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
17112 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
17113 "nodes" => Ok(GeneratedField::Nodes),
17114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17115 }
17116 }
17117 }
17118 deserializer.deserialize_identifier(GeneratedVisitor)
17119 }
17120 }
17121 struct GeneratedVisitor;
17122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17123 type Value = table_fragments::Fragment;
17124
17125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17126 formatter.write_str("struct meta.TableFragments.Fragment")
17127 }
17128
17129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
17130 where
17131 V: serde::de::MapAccess<'de>,
17132 {
17133 let mut fragment_id__ = None;
17134 let mut fragment_type_mask__ = None;
17135 let mut distribution_type__ = None;
17136 let mut actors__ = None;
17137 let mut state_table_ids__ = None;
17138 let mut upstream_fragment_ids__ = None;
17139 let mut maybe_vnode_count__ = None;
17140 let mut nodes__ = None;
17141 while let Some(k) = map_.next_key()? {
17142 match k {
17143 GeneratedField::FragmentId => {
17144 if fragment_id__.is_some() {
17145 return Err(serde::de::Error::duplicate_field("fragmentId"));
17146 }
17147 fragment_id__ =
17148 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17149 ;
17150 }
17151 GeneratedField::FragmentTypeMask => {
17152 if fragment_type_mask__.is_some() {
17153 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
17154 }
17155 fragment_type_mask__ =
17156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17157 ;
17158 }
17159 GeneratedField::DistributionType => {
17160 if distribution_type__.is_some() {
17161 return Err(serde::de::Error::duplicate_field("distributionType"));
17162 }
17163 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
17164 }
17165 GeneratedField::Actors => {
17166 if actors__.is_some() {
17167 return Err(serde::de::Error::duplicate_field("actors"));
17168 }
17169 actors__ = Some(map_.next_value()?);
17170 }
17171 GeneratedField::StateTableIds => {
17172 if state_table_ids__.is_some() {
17173 return Err(serde::de::Error::duplicate_field("stateTableIds"));
17174 }
17175 state_table_ids__ =
17176 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17177 .into_iter().map(|x| x.0).collect())
17178 ;
17179 }
17180 GeneratedField::UpstreamFragmentIds => {
17181 if upstream_fragment_ids__.is_some() {
17182 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
17183 }
17184 upstream_fragment_ids__ =
17185 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17186 .into_iter().map(|x| x.0).collect())
17187 ;
17188 }
17189 GeneratedField::MaybeVnodeCount => {
17190 if maybe_vnode_count__.is_some() {
17191 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
17192 }
17193 maybe_vnode_count__ =
17194 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17195 ;
17196 }
17197 GeneratedField::Nodes => {
17198 if nodes__.is_some() {
17199 return Err(serde::de::Error::duplicate_field("nodes"));
17200 }
17201 nodes__ = map_.next_value()?;
17202 }
17203 }
17204 }
17205 Ok(table_fragments::Fragment {
17206 fragment_id: fragment_id__.unwrap_or_default(),
17207 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
17208 distribution_type: distribution_type__.unwrap_or_default(),
17209 actors: actors__.unwrap_or_default(),
17210 state_table_ids: state_table_ids__.unwrap_or_default(),
17211 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
17212 maybe_vnode_count: maybe_vnode_count__,
17213 nodes: nodes__,
17214 })
17215 }
17216 }
17217 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
17218 }
17219}
17220impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
17221 #[allow(deprecated)]
17222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17223 where
17224 S: serde::Serializer,
17225 {
17226 let variant = match self {
17227 Self::Unspecified => "UNSPECIFIED",
17228 Self::Single => "SINGLE",
17229 Self::Hash => "HASH",
17230 };
17231 serializer.serialize_str(variant)
17232 }
17233}
17234impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
17235 #[allow(deprecated)]
17236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17237 where
17238 D: serde::Deserializer<'de>,
17239 {
17240 const FIELDS: &[&str] = &[
17241 "UNSPECIFIED",
17242 "SINGLE",
17243 "HASH",
17244 ];
17245
17246 struct GeneratedVisitor;
17247
17248 impl serde::de::Visitor<'_> for GeneratedVisitor {
17249 type Value = table_fragments::fragment::FragmentDistributionType;
17250
17251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17252 write!(formatter, "expected one of: {:?}", &FIELDS)
17253 }
17254
17255 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17256 where
17257 E: serde::de::Error,
17258 {
17259 i32::try_from(v)
17260 .ok()
17261 .and_then(|x| x.try_into().ok())
17262 .ok_or_else(|| {
17263 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17264 })
17265 }
17266
17267 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17268 where
17269 E: serde::de::Error,
17270 {
17271 i32::try_from(v)
17272 .ok()
17273 .and_then(|x| x.try_into().ok())
17274 .ok_or_else(|| {
17275 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17276 })
17277 }
17278
17279 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17280 where
17281 E: serde::de::Error,
17282 {
17283 match value {
17284 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
17285 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
17286 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
17287 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17288 }
17289 }
17290 }
17291 deserializer.deserialize_any(GeneratedVisitor)
17292 }
17293}
17294impl serde::Serialize for table_fragments::State {
17295 #[allow(deprecated)]
17296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17297 where
17298 S: serde::Serializer,
17299 {
17300 let variant = match self {
17301 Self::Unspecified => "UNSPECIFIED",
17302 Self::Initial => "INITIAL",
17303 Self::Creating => "CREATING",
17304 Self::Created => "CREATED",
17305 };
17306 serializer.serialize_str(variant)
17307 }
17308}
17309impl<'de> serde::Deserialize<'de> for table_fragments::State {
17310 #[allow(deprecated)]
17311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17312 where
17313 D: serde::Deserializer<'de>,
17314 {
17315 const FIELDS: &[&str] = &[
17316 "UNSPECIFIED",
17317 "INITIAL",
17318 "CREATING",
17319 "CREATED",
17320 ];
17321
17322 struct GeneratedVisitor;
17323
17324 impl serde::de::Visitor<'_> for GeneratedVisitor {
17325 type Value = table_fragments::State;
17326
17327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17328 write!(formatter, "expected one of: {:?}", &FIELDS)
17329 }
17330
17331 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17332 where
17333 E: serde::de::Error,
17334 {
17335 i32::try_from(v)
17336 .ok()
17337 .and_then(|x| x.try_into().ok())
17338 .ok_or_else(|| {
17339 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17340 })
17341 }
17342
17343 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17344 where
17345 E: serde::de::Error,
17346 {
17347 i32::try_from(v)
17348 .ok()
17349 .and_then(|x| x.try_into().ok())
17350 .ok_or_else(|| {
17351 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17352 })
17353 }
17354
17355 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17356 where
17357 E: serde::de::Error,
17358 {
17359 match value {
17360 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
17361 "INITIAL" => Ok(table_fragments::State::Initial),
17362 "CREATING" => Ok(table_fragments::State::Creating),
17363 "CREATED" => Ok(table_fragments::State::Created),
17364 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17365 }
17366 }
17367 }
17368 deserializer.deserialize_any(GeneratedVisitor)
17369 }
17370}
17371impl serde::Serialize for TableParallelism {
17372 #[allow(deprecated)]
17373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17374 where
17375 S: serde::Serializer,
17376 {
17377 use serde::ser::SerializeStruct;
17378 let mut len = 0;
17379 if self.parallelism.is_some() {
17380 len += 1;
17381 }
17382 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
17383 if let Some(v) = self.parallelism.as_ref() {
17384 match v {
17385 table_parallelism::Parallelism::Fixed(v) => {
17386 struct_ser.serialize_field("fixed", v)?;
17387 }
17388 table_parallelism::Parallelism::Auto(v) => {
17389 struct_ser.serialize_field("auto", v)?;
17390 }
17391 table_parallelism::Parallelism::Custom(v) => {
17392 struct_ser.serialize_field("custom", v)?;
17393 }
17394 table_parallelism::Parallelism::Adaptive(v) => {
17395 struct_ser.serialize_field("adaptive", v)?;
17396 }
17397 }
17398 }
17399 struct_ser.end()
17400 }
17401}
17402impl<'de> serde::Deserialize<'de> for TableParallelism {
17403 #[allow(deprecated)]
17404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17405 where
17406 D: serde::Deserializer<'de>,
17407 {
17408 const FIELDS: &[&str] = &[
17409 "fixed",
17410 "auto",
17411 "custom",
17412 "adaptive",
17413 ];
17414
17415 #[allow(clippy::enum_variant_names)]
17416 enum GeneratedField {
17417 Fixed,
17418 Auto,
17419 Custom,
17420 Adaptive,
17421 }
17422 impl<'de> serde::Deserialize<'de> for GeneratedField {
17423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17424 where
17425 D: serde::Deserializer<'de>,
17426 {
17427 struct GeneratedVisitor;
17428
17429 impl serde::de::Visitor<'_> for GeneratedVisitor {
17430 type Value = GeneratedField;
17431
17432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17433 write!(formatter, "expected one of: {:?}", &FIELDS)
17434 }
17435
17436 #[allow(unused_variables)]
17437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17438 where
17439 E: serde::de::Error,
17440 {
17441 match value {
17442 "fixed" => Ok(GeneratedField::Fixed),
17443 "auto" => Ok(GeneratedField::Auto),
17444 "custom" => Ok(GeneratedField::Custom),
17445 "adaptive" => Ok(GeneratedField::Adaptive),
17446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17447 }
17448 }
17449 }
17450 deserializer.deserialize_identifier(GeneratedVisitor)
17451 }
17452 }
17453 struct GeneratedVisitor;
17454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17455 type Value = TableParallelism;
17456
17457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17458 formatter.write_str("struct meta.TableParallelism")
17459 }
17460
17461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
17462 where
17463 V: serde::de::MapAccess<'de>,
17464 {
17465 let mut parallelism__ = None;
17466 while let Some(k) = map_.next_key()? {
17467 match k {
17468 GeneratedField::Fixed => {
17469 if parallelism__.is_some() {
17470 return Err(serde::de::Error::duplicate_field("fixed"));
17471 }
17472 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
17473;
17474 }
17475 GeneratedField::Auto => {
17476 if parallelism__.is_some() {
17477 return Err(serde::de::Error::duplicate_field("auto"));
17478 }
17479 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
17480;
17481 }
17482 GeneratedField::Custom => {
17483 if parallelism__.is_some() {
17484 return Err(serde::de::Error::duplicate_field("custom"));
17485 }
17486 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
17487;
17488 }
17489 GeneratedField::Adaptive => {
17490 if parallelism__.is_some() {
17491 return Err(serde::de::Error::duplicate_field("adaptive"));
17492 }
17493 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
17494;
17495 }
17496 }
17497 }
17498 Ok(TableParallelism {
17499 parallelism: parallelism__,
17500 })
17501 }
17502 }
17503 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
17504 }
17505}
17506impl serde::Serialize for table_parallelism::AdaptiveParallelism {
17507 #[allow(deprecated)]
17508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17509 where
17510 S: serde::Serializer,
17511 {
17512 use serde::ser::SerializeStruct;
17513 let len = 0;
17514 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
17515 struct_ser.end()
17516 }
17517}
17518impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
17519 #[allow(deprecated)]
17520 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17521 where
17522 D: serde::Deserializer<'de>,
17523 {
17524 const FIELDS: &[&str] = &[
17525 ];
17526
17527 #[allow(clippy::enum_variant_names)]
17528 enum GeneratedField {
17529 }
17530 impl<'de> serde::Deserialize<'de> for GeneratedField {
17531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17532 where
17533 D: serde::Deserializer<'de>,
17534 {
17535 struct GeneratedVisitor;
17536
17537 impl serde::de::Visitor<'_> for GeneratedVisitor {
17538 type Value = GeneratedField;
17539
17540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17541 write!(formatter, "expected one of: {:?}", &FIELDS)
17542 }
17543
17544 #[allow(unused_variables)]
17545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17546 where
17547 E: serde::de::Error,
17548 {
17549 Err(serde::de::Error::unknown_field(value, FIELDS))
17550 }
17551 }
17552 deserializer.deserialize_identifier(GeneratedVisitor)
17553 }
17554 }
17555 struct GeneratedVisitor;
17556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17557 type Value = table_parallelism::AdaptiveParallelism;
17558
17559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17560 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
17561 }
17562
17563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
17564 where
17565 V: serde::de::MapAccess<'de>,
17566 {
17567 while map_.next_key::<GeneratedField>()?.is_some() {
17568 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17569 }
17570 Ok(table_parallelism::AdaptiveParallelism {
17571 })
17572 }
17573 }
17574 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
17575 }
17576}
17577impl serde::Serialize for table_parallelism::AutoParallelism {
17578 #[allow(deprecated)]
17579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17580 where
17581 S: serde::Serializer,
17582 {
17583 use serde::ser::SerializeStruct;
17584 let len = 0;
17585 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
17586 struct_ser.end()
17587 }
17588}
17589impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
17590 #[allow(deprecated)]
17591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17592 where
17593 D: serde::Deserializer<'de>,
17594 {
17595 const FIELDS: &[&str] = &[
17596 ];
17597
17598 #[allow(clippy::enum_variant_names)]
17599 enum GeneratedField {
17600 }
17601 impl<'de> serde::Deserialize<'de> for GeneratedField {
17602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17603 where
17604 D: serde::Deserializer<'de>,
17605 {
17606 struct GeneratedVisitor;
17607
17608 impl serde::de::Visitor<'_> for GeneratedVisitor {
17609 type Value = GeneratedField;
17610
17611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17612 write!(formatter, "expected one of: {:?}", &FIELDS)
17613 }
17614
17615 #[allow(unused_variables)]
17616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17617 where
17618 E: serde::de::Error,
17619 {
17620 Err(serde::de::Error::unknown_field(value, FIELDS))
17621 }
17622 }
17623 deserializer.deserialize_identifier(GeneratedVisitor)
17624 }
17625 }
17626 struct GeneratedVisitor;
17627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17628 type Value = table_parallelism::AutoParallelism;
17629
17630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17631 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
17632 }
17633
17634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
17635 where
17636 V: serde::de::MapAccess<'de>,
17637 {
17638 while map_.next_key::<GeneratedField>()?.is_some() {
17639 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17640 }
17641 Ok(table_parallelism::AutoParallelism {
17642 })
17643 }
17644 }
17645 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
17646 }
17647}
17648impl serde::Serialize for table_parallelism::CustomParallelism {
17649 #[allow(deprecated)]
17650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17651 where
17652 S: serde::Serializer,
17653 {
17654 use serde::ser::SerializeStruct;
17655 let len = 0;
17656 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
17657 struct_ser.end()
17658 }
17659}
17660impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
17661 #[allow(deprecated)]
17662 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17663 where
17664 D: serde::Deserializer<'de>,
17665 {
17666 const FIELDS: &[&str] = &[
17667 ];
17668
17669 #[allow(clippy::enum_variant_names)]
17670 enum GeneratedField {
17671 }
17672 impl<'de> serde::Deserialize<'de> for GeneratedField {
17673 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17674 where
17675 D: serde::Deserializer<'de>,
17676 {
17677 struct GeneratedVisitor;
17678
17679 impl serde::de::Visitor<'_> for GeneratedVisitor {
17680 type Value = GeneratedField;
17681
17682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17683 write!(formatter, "expected one of: {:?}", &FIELDS)
17684 }
17685
17686 #[allow(unused_variables)]
17687 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17688 where
17689 E: serde::de::Error,
17690 {
17691 Err(serde::de::Error::unknown_field(value, FIELDS))
17692 }
17693 }
17694 deserializer.deserialize_identifier(GeneratedVisitor)
17695 }
17696 }
17697 struct GeneratedVisitor;
17698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17699 type Value = table_parallelism::CustomParallelism;
17700
17701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17702 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
17703 }
17704
17705 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
17706 where
17707 V: serde::de::MapAccess<'de>,
17708 {
17709 while map_.next_key::<GeneratedField>()?.is_some() {
17710 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17711 }
17712 Ok(table_parallelism::CustomParallelism {
17713 })
17714 }
17715 }
17716 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
17717 }
17718}
17719impl serde::Serialize for table_parallelism::FixedParallelism {
17720 #[allow(deprecated)]
17721 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17722 where
17723 S: serde::Serializer,
17724 {
17725 use serde::ser::SerializeStruct;
17726 let mut len = 0;
17727 if self.parallelism != 0 {
17728 len += 1;
17729 }
17730 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
17731 if self.parallelism != 0 {
17732 struct_ser.serialize_field("parallelism", &self.parallelism)?;
17733 }
17734 struct_ser.end()
17735 }
17736}
17737impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
17738 #[allow(deprecated)]
17739 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17740 where
17741 D: serde::Deserializer<'de>,
17742 {
17743 const FIELDS: &[&str] = &[
17744 "parallelism",
17745 ];
17746
17747 #[allow(clippy::enum_variant_names)]
17748 enum GeneratedField {
17749 Parallelism,
17750 }
17751 impl<'de> serde::Deserialize<'de> for GeneratedField {
17752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17753 where
17754 D: serde::Deserializer<'de>,
17755 {
17756 struct GeneratedVisitor;
17757
17758 impl serde::de::Visitor<'_> for GeneratedVisitor {
17759 type Value = GeneratedField;
17760
17761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17762 write!(formatter, "expected one of: {:?}", &FIELDS)
17763 }
17764
17765 #[allow(unused_variables)]
17766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17767 where
17768 E: serde::de::Error,
17769 {
17770 match value {
17771 "parallelism" => Ok(GeneratedField::Parallelism),
17772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17773 }
17774 }
17775 }
17776 deserializer.deserialize_identifier(GeneratedVisitor)
17777 }
17778 }
17779 struct GeneratedVisitor;
17780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17781 type Value = table_parallelism::FixedParallelism;
17782
17783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17784 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
17785 }
17786
17787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
17788 where
17789 V: serde::de::MapAccess<'de>,
17790 {
17791 let mut parallelism__ = None;
17792 while let Some(k) = map_.next_key()? {
17793 match k {
17794 GeneratedField::Parallelism => {
17795 if parallelism__.is_some() {
17796 return Err(serde::de::Error::duplicate_field("parallelism"));
17797 }
17798 parallelism__ =
17799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17800 ;
17801 }
17802 }
17803 }
17804 Ok(table_parallelism::FixedParallelism {
17805 parallelism: parallelism__.unwrap_or_default(),
17806 })
17807 }
17808 }
17809 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
17810 }
17811}
17812impl serde::Serialize for TelemetryInfoResponse {
17813 #[allow(deprecated)]
17814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17815 where
17816 S: serde::Serializer,
17817 {
17818 use serde::ser::SerializeStruct;
17819 let mut len = 0;
17820 if self.tracking_id.is_some() {
17821 len += 1;
17822 }
17823 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
17824 if let Some(v) = self.tracking_id.as_ref() {
17825 struct_ser.serialize_field("trackingId", v)?;
17826 }
17827 struct_ser.end()
17828 }
17829}
17830impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
17831 #[allow(deprecated)]
17832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17833 where
17834 D: serde::Deserializer<'de>,
17835 {
17836 const FIELDS: &[&str] = &[
17837 "tracking_id",
17838 "trackingId",
17839 ];
17840
17841 #[allow(clippy::enum_variant_names)]
17842 enum GeneratedField {
17843 TrackingId,
17844 }
17845 impl<'de> serde::Deserialize<'de> for GeneratedField {
17846 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17847 where
17848 D: serde::Deserializer<'de>,
17849 {
17850 struct GeneratedVisitor;
17851
17852 impl serde::de::Visitor<'_> for GeneratedVisitor {
17853 type Value = GeneratedField;
17854
17855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17856 write!(formatter, "expected one of: {:?}", &FIELDS)
17857 }
17858
17859 #[allow(unused_variables)]
17860 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17861 where
17862 E: serde::de::Error,
17863 {
17864 match value {
17865 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
17866 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17867 }
17868 }
17869 }
17870 deserializer.deserialize_identifier(GeneratedVisitor)
17871 }
17872 }
17873 struct GeneratedVisitor;
17874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17875 type Value = TelemetryInfoResponse;
17876
17877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17878 formatter.write_str("struct meta.TelemetryInfoResponse")
17879 }
17880
17881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
17882 where
17883 V: serde::de::MapAccess<'de>,
17884 {
17885 let mut tracking_id__ = None;
17886 while let Some(k) = map_.next_key()? {
17887 match k {
17888 GeneratedField::TrackingId => {
17889 if tracking_id__.is_some() {
17890 return Err(serde::de::Error::duplicate_field("trackingId"));
17891 }
17892 tracking_id__ = map_.next_value()?;
17893 }
17894 }
17895 }
17896 Ok(TelemetryInfoResponse {
17897 tracking_id: tracking_id__,
17898 })
17899 }
17900 }
17901 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
17902 }
17903}
17904impl serde::Serialize for ThrottleTarget {
17905 #[allow(deprecated)]
17906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17907 where
17908 S: serde::Serializer,
17909 {
17910 let variant = match self {
17911 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
17912 Self::Source => "SOURCE",
17913 Self::Mv => "MV",
17914 Self::Table => "TABLE",
17915 Self::Sink => "SINK",
17916 Self::Fragment => "FRAGMENT",
17917 };
17918 serializer.serialize_str(variant)
17919 }
17920}
17921impl<'de> serde::Deserialize<'de> for ThrottleTarget {
17922 #[allow(deprecated)]
17923 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17924 where
17925 D: serde::Deserializer<'de>,
17926 {
17927 const FIELDS: &[&str] = &[
17928 "THROTTLE_TARGET_UNSPECIFIED",
17929 "SOURCE",
17930 "MV",
17931 "TABLE",
17932 "SINK",
17933 "FRAGMENT",
17934 ];
17935
17936 struct GeneratedVisitor;
17937
17938 impl serde::de::Visitor<'_> for GeneratedVisitor {
17939 type Value = ThrottleTarget;
17940
17941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17942 write!(formatter, "expected one of: {:?}", &FIELDS)
17943 }
17944
17945 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17946 where
17947 E: serde::de::Error,
17948 {
17949 i32::try_from(v)
17950 .ok()
17951 .and_then(|x| x.try_into().ok())
17952 .ok_or_else(|| {
17953 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17954 })
17955 }
17956
17957 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17958 where
17959 E: serde::de::Error,
17960 {
17961 i32::try_from(v)
17962 .ok()
17963 .and_then(|x| x.try_into().ok())
17964 .ok_or_else(|| {
17965 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17966 })
17967 }
17968
17969 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17970 where
17971 E: serde::de::Error,
17972 {
17973 match value {
17974 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
17975 "SOURCE" => Ok(ThrottleTarget::Source),
17976 "MV" => Ok(ThrottleTarget::Mv),
17977 "TABLE" => Ok(ThrottleTarget::Table),
17978 "SINK" => Ok(ThrottleTarget::Sink),
17979 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
17980 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17981 }
17982 }
17983 }
17984 deserializer.deserialize_any(GeneratedVisitor)
17985 }
17986}
17987impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
17988 #[allow(deprecated)]
17989 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17990 where
17991 S: serde::Serializer,
17992 {
17993 use serde::ser::SerializeStruct;
17994 let mut len = 0;
17995 if self.id != 0 {
17996 len += 1;
17997 }
17998 if !self.node_label.is_empty() {
17999 len += 1;
18000 }
18001 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
18002 if self.id != 0 {
18003 struct_ser.serialize_field("id", &self.id)?;
18004 }
18005 if !self.node_label.is_empty() {
18006 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18007 }
18008 struct_ser.end()
18009 }
18010}
18011impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
18012 #[allow(deprecated)]
18013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18014 where
18015 D: serde::Deserializer<'de>,
18016 {
18017 const FIELDS: &[&str] = &[
18018 "id",
18019 "node_label",
18020 "nodeLabel",
18021 ];
18022
18023 #[allow(clippy::enum_variant_names)]
18024 enum GeneratedField {
18025 Id,
18026 NodeLabel,
18027 }
18028 impl<'de> serde::Deserialize<'de> for GeneratedField {
18029 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18030 where
18031 D: serde::Deserializer<'de>,
18032 {
18033 struct GeneratedVisitor;
18034
18035 impl serde::de::Visitor<'_> for GeneratedVisitor {
18036 type Value = GeneratedField;
18037
18038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18039 write!(formatter, "expected one of: {:?}", &FIELDS)
18040 }
18041
18042 #[allow(unused_variables)]
18043 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18044 where
18045 E: serde::de::Error,
18046 {
18047 match value {
18048 "id" => Ok(GeneratedField::Id),
18049 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18051 }
18052 }
18053 }
18054 deserializer.deserialize_identifier(GeneratedVisitor)
18055 }
18056 }
18057 struct GeneratedVisitor;
18058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18059 type Value = UpdateStreamingJobNodeLabelsRequest;
18060
18061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18062 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
18063 }
18064
18065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
18066 where
18067 V: serde::de::MapAccess<'de>,
18068 {
18069 let mut id__ = None;
18070 let mut node_label__ = None;
18071 while let Some(k) = map_.next_key()? {
18072 match k {
18073 GeneratedField::Id => {
18074 if id__.is_some() {
18075 return Err(serde::de::Error::duplicate_field("id"));
18076 }
18077 id__ =
18078 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18079 ;
18080 }
18081 GeneratedField::NodeLabel => {
18082 if node_label__.is_some() {
18083 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18084 }
18085 node_label__ = Some(map_.next_value()?);
18086 }
18087 }
18088 }
18089 Ok(UpdateStreamingJobNodeLabelsRequest {
18090 id: id__.unwrap_or_default(),
18091 node_label: node_label__.unwrap_or_default(),
18092 })
18093 }
18094 }
18095 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
18096 }
18097}
18098impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
18099 #[allow(deprecated)]
18100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18101 where
18102 S: serde::Serializer,
18103 {
18104 use serde::ser::SerializeStruct;
18105 let len = 0;
18106 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
18107 struct_ser.end()
18108 }
18109}
18110impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
18111 #[allow(deprecated)]
18112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18113 where
18114 D: serde::Deserializer<'de>,
18115 {
18116 const FIELDS: &[&str] = &[
18117 ];
18118
18119 #[allow(clippy::enum_variant_names)]
18120 enum GeneratedField {
18121 }
18122 impl<'de> serde::Deserialize<'de> for GeneratedField {
18123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18124 where
18125 D: serde::Deserializer<'de>,
18126 {
18127 struct GeneratedVisitor;
18128
18129 impl serde::de::Visitor<'_> for GeneratedVisitor {
18130 type Value = GeneratedField;
18131
18132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18133 write!(formatter, "expected one of: {:?}", &FIELDS)
18134 }
18135
18136 #[allow(unused_variables)]
18137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18138 where
18139 E: serde::de::Error,
18140 {
18141 Err(serde::de::Error::unknown_field(value, FIELDS))
18142 }
18143 }
18144 deserializer.deserialize_identifier(GeneratedVisitor)
18145 }
18146 }
18147 struct GeneratedVisitor;
18148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18149 type Value = UpdateStreamingJobNodeLabelsResponse;
18150
18151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18152 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
18153 }
18154
18155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
18156 where
18157 V: serde::de::MapAccess<'de>,
18158 {
18159 while map_.next_key::<GeneratedField>()?.is_some() {
18160 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18161 }
18162 Ok(UpdateStreamingJobNodeLabelsResponse {
18163 })
18164 }
18165 }
18166 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
18167 }
18168}
18169impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
18170 #[allow(deprecated)]
18171 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18172 where
18173 S: serde::Serializer,
18174 {
18175 use serde::ser::SerializeStruct;
18176 let mut len = 0;
18177 if !self.worker_ids.is_empty() {
18178 len += 1;
18179 }
18180 if self.schedulability != 0 {
18181 len += 1;
18182 }
18183 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
18184 if !self.worker_ids.is_empty() {
18185 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
18186 }
18187 if self.schedulability != 0 {
18188 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
18189 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
18190 struct_ser.serialize_field("schedulability", &v)?;
18191 }
18192 struct_ser.end()
18193 }
18194}
18195impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
18196 #[allow(deprecated)]
18197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18198 where
18199 D: serde::Deserializer<'de>,
18200 {
18201 const FIELDS: &[&str] = &[
18202 "worker_ids",
18203 "workerIds",
18204 "schedulability",
18205 ];
18206
18207 #[allow(clippy::enum_variant_names)]
18208 enum GeneratedField {
18209 WorkerIds,
18210 Schedulability,
18211 }
18212 impl<'de> serde::Deserialize<'de> for GeneratedField {
18213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18214 where
18215 D: serde::Deserializer<'de>,
18216 {
18217 struct GeneratedVisitor;
18218
18219 impl serde::de::Visitor<'_> for GeneratedVisitor {
18220 type Value = GeneratedField;
18221
18222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18223 write!(formatter, "expected one of: {:?}", &FIELDS)
18224 }
18225
18226 #[allow(unused_variables)]
18227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18228 where
18229 E: serde::de::Error,
18230 {
18231 match value {
18232 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
18233 "schedulability" => Ok(GeneratedField::Schedulability),
18234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18235 }
18236 }
18237 }
18238 deserializer.deserialize_identifier(GeneratedVisitor)
18239 }
18240 }
18241 struct GeneratedVisitor;
18242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18243 type Value = UpdateWorkerNodeSchedulabilityRequest;
18244
18245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18246 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
18247 }
18248
18249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
18250 where
18251 V: serde::de::MapAccess<'de>,
18252 {
18253 let mut worker_ids__ = None;
18254 let mut schedulability__ = None;
18255 while let Some(k) = map_.next_key()? {
18256 match k {
18257 GeneratedField::WorkerIds => {
18258 if worker_ids__.is_some() {
18259 return Err(serde::de::Error::duplicate_field("workerIds"));
18260 }
18261 worker_ids__ =
18262 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18263 .into_iter().map(|x| x.0).collect())
18264 ;
18265 }
18266 GeneratedField::Schedulability => {
18267 if schedulability__.is_some() {
18268 return Err(serde::de::Error::duplicate_field("schedulability"));
18269 }
18270 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
18271 }
18272 }
18273 }
18274 Ok(UpdateWorkerNodeSchedulabilityRequest {
18275 worker_ids: worker_ids__.unwrap_or_default(),
18276 schedulability: schedulability__.unwrap_or_default(),
18277 })
18278 }
18279 }
18280 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
18281 }
18282}
18283impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
18284 #[allow(deprecated)]
18285 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18286 where
18287 S: serde::Serializer,
18288 {
18289 let variant = match self {
18290 Self::Unspecified => "UNSPECIFIED",
18291 Self::Schedulable => "SCHEDULABLE",
18292 Self::Unschedulable => "UNSCHEDULABLE",
18293 };
18294 serializer.serialize_str(variant)
18295 }
18296}
18297impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
18298 #[allow(deprecated)]
18299 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18300 where
18301 D: serde::Deserializer<'de>,
18302 {
18303 const FIELDS: &[&str] = &[
18304 "UNSPECIFIED",
18305 "SCHEDULABLE",
18306 "UNSCHEDULABLE",
18307 ];
18308
18309 struct GeneratedVisitor;
18310
18311 impl serde::de::Visitor<'_> for GeneratedVisitor {
18312 type Value = update_worker_node_schedulability_request::Schedulability;
18313
18314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18315 write!(formatter, "expected one of: {:?}", &FIELDS)
18316 }
18317
18318 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18319 where
18320 E: serde::de::Error,
18321 {
18322 i32::try_from(v)
18323 .ok()
18324 .and_then(|x| x.try_into().ok())
18325 .ok_or_else(|| {
18326 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18327 })
18328 }
18329
18330 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18331 where
18332 E: serde::de::Error,
18333 {
18334 i32::try_from(v)
18335 .ok()
18336 .and_then(|x| x.try_into().ok())
18337 .ok_or_else(|| {
18338 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18339 })
18340 }
18341
18342 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18343 where
18344 E: serde::de::Error,
18345 {
18346 match value {
18347 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
18348 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
18349 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
18350 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18351 }
18352 }
18353 }
18354 deserializer.deserialize_any(GeneratedVisitor)
18355 }
18356}
18357impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
18358 #[allow(deprecated)]
18359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18360 where
18361 S: serde::Serializer,
18362 {
18363 use serde::ser::SerializeStruct;
18364 let mut len = 0;
18365 if self.status.is_some() {
18366 len += 1;
18367 }
18368 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
18369 if let Some(v) = self.status.as_ref() {
18370 struct_ser.serialize_field("status", v)?;
18371 }
18372 struct_ser.end()
18373 }
18374}
18375impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
18376 #[allow(deprecated)]
18377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18378 where
18379 D: serde::Deserializer<'de>,
18380 {
18381 const FIELDS: &[&str] = &[
18382 "status",
18383 ];
18384
18385 #[allow(clippy::enum_variant_names)]
18386 enum GeneratedField {
18387 Status,
18388 }
18389 impl<'de> serde::Deserialize<'de> for GeneratedField {
18390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18391 where
18392 D: serde::Deserializer<'de>,
18393 {
18394 struct GeneratedVisitor;
18395
18396 impl serde::de::Visitor<'_> for GeneratedVisitor {
18397 type Value = GeneratedField;
18398
18399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18400 write!(formatter, "expected one of: {:?}", &FIELDS)
18401 }
18402
18403 #[allow(unused_variables)]
18404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18405 where
18406 E: serde::de::Error,
18407 {
18408 match value {
18409 "status" => Ok(GeneratedField::Status),
18410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18411 }
18412 }
18413 }
18414 deserializer.deserialize_identifier(GeneratedVisitor)
18415 }
18416 }
18417 struct GeneratedVisitor;
18418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18419 type Value = UpdateWorkerNodeSchedulabilityResponse;
18420
18421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18422 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
18423 }
18424
18425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
18426 where
18427 V: serde::de::MapAccess<'de>,
18428 {
18429 let mut status__ = None;
18430 while let Some(k) = map_.next_key()? {
18431 match k {
18432 GeneratedField::Status => {
18433 if status__.is_some() {
18434 return Err(serde::de::Error::duplicate_field("status"));
18435 }
18436 status__ = map_.next_value()?;
18437 }
18438 }
18439 }
18440 Ok(UpdateWorkerNodeSchedulabilityResponse {
18441 status: status__,
18442 })
18443 }
18444 }
18445 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
18446 }
18447}
18448impl serde::Serialize for WorkerReschedule {
18449 #[allow(deprecated)]
18450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18451 where
18452 S: serde::Serializer,
18453 {
18454 use serde::ser::SerializeStruct;
18455 let mut len = 0;
18456 if !self.worker_actor_diff.is_empty() {
18457 len += 1;
18458 }
18459 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
18460 if !self.worker_actor_diff.is_empty() {
18461 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
18462 }
18463 struct_ser.end()
18464 }
18465}
18466impl<'de> serde::Deserialize<'de> for WorkerReschedule {
18467 #[allow(deprecated)]
18468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18469 where
18470 D: serde::Deserializer<'de>,
18471 {
18472 const FIELDS: &[&str] = &[
18473 "worker_actor_diff",
18474 "workerActorDiff",
18475 ];
18476
18477 #[allow(clippy::enum_variant_names)]
18478 enum GeneratedField {
18479 WorkerActorDiff,
18480 }
18481 impl<'de> serde::Deserialize<'de> for GeneratedField {
18482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18483 where
18484 D: serde::Deserializer<'de>,
18485 {
18486 struct GeneratedVisitor;
18487
18488 impl serde::de::Visitor<'_> for GeneratedVisitor {
18489 type Value = GeneratedField;
18490
18491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18492 write!(formatter, "expected one of: {:?}", &FIELDS)
18493 }
18494
18495 #[allow(unused_variables)]
18496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18497 where
18498 E: serde::de::Error,
18499 {
18500 match value {
18501 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
18502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18503 }
18504 }
18505 }
18506 deserializer.deserialize_identifier(GeneratedVisitor)
18507 }
18508 }
18509 struct GeneratedVisitor;
18510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18511 type Value = WorkerReschedule;
18512
18513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18514 formatter.write_str("struct meta.WorkerReschedule")
18515 }
18516
18517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
18518 where
18519 V: serde::de::MapAccess<'de>,
18520 {
18521 let mut worker_actor_diff__ = None;
18522 while let Some(k) = map_.next_key()? {
18523 match k {
18524 GeneratedField::WorkerActorDiff => {
18525 if worker_actor_diff__.is_some() {
18526 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
18527 }
18528 worker_actor_diff__ = Some(
18529 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
18530 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
18531 );
18532 }
18533 }
18534 }
18535 Ok(WorkerReschedule {
18536 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
18537 })
18538 }
18539 }
18540 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
18541 }
18542}