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 AlterSourcePropertiesSafeRequest {
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.source_id != 0 {
1587 len += 1;
1588 }
1589 if !self.changed_props.is_empty() {
1590 len += 1;
1591 }
1592 if !self.changed_secret_refs.is_empty() {
1593 len += 1;
1594 }
1595 if self.options.is_some() {
1596 len += 1;
1597 }
1598 let mut struct_ser = serializer.serialize_struct("meta.AlterSourcePropertiesSafeRequest", len)?;
1599 if self.source_id != 0 {
1600 struct_ser.serialize_field("sourceId", &self.source_id)?;
1601 }
1602 if !self.changed_props.is_empty() {
1603 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1604 }
1605 if !self.changed_secret_refs.is_empty() {
1606 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1607 }
1608 if let Some(v) = self.options.as_ref() {
1609 struct_ser.serialize_field("options", v)?;
1610 }
1611 struct_ser.end()
1612 }
1613}
1614impl<'de> serde::Deserialize<'de> for AlterSourcePropertiesSafeRequest {
1615 #[allow(deprecated)]
1616 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1617 where
1618 D: serde::Deserializer<'de>,
1619 {
1620 const FIELDS: &[&str] = &[
1621 "source_id",
1622 "sourceId",
1623 "changed_props",
1624 "changedProps",
1625 "changed_secret_refs",
1626 "changedSecretRefs",
1627 "options",
1628 ];
1629
1630 #[allow(clippy::enum_variant_names)]
1631 enum GeneratedField {
1632 SourceId,
1633 ChangedProps,
1634 ChangedSecretRefs,
1635 Options,
1636 }
1637 impl<'de> serde::Deserialize<'de> for GeneratedField {
1638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1639 where
1640 D: serde::Deserializer<'de>,
1641 {
1642 struct GeneratedVisitor;
1643
1644 impl serde::de::Visitor<'_> for GeneratedVisitor {
1645 type Value = GeneratedField;
1646
1647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1648 write!(formatter, "expected one of: {:?}", &FIELDS)
1649 }
1650
1651 #[allow(unused_variables)]
1652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1653 where
1654 E: serde::de::Error,
1655 {
1656 match value {
1657 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1658 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1659 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1660 "options" => Ok(GeneratedField::Options),
1661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1662 }
1663 }
1664 }
1665 deserializer.deserialize_identifier(GeneratedVisitor)
1666 }
1667 }
1668 struct GeneratedVisitor;
1669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1670 type Value = AlterSourcePropertiesSafeRequest;
1671
1672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1673 formatter.write_str("struct meta.AlterSourcePropertiesSafeRequest")
1674 }
1675
1676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourcePropertiesSafeRequest, V::Error>
1677 where
1678 V: serde::de::MapAccess<'de>,
1679 {
1680 let mut source_id__ = None;
1681 let mut changed_props__ = None;
1682 let mut changed_secret_refs__ = None;
1683 let mut options__ = None;
1684 while let Some(k) = map_.next_key()? {
1685 match k {
1686 GeneratedField::SourceId => {
1687 if source_id__.is_some() {
1688 return Err(serde::de::Error::duplicate_field("sourceId"));
1689 }
1690 source_id__ =
1691 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1692 ;
1693 }
1694 GeneratedField::ChangedProps => {
1695 if changed_props__.is_some() {
1696 return Err(serde::de::Error::duplicate_field("changedProps"));
1697 }
1698 changed_props__ = Some(
1699 map_.next_value::<std::collections::HashMap<_, _>>()?
1700 );
1701 }
1702 GeneratedField::ChangedSecretRefs => {
1703 if changed_secret_refs__.is_some() {
1704 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1705 }
1706 changed_secret_refs__ = Some(
1707 map_.next_value::<std::collections::HashMap<_, _>>()?
1708 );
1709 }
1710 GeneratedField::Options => {
1711 if options__.is_some() {
1712 return Err(serde::de::Error::duplicate_field("options"));
1713 }
1714 options__ = map_.next_value()?;
1715 }
1716 }
1717 }
1718 Ok(AlterSourcePropertiesSafeRequest {
1719 source_id: source_id__.unwrap_or_default(),
1720 changed_props: changed_props__.unwrap_or_default(),
1721 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1722 options: options__,
1723 })
1724 }
1725 }
1726 deserializer.deserialize_struct("meta.AlterSourcePropertiesSafeRequest", FIELDS, GeneratedVisitor)
1727 }
1728}
1729impl serde::Serialize for AlterSourcePropertiesSafeResponse {
1730 #[allow(deprecated)]
1731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1732 where
1733 S: serde::Serializer,
1734 {
1735 use serde::ser::SerializeStruct;
1736 let len = 0;
1737 let struct_ser = serializer.serialize_struct("meta.AlterSourcePropertiesSafeResponse", len)?;
1738 struct_ser.end()
1739 }
1740}
1741impl<'de> serde::Deserialize<'de> for AlterSourcePropertiesSafeResponse {
1742 #[allow(deprecated)]
1743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1744 where
1745 D: serde::Deserializer<'de>,
1746 {
1747 const FIELDS: &[&str] = &[
1748 ];
1749
1750 #[allow(clippy::enum_variant_names)]
1751 enum GeneratedField {
1752 }
1753 impl<'de> serde::Deserialize<'de> for GeneratedField {
1754 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1755 where
1756 D: serde::Deserializer<'de>,
1757 {
1758 struct GeneratedVisitor;
1759
1760 impl serde::de::Visitor<'_> for GeneratedVisitor {
1761 type Value = GeneratedField;
1762
1763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1764 write!(formatter, "expected one of: {:?}", &FIELDS)
1765 }
1766
1767 #[allow(unused_variables)]
1768 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1769 where
1770 E: serde::de::Error,
1771 {
1772 Err(serde::de::Error::unknown_field(value, FIELDS))
1773 }
1774 }
1775 deserializer.deserialize_identifier(GeneratedVisitor)
1776 }
1777 }
1778 struct GeneratedVisitor;
1779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1780 type Value = AlterSourcePropertiesSafeResponse;
1781
1782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1783 formatter.write_str("struct meta.AlterSourcePropertiesSafeResponse")
1784 }
1785
1786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourcePropertiesSafeResponse, V::Error>
1787 where
1788 V: serde::de::MapAccess<'de>,
1789 {
1790 while map_.next_key::<GeneratedField>()?.is_some() {
1791 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1792 }
1793 Ok(AlterSourcePropertiesSafeResponse {
1794 })
1795 }
1796 }
1797 deserializer.deserialize_struct("meta.AlterSourcePropertiesSafeResponse", FIELDS, GeneratedVisitor)
1798 }
1799}
1800impl serde::Serialize for ApplyThrottleRequest {
1801 #[allow(deprecated)]
1802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1803 where
1804 S: serde::Serializer,
1805 {
1806 use serde::ser::SerializeStruct;
1807 let mut len = 0;
1808 if self.throttle_target != 0 {
1809 len += 1;
1810 }
1811 if self.throttle_type != 0 {
1812 len += 1;
1813 }
1814 if self.id != 0 {
1815 len += 1;
1816 }
1817 if self.rate.is_some() {
1818 len += 1;
1819 }
1820 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1821 if self.throttle_target != 0 {
1822 let v = ThrottleTarget::try_from(self.throttle_target)
1823 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_target)))?;
1824 struct_ser.serialize_field("throttleTarget", &v)?;
1825 }
1826 if self.throttle_type != 0 {
1827 let v = super::common::ThrottleType::try_from(self.throttle_type)
1828 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
1829 struct_ser.serialize_field("throttleType", &v)?;
1830 }
1831 if self.id != 0 {
1832 struct_ser.serialize_field("id", &self.id)?;
1833 }
1834 if let Some(v) = self.rate.as_ref() {
1835 struct_ser.serialize_field("rate", v)?;
1836 }
1837 struct_ser.end()
1838 }
1839}
1840impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1841 #[allow(deprecated)]
1842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1843 where
1844 D: serde::Deserializer<'de>,
1845 {
1846 const FIELDS: &[&str] = &[
1847 "throttle_target",
1848 "throttleTarget",
1849 "throttle_type",
1850 "throttleType",
1851 "id",
1852 "rate",
1853 ];
1854
1855 #[allow(clippy::enum_variant_names)]
1856 enum GeneratedField {
1857 ThrottleTarget,
1858 ThrottleType,
1859 Id,
1860 Rate,
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 "throttleTarget" | "throttle_target" => Ok(GeneratedField::ThrottleTarget),
1883 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
1884 "id" => Ok(GeneratedField::Id),
1885 "rate" => Ok(GeneratedField::Rate),
1886 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1887 }
1888 }
1889 }
1890 deserializer.deserialize_identifier(GeneratedVisitor)
1891 }
1892 }
1893 struct GeneratedVisitor;
1894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1895 type Value = ApplyThrottleRequest;
1896
1897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1898 formatter.write_str("struct meta.ApplyThrottleRequest")
1899 }
1900
1901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1902 where
1903 V: serde::de::MapAccess<'de>,
1904 {
1905 let mut throttle_target__ = None;
1906 let mut throttle_type__ = None;
1907 let mut id__ = None;
1908 let mut rate__ = None;
1909 while let Some(k) = map_.next_key()? {
1910 match k {
1911 GeneratedField::ThrottleTarget => {
1912 if throttle_target__.is_some() {
1913 return Err(serde::de::Error::duplicate_field("throttleTarget"));
1914 }
1915 throttle_target__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1916 }
1917 GeneratedField::ThrottleType => {
1918 if throttle_type__.is_some() {
1919 return Err(serde::de::Error::duplicate_field("throttleType"));
1920 }
1921 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
1922 }
1923 GeneratedField::Id => {
1924 if id__.is_some() {
1925 return Err(serde::de::Error::duplicate_field("id"));
1926 }
1927 id__ =
1928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1929 ;
1930 }
1931 GeneratedField::Rate => {
1932 if rate__.is_some() {
1933 return Err(serde::de::Error::duplicate_field("rate"));
1934 }
1935 rate__ =
1936 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1937 ;
1938 }
1939 }
1940 }
1941 Ok(ApplyThrottleRequest {
1942 throttle_target: throttle_target__.unwrap_or_default(),
1943 throttle_type: throttle_type__.unwrap_or_default(),
1944 id: id__.unwrap_or_default(),
1945 rate: rate__,
1946 })
1947 }
1948 }
1949 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1950 }
1951}
1952impl serde::Serialize for ApplyThrottleResponse {
1953 #[allow(deprecated)]
1954 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1955 where
1956 S: serde::Serializer,
1957 {
1958 use serde::ser::SerializeStruct;
1959 let mut len = 0;
1960 if self.status.is_some() {
1961 len += 1;
1962 }
1963 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1964 if let Some(v) = self.status.as_ref() {
1965 struct_ser.serialize_field("status", v)?;
1966 }
1967 struct_ser.end()
1968 }
1969}
1970impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1971 #[allow(deprecated)]
1972 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1973 where
1974 D: serde::Deserializer<'de>,
1975 {
1976 const FIELDS: &[&str] = &[
1977 "status",
1978 ];
1979
1980 #[allow(clippy::enum_variant_names)]
1981 enum GeneratedField {
1982 Status,
1983 }
1984 impl<'de> serde::Deserialize<'de> for GeneratedField {
1985 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1986 where
1987 D: serde::Deserializer<'de>,
1988 {
1989 struct GeneratedVisitor;
1990
1991 impl serde::de::Visitor<'_> for GeneratedVisitor {
1992 type Value = GeneratedField;
1993
1994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1995 write!(formatter, "expected one of: {:?}", &FIELDS)
1996 }
1997
1998 #[allow(unused_variables)]
1999 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2000 where
2001 E: serde::de::Error,
2002 {
2003 match value {
2004 "status" => Ok(GeneratedField::Status),
2005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2006 }
2007 }
2008 }
2009 deserializer.deserialize_identifier(GeneratedVisitor)
2010 }
2011 }
2012 struct GeneratedVisitor;
2013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2014 type Value = ApplyThrottleResponse;
2015
2016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2017 formatter.write_str("struct meta.ApplyThrottleResponse")
2018 }
2019
2020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
2021 where
2022 V: serde::de::MapAccess<'de>,
2023 {
2024 let mut status__ = None;
2025 while let Some(k) = map_.next_key()? {
2026 match k {
2027 GeneratedField::Status => {
2028 if status__.is_some() {
2029 return Err(serde::de::Error::duplicate_field("status"));
2030 }
2031 status__ = map_.next_value()?;
2032 }
2033 }
2034 }
2035 Ok(ApplyThrottleResponse {
2036 status: status__,
2037 })
2038 }
2039 }
2040 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
2041 }
2042}
2043impl serde::Serialize for CancelCreatingJobsRequest {
2044 #[allow(deprecated)]
2045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2046 where
2047 S: serde::Serializer,
2048 {
2049 use serde::ser::SerializeStruct;
2050 let mut len = 0;
2051 if self.jobs.is_some() {
2052 len += 1;
2053 }
2054 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
2055 if let Some(v) = self.jobs.as_ref() {
2056 match v {
2057 cancel_creating_jobs_request::Jobs::Infos(v) => {
2058 struct_ser.serialize_field("infos", v)?;
2059 }
2060 cancel_creating_jobs_request::Jobs::Ids(v) => {
2061 struct_ser.serialize_field("ids", v)?;
2062 }
2063 }
2064 }
2065 struct_ser.end()
2066 }
2067}
2068impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
2069 #[allow(deprecated)]
2070 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2071 where
2072 D: serde::Deserializer<'de>,
2073 {
2074 const FIELDS: &[&str] = &[
2075 "infos",
2076 "ids",
2077 ];
2078
2079 #[allow(clippy::enum_variant_names)]
2080 enum GeneratedField {
2081 Infos,
2082 Ids,
2083 }
2084 impl<'de> serde::Deserialize<'de> for GeneratedField {
2085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2086 where
2087 D: serde::Deserializer<'de>,
2088 {
2089 struct GeneratedVisitor;
2090
2091 impl serde::de::Visitor<'_> for GeneratedVisitor {
2092 type Value = GeneratedField;
2093
2094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2095 write!(formatter, "expected one of: {:?}", &FIELDS)
2096 }
2097
2098 #[allow(unused_variables)]
2099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2100 where
2101 E: serde::de::Error,
2102 {
2103 match value {
2104 "infos" => Ok(GeneratedField::Infos),
2105 "ids" => Ok(GeneratedField::Ids),
2106 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2107 }
2108 }
2109 }
2110 deserializer.deserialize_identifier(GeneratedVisitor)
2111 }
2112 }
2113 struct GeneratedVisitor;
2114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2115 type Value = CancelCreatingJobsRequest;
2116
2117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2118 formatter.write_str("struct meta.CancelCreatingJobsRequest")
2119 }
2120
2121 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
2122 where
2123 V: serde::de::MapAccess<'de>,
2124 {
2125 let mut jobs__ = None;
2126 while let Some(k) = map_.next_key()? {
2127 match k {
2128 GeneratedField::Infos => {
2129 if jobs__.is_some() {
2130 return Err(serde::de::Error::duplicate_field("infos"));
2131 }
2132 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
2133;
2134 }
2135 GeneratedField::Ids => {
2136 if jobs__.is_some() {
2137 return Err(serde::de::Error::duplicate_field("ids"));
2138 }
2139 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
2140;
2141 }
2142 }
2143 }
2144 Ok(CancelCreatingJobsRequest {
2145 jobs: jobs__,
2146 })
2147 }
2148 }
2149 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
2150 }
2151}
2152impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
2153 #[allow(deprecated)]
2154 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2155 where
2156 S: serde::Serializer,
2157 {
2158 use serde::ser::SerializeStruct;
2159 let mut len = 0;
2160 if !self.job_ids.is_empty() {
2161 len += 1;
2162 }
2163 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
2164 if !self.job_ids.is_empty() {
2165 struct_ser.serialize_field("jobIds", &self.job_ids)?;
2166 }
2167 struct_ser.end()
2168 }
2169}
2170impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
2171 #[allow(deprecated)]
2172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2173 where
2174 D: serde::Deserializer<'de>,
2175 {
2176 const FIELDS: &[&str] = &[
2177 "job_ids",
2178 "jobIds",
2179 ];
2180
2181 #[allow(clippy::enum_variant_names)]
2182 enum GeneratedField {
2183 JobIds,
2184 }
2185 impl<'de> serde::Deserialize<'de> for GeneratedField {
2186 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2187 where
2188 D: serde::Deserializer<'de>,
2189 {
2190 struct GeneratedVisitor;
2191
2192 impl serde::de::Visitor<'_> for GeneratedVisitor {
2193 type Value = GeneratedField;
2194
2195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2196 write!(formatter, "expected one of: {:?}", &FIELDS)
2197 }
2198
2199 #[allow(unused_variables)]
2200 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2201 where
2202 E: serde::de::Error,
2203 {
2204 match value {
2205 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
2206 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2207 }
2208 }
2209 }
2210 deserializer.deserialize_identifier(GeneratedVisitor)
2211 }
2212 }
2213 struct GeneratedVisitor;
2214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2215 type Value = cancel_creating_jobs_request::CreatingJobIds;
2216
2217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2218 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
2219 }
2220
2221 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
2222 where
2223 V: serde::de::MapAccess<'de>,
2224 {
2225 let mut job_ids__ = None;
2226 while let Some(k) = map_.next_key()? {
2227 match k {
2228 GeneratedField::JobIds => {
2229 if job_ids__.is_some() {
2230 return Err(serde::de::Error::duplicate_field("jobIds"));
2231 }
2232 job_ids__ =
2233 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2234 .into_iter().map(|x| x.0).collect())
2235 ;
2236 }
2237 }
2238 }
2239 Ok(cancel_creating_jobs_request::CreatingJobIds {
2240 job_ids: job_ids__.unwrap_or_default(),
2241 })
2242 }
2243 }
2244 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2245 }
2246}
2247impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
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.database_id != 0 {
2256 len += 1;
2257 }
2258 if self.schema_id != 0 {
2259 len += 1;
2260 }
2261 if !self.name.is_empty() {
2262 len += 1;
2263 }
2264 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2265 if self.database_id != 0 {
2266 struct_ser.serialize_field("databaseId", &self.database_id)?;
2267 }
2268 if self.schema_id != 0 {
2269 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2270 }
2271 if !self.name.is_empty() {
2272 struct_ser.serialize_field("name", &self.name)?;
2273 }
2274 struct_ser.end()
2275 }
2276}
2277impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2278 #[allow(deprecated)]
2279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2280 where
2281 D: serde::Deserializer<'de>,
2282 {
2283 const FIELDS: &[&str] = &[
2284 "database_id",
2285 "databaseId",
2286 "schema_id",
2287 "schemaId",
2288 "name",
2289 ];
2290
2291 #[allow(clippy::enum_variant_names)]
2292 enum GeneratedField {
2293 DatabaseId,
2294 SchemaId,
2295 Name,
2296 }
2297 impl<'de> serde::Deserialize<'de> for GeneratedField {
2298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2299 where
2300 D: serde::Deserializer<'de>,
2301 {
2302 struct GeneratedVisitor;
2303
2304 impl serde::de::Visitor<'_> for GeneratedVisitor {
2305 type Value = GeneratedField;
2306
2307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2308 write!(formatter, "expected one of: {:?}", &FIELDS)
2309 }
2310
2311 #[allow(unused_variables)]
2312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2313 where
2314 E: serde::de::Error,
2315 {
2316 match value {
2317 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2318 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2319 "name" => Ok(GeneratedField::Name),
2320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2321 }
2322 }
2323 }
2324 deserializer.deserialize_identifier(GeneratedVisitor)
2325 }
2326 }
2327 struct GeneratedVisitor;
2328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2329 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2330
2331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2332 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2333 }
2334
2335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2336 where
2337 V: serde::de::MapAccess<'de>,
2338 {
2339 let mut database_id__ = None;
2340 let mut schema_id__ = None;
2341 let mut name__ = None;
2342 while let Some(k) = map_.next_key()? {
2343 match k {
2344 GeneratedField::DatabaseId => {
2345 if database_id__.is_some() {
2346 return Err(serde::de::Error::duplicate_field("databaseId"));
2347 }
2348 database_id__ =
2349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2350 ;
2351 }
2352 GeneratedField::SchemaId => {
2353 if schema_id__.is_some() {
2354 return Err(serde::de::Error::duplicate_field("schemaId"));
2355 }
2356 schema_id__ =
2357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2358 ;
2359 }
2360 GeneratedField::Name => {
2361 if name__.is_some() {
2362 return Err(serde::de::Error::duplicate_field("name"));
2363 }
2364 name__ = Some(map_.next_value()?);
2365 }
2366 }
2367 }
2368 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2369 database_id: database_id__.unwrap_or_default(),
2370 schema_id: schema_id__.unwrap_or_default(),
2371 name: name__.unwrap_or_default(),
2372 })
2373 }
2374 }
2375 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2376 }
2377}
2378impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2379 #[allow(deprecated)]
2380 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2381 where
2382 S: serde::Serializer,
2383 {
2384 use serde::ser::SerializeStruct;
2385 let mut len = 0;
2386 if !self.infos.is_empty() {
2387 len += 1;
2388 }
2389 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2390 if !self.infos.is_empty() {
2391 struct_ser.serialize_field("infos", &self.infos)?;
2392 }
2393 struct_ser.end()
2394 }
2395}
2396impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2397 #[allow(deprecated)]
2398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2399 where
2400 D: serde::Deserializer<'de>,
2401 {
2402 const FIELDS: &[&str] = &[
2403 "infos",
2404 ];
2405
2406 #[allow(clippy::enum_variant_names)]
2407 enum GeneratedField {
2408 Infos,
2409 }
2410 impl<'de> serde::Deserialize<'de> for GeneratedField {
2411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2412 where
2413 D: serde::Deserializer<'de>,
2414 {
2415 struct GeneratedVisitor;
2416
2417 impl serde::de::Visitor<'_> for GeneratedVisitor {
2418 type Value = GeneratedField;
2419
2420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2421 write!(formatter, "expected one of: {:?}", &FIELDS)
2422 }
2423
2424 #[allow(unused_variables)]
2425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2426 where
2427 E: serde::de::Error,
2428 {
2429 match value {
2430 "infos" => Ok(GeneratedField::Infos),
2431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2432 }
2433 }
2434 }
2435 deserializer.deserialize_identifier(GeneratedVisitor)
2436 }
2437 }
2438 struct GeneratedVisitor;
2439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2440 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2441
2442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2443 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2444 }
2445
2446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2447 where
2448 V: serde::de::MapAccess<'de>,
2449 {
2450 let mut infos__ = None;
2451 while let Some(k) = map_.next_key()? {
2452 match k {
2453 GeneratedField::Infos => {
2454 if infos__.is_some() {
2455 return Err(serde::de::Error::duplicate_field("infos"));
2456 }
2457 infos__ = Some(map_.next_value()?);
2458 }
2459 }
2460 }
2461 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2462 infos: infos__.unwrap_or_default(),
2463 })
2464 }
2465 }
2466 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2467 }
2468}
2469impl serde::Serialize for CancelCreatingJobsResponse {
2470 #[allow(deprecated)]
2471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2472 where
2473 S: serde::Serializer,
2474 {
2475 use serde::ser::SerializeStruct;
2476 let mut len = 0;
2477 if self.status.is_some() {
2478 len += 1;
2479 }
2480 if !self.canceled_jobs.is_empty() {
2481 len += 1;
2482 }
2483 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2484 if let Some(v) = self.status.as_ref() {
2485 struct_ser.serialize_field("status", v)?;
2486 }
2487 if !self.canceled_jobs.is_empty() {
2488 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2489 }
2490 struct_ser.end()
2491 }
2492}
2493impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2494 #[allow(deprecated)]
2495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2496 where
2497 D: serde::Deserializer<'de>,
2498 {
2499 const FIELDS: &[&str] = &[
2500 "status",
2501 "canceled_jobs",
2502 "canceledJobs",
2503 ];
2504
2505 #[allow(clippy::enum_variant_names)]
2506 enum GeneratedField {
2507 Status,
2508 CanceledJobs,
2509 }
2510 impl<'de> serde::Deserialize<'de> for GeneratedField {
2511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2512 where
2513 D: serde::Deserializer<'de>,
2514 {
2515 struct GeneratedVisitor;
2516
2517 impl serde::de::Visitor<'_> for GeneratedVisitor {
2518 type Value = GeneratedField;
2519
2520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2521 write!(formatter, "expected one of: {:?}", &FIELDS)
2522 }
2523
2524 #[allow(unused_variables)]
2525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2526 where
2527 E: serde::de::Error,
2528 {
2529 match value {
2530 "status" => Ok(GeneratedField::Status),
2531 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2533 }
2534 }
2535 }
2536 deserializer.deserialize_identifier(GeneratedVisitor)
2537 }
2538 }
2539 struct GeneratedVisitor;
2540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2541 type Value = CancelCreatingJobsResponse;
2542
2543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2544 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2545 }
2546
2547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2548 where
2549 V: serde::de::MapAccess<'de>,
2550 {
2551 let mut status__ = None;
2552 let mut canceled_jobs__ = None;
2553 while let Some(k) = map_.next_key()? {
2554 match k {
2555 GeneratedField::Status => {
2556 if status__.is_some() {
2557 return Err(serde::de::Error::duplicate_field("status"));
2558 }
2559 status__ = map_.next_value()?;
2560 }
2561 GeneratedField::CanceledJobs => {
2562 if canceled_jobs__.is_some() {
2563 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2564 }
2565 canceled_jobs__ =
2566 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2567 .into_iter().map(|x| x.0).collect())
2568 ;
2569 }
2570 }
2571 }
2572 Ok(CancelCreatingJobsResponse {
2573 status: status__,
2574 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2575 })
2576 }
2577 }
2578 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2579 }
2580}
2581impl serde::Serialize for ClusterLimit {
2582 #[allow(deprecated)]
2583 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2584 where
2585 S: serde::Serializer,
2586 {
2587 use serde::ser::SerializeStruct;
2588 let mut len = 0;
2589 if self.limit.is_some() {
2590 len += 1;
2591 }
2592 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2593 if let Some(v) = self.limit.as_ref() {
2594 match v {
2595 cluster_limit::Limit::ActorCount(v) => {
2596 struct_ser.serialize_field("actorCount", v)?;
2597 }
2598 }
2599 }
2600 struct_ser.end()
2601 }
2602}
2603impl<'de> serde::Deserialize<'de> for ClusterLimit {
2604 #[allow(deprecated)]
2605 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2606 where
2607 D: serde::Deserializer<'de>,
2608 {
2609 const FIELDS: &[&str] = &[
2610 "actor_count",
2611 "actorCount",
2612 ];
2613
2614 #[allow(clippy::enum_variant_names)]
2615 enum GeneratedField {
2616 ActorCount,
2617 }
2618 impl<'de> serde::Deserialize<'de> for GeneratedField {
2619 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2620 where
2621 D: serde::Deserializer<'de>,
2622 {
2623 struct GeneratedVisitor;
2624
2625 impl serde::de::Visitor<'_> for GeneratedVisitor {
2626 type Value = GeneratedField;
2627
2628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2629 write!(formatter, "expected one of: {:?}", &FIELDS)
2630 }
2631
2632 #[allow(unused_variables)]
2633 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2634 where
2635 E: serde::de::Error,
2636 {
2637 match value {
2638 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2639 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2640 }
2641 }
2642 }
2643 deserializer.deserialize_identifier(GeneratedVisitor)
2644 }
2645 }
2646 struct GeneratedVisitor;
2647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2648 type Value = ClusterLimit;
2649
2650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2651 formatter.write_str("struct meta.ClusterLimit")
2652 }
2653
2654 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2655 where
2656 V: serde::de::MapAccess<'de>,
2657 {
2658 let mut limit__ = None;
2659 while let Some(k) = map_.next_key()? {
2660 match k {
2661 GeneratedField::ActorCount => {
2662 if limit__.is_some() {
2663 return Err(serde::de::Error::duplicate_field("actorCount"));
2664 }
2665 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2666;
2667 }
2668 }
2669 }
2670 Ok(ClusterLimit {
2671 limit: limit__,
2672 })
2673 }
2674 }
2675 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2676 }
2677}
2678impl serde::Serialize for DeleteWorkerNodeRequest {
2679 #[allow(deprecated)]
2680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2681 where
2682 S: serde::Serializer,
2683 {
2684 use serde::ser::SerializeStruct;
2685 let mut len = 0;
2686 if self.host.is_some() {
2687 len += 1;
2688 }
2689 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2690 if let Some(v) = self.host.as_ref() {
2691 struct_ser.serialize_field("host", v)?;
2692 }
2693 struct_ser.end()
2694 }
2695}
2696impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2697 #[allow(deprecated)]
2698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2699 where
2700 D: serde::Deserializer<'de>,
2701 {
2702 const FIELDS: &[&str] = &[
2703 "host",
2704 ];
2705
2706 #[allow(clippy::enum_variant_names)]
2707 enum GeneratedField {
2708 Host,
2709 }
2710 impl<'de> serde::Deserialize<'de> for GeneratedField {
2711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2712 where
2713 D: serde::Deserializer<'de>,
2714 {
2715 struct GeneratedVisitor;
2716
2717 impl serde::de::Visitor<'_> for GeneratedVisitor {
2718 type Value = GeneratedField;
2719
2720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2721 write!(formatter, "expected one of: {:?}", &FIELDS)
2722 }
2723
2724 #[allow(unused_variables)]
2725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2726 where
2727 E: serde::de::Error,
2728 {
2729 match value {
2730 "host" => Ok(GeneratedField::Host),
2731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2732 }
2733 }
2734 }
2735 deserializer.deserialize_identifier(GeneratedVisitor)
2736 }
2737 }
2738 struct GeneratedVisitor;
2739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2740 type Value = DeleteWorkerNodeRequest;
2741
2742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2743 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2744 }
2745
2746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2747 where
2748 V: serde::de::MapAccess<'de>,
2749 {
2750 let mut host__ = None;
2751 while let Some(k) = map_.next_key()? {
2752 match k {
2753 GeneratedField::Host => {
2754 if host__.is_some() {
2755 return Err(serde::de::Error::duplicate_field("host"));
2756 }
2757 host__ = map_.next_value()?;
2758 }
2759 }
2760 }
2761 Ok(DeleteWorkerNodeRequest {
2762 host: host__,
2763 })
2764 }
2765 }
2766 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2767 }
2768}
2769impl serde::Serialize for DeleteWorkerNodeResponse {
2770 #[allow(deprecated)]
2771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2772 where
2773 S: serde::Serializer,
2774 {
2775 use serde::ser::SerializeStruct;
2776 let mut len = 0;
2777 if self.status.is_some() {
2778 len += 1;
2779 }
2780 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2781 if let Some(v) = self.status.as_ref() {
2782 struct_ser.serialize_field("status", v)?;
2783 }
2784 struct_ser.end()
2785 }
2786}
2787impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2788 #[allow(deprecated)]
2789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2790 where
2791 D: serde::Deserializer<'de>,
2792 {
2793 const FIELDS: &[&str] = &[
2794 "status",
2795 ];
2796
2797 #[allow(clippy::enum_variant_names)]
2798 enum GeneratedField {
2799 Status,
2800 }
2801 impl<'de> serde::Deserialize<'de> for GeneratedField {
2802 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2803 where
2804 D: serde::Deserializer<'de>,
2805 {
2806 struct GeneratedVisitor;
2807
2808 impl serde::de::Visitor<'_> for GeneratedVisitor {
2809 type Value = GeneratedField;
2810
2811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2812 write!(formatter, "expected one of: {:?}", &FIELDS)
2813 }
2814
2815 #[allow(unused_variables)]
2816 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2817 where
2818 E: serde::de::Error,
2819 {
2820 match value {
2821 "status" => Ok(GeneratedField::Status),
2822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2823 }
2824 }
2825 }
2826 deserializer.deserialize_identifier(GeneratedVisitor)
2827 }
2828 }
2829 struct GeneratedVisitor;
2830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2831 type Value = DeleteWorkerNodeResponse;
2832
2833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2834 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2835 }
2836
2837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2838 where
2839 V: serde::de::MapAccess<'de>,
2840 {
2841 let mut status__ = None;
2842 while let Some(k) = map_.next_key()? {
2843 match k {
2844 GeneratedField::Status => {
2845 if status__.is_some() {
2846 return Err(serde::de::Error::duplicate_field("status"));
2847 }
2848 status__ = map_.next_value()?;
2849 }
2850 }
2851 }
2852 Ok(DeleteWorkerNodeResponse {
2853 status: status__,
2854 })
2855 }
2856 }
2857 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2858 }
2859}
2860impl serde::Serialize for EventLog {
2861 #[allow(deprecated)]
2862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2863 where
2864 S: serde::Serializer,
2865 {
2866 use serde::ser::SerializeStruct;
2867 let mut len = 0;
2868 if self.unique_id.is_some() {
2869 len += 1;
2870 }
2871 if self.timestamp.is_some() {
2872 len += 1;
2873 }
2874 if self.event.is_some() {
2875 len += 1;
2876 }
2877 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2878 if let Some(v) = self.unique_id.as_ref() {
2879 struct_ser.serialize_field("uniqueId", v)?;
2880 }
2881 if let Some(v) = self.timestamp.as_ref() {
2882 #[allow(clippy::needless_borrow)]
2883 #[allow(clippy::needless_borrows_for_generic_args)]
2884 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2885 }
2886 if let Some(v) = self.event.as_ref() {
2887 match v {
2888 event_log::Event::CreateStreamJobFail(v) => {
2889 struct_ser.serialize_field("createStreamJobFail", v)?;
2890 }
2891 event_log::Event::DirtyStreamJobClear(v) => {
2892 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2893 }
2894 event_log::Event::MetaNodeStart(v) => {
2895 struct_ser.serialize_field("metaNodeStart", v)?;
2896 }
2897 event_log::Event::BarrierComplete(v) => {
2898 struct_ser.serialize_field("barrierComplete", v)?;
2899 }
2900 event_log::Event::InjectBarrierFail(v) => {
2901 struct_ser.serialize_field("injectBarrierFail", v)?;
2902 }
2903 event_log::Event::CollectBarrierFail(v) => {
2904 struct_ser.serialize_field("collectBarrierFail", v)?;
2905 }
2906 event_log::Event::WorkerNodePanic(v) => {
2907 struct_ser.serialize_field("workerNodePanic", v)?;
2908 }
2909 event_log::Event::AutoSchemaChangeFail(v) => {
2910 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2911 }
2912 event_log::Event::SinkFail(v) => {
2913 struct_ser.serialize_field("sinkFail", v)?;
2914 }
2915 event_log::Event::Recovery(v) => {
2916 struct_ser.serialize_field("recovery", v)?;
2917 }
2918 }
2919 }
2920 struct_ser.end()
2921 }
2922}
2923impl<'de> serde::Deserialize<'de> for EventLog {
2924 #[allow(deprecated)]
2925 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2926 where
2927 D: serde::Deserializer<'de>,
2928 {
2929 const FIELDS: &[&str] = &[
2930 "unique_id",
2931 "uniqueId",
2932 "timestamp",
2933 "create_stream_job_fail",
2934 "createStreamJobFail",
2935 "dirty_stream_job_clear",
2936 "dirtyStreamJobClear",
2937 "meta_node_start",
2938 "metaNodeStart",
2939 "barrier_complete",
2940 "barrierComplete",
2941 "inject_barrier_fail",
2942 "injectBarrierFail",
2943 "collect_barrier_fail",
2944 "collectBarrierFail",
2945 "worker_node_panic",
2946 "workerNodePanic",
2947 "auto_schema_change_fail",
2948 "autoSchemaChangeFail",
2949 "sink_fail",
2950 "sinkFail",
2951 "recovery",
2952 ];
2953
2954 #[allow(clippy::enum_variant_names)]
2955 enum GeneratedField {
2956 UniqueId,
2957 Timestamp,
2958 CreateStreamJobFail,
2959 DirtyStreamJobClear,
2960 MetaNodeStart,
2961 BarrierComplete,
2962 InjectBarrierFail,
2963 CollectBarrierFail,
2964 WorkerNodePanic,
2965 AutoSchemaChangeFail,
2966 SinkFail,
2967 Recovery,
2968 }
2969 impl<'de> serde::Deserialize<'de> for GeneratedField {
2970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2971 where
2972 D: serde::Deserializer<'de>,
2973 {
2974 struct GeneratedVisitor;
2975
2976 impl serde::de::Visitor<'_> for GeneratedVisitor {
2977 type Value = GeneratedField;
2978
2979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2980 write!(formatter, "expected one of: {:?}", &FIELDS)
2981 }
2982
2983 #[allow(unused_variables)]
2984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2985 where
2986 E: serde::de::Error,
2987 {
2988 match value {
2989 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2990 "timestamp" => Ok(GeneratedField::Timestamp),
2991 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2992 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2993 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2994 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2995 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2996 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2997 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2998 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2999 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
3000 "recovery" => Ok(GeneratedField::Recovery),
3001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3002 }
3003 }
3004 }
3005 deserializer.deserialize_identifier(GeneratedVisitor)
3006 }
3007 }
3008 struct GeneratedVisitor;
3009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3010 type Value = EventLog;
3011
3012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3013 formatter.write_str("struct meta.EventLog")
3014 }
3015
3016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
3017 where
3018 V: serde::de::MapAccess<'de>,
3019 {
3020 let mut unique_id__ = None;
3021 let mut timestamp__ = None;
3022 let mut event__ = None;
3023 while let Some(k) = map_.next_key()? {
3024 match k {
3025 GeneratedField::UniqueId => {
3026 if unique_id__.is_some() {
3027 return Err(serde::de::Error::duplicate_field("uniqueId"));
3028 }
3029 unique_id__ = map_.next_value()?;
3030 }
3031 GeneratedField::Timestamp => {
3032 if timestamp__.is_some() {
3033 return Err(serde::de::Error::duplicate_field("timestamp"));
3034 }
3035 timestamp__ =
3036 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3037 ;
3038 }
3039 GeneratedField::CreateStreamJobFail => {
3040 if event__.is_some() {
3041 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
3042 }
3043 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
3044;
3045 }
3046 GeneratedField::DirtyStreamJobClear => {
3047 if event__.is_some() {
3048 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
3049 }
3050 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
3051;
3052 }
3053 GeneratedField::MetaNodeStart => {
3054 if event__.is_some() {
3055 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
3056 }
3057 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
3058;
3059 }
3060 GeneratedField::BarrierComplete => {
3061 if event__.is_some() {
3062 return Err(serde::de::Error::duplicate_field("barrierComplete"));
3063 }
3064 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
3065;
3066 }
3067 GeneratedField::InjectBarrierFail => {
3068 if event__.is_some() {
3069 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
3070 }
3071 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
3072;
3073 }
3074 GeneratedField::CollectBarrierFail => {
3075 if event__.is_some() {
3076 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
3077 }
3078 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
3079;
3080 }
3081 GeneratedField::WorkerNodePanic => {
3082 if event__.is_some() {
3083 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
3084 }
3085 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
3086;
3087 }
3088 GeneratedField::AutoSchemaChangeFail => {
3089 if event__.is_some() {
3090 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
3091 }
3092 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
3093;
3094 }
3095 GeneratedField::SinkFail => {
3096 if event__.is_some() {
3097 return Err(serde::de::Error::duplicate_field("sinkFail"));
3098 }
3099 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
3100;
3101 }
3102 GeneratedField::Recovery => {
3103 if event__.is_some() {
3104 return Err(serde::de::Error::duplicate_field("recovery"));
3105 }
3106 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
3107;
3108 }
3109 }
3110 }
3111 Ok(EventLog {
3112 unique_id: unique_id__,
3113 timestamp: timestamp__,
3114 event: event__,
3115 })
3116 }
3117 }
3118 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
3119 }
3120}
3121impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
3122 #[allow(deprecated)]
3123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3124 where
3125 S: serde::Serializer,
3126 {
3127 use serde::ser::SerializeStruct;
3128 let mut len = 0;
3129 if self.table_id != 0 {
3130 len += 1;
3131 }
3132 if !self.table_name.is_empty() {
3133 len += 1;
3134 }
3135 if !self.cdc_table_id.is_empty() {
3136 len += 1;
3137 }
3138 if !self.upstream_ddl.is_empty() {
3139 len += 1;
3140 }
3141 if !self.fail_info.is_empty() {
3142 len += 1;
3143 }
3144 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
3145 if self.table_id != 0 {
3146 struct_ser.serialize_field("tableId", &self.table_id)?;
3147 }
3148 if !self.table_name.is_empty() {
3149 struct_ser.serialize_field("tableName", &self.table_name)?;
3150 }
3151 if !self.cdc_table_id.is_empty() {
3152 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
3153 }
3154 if !self.upstream_ddl.is_empty() {
3155 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
3156 }
3157 if !self.fail_info.is_empty() {
3158 struct_ser.serialize_field("failInfo", &self.fail_info)?;
3159 }
3160 struct_ser.end()
3161 }
3162}
3163impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
3164 #[allow(deprecated)]
3165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3166 where
3167 D: serde::Deserializer<'de>,
3168 {
3169 const FIELDS: &[&str] = &[
3170 "table_id",
3171 "tableId",
3172 "table_name",
3173 "tableName",
3174 "cdc_table_id",
3175 "cdcTableId",
3176 "upstream_ddl",
3177 "upstreamDdl",
3178 "fail_info",
3179 "failInfo",
3180 ];
3181
3182 #[allow(clippy::enum_variant_names)]
3183 enum GeneratedField {
3184 TableId,
3185 TableName,
3186 CdcTableId,
3187 UpstreamDdl,
3188 FailInfo,
3189 }
3190 impl<'de> serde::Deserialize<'de> for GeneratedField {
3191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3192 where
3193 D: serde::Deserializer<'de>,
3194 {
3195 struct GeneratedVisitor;
3196
3197 impl serde::de::Visitor<'_> for GeneratedVisitor {
3198 type Value = GeneratedField;
3199
3200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3201 write!(formatter, "expected one of: {:?}", &FIELDS)
3202 }
3203
3204 #[allow(unused_variables)]
3205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3206 where
3207 E: serde::de::Error,
3208 {
3209 match value {
3210 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3211 "tableName" | "table_name" => Ok(GeneratedField::TableName),
3212 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
3213 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
3214 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
3215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3216 }
3217 }
3218 }
3219 deserializer.deserialize_identifier(GeneratedVisitor)
3220 }
3221 }
3222 struct GeneratedVisitor;
3223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3224 type Value = event_log::EventAutoSchemaChangeFail;
3225
3226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3227 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
3228 }
3229
3230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
3231 where
3232 V: serde::de::MapAccess<'de>,
3233 {
3234 let mut table_id__ = None;
3235 let mut table_name__ = None;
3236 let mut cdc_table_id__ = None;
3237 let mut upstream_ddl__ = None;
3238 let mut fail_info__ = None;
3239 while let Some(k) = map_.next_key()? {
3240 match k {
3241 GeneratedField::TableId => {
3242 if table_id__.is_some() {
3243 return Err(serde::de::Error::duplicate_field("tableId"));
3244 }
3245 table_id__ =
3246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3247 ;
3248 }
3249 GeneratedField::TableName => {
3250 if table_name__.is_some() {
3251 return Err(serde::de::Error::duplicate_field("tableName"));
3252 }
3253 table_name__ = Some(map_.next_value()?);
3254 }
3255 GeneratedField::CdcTableId => {
3256 if cdc_table_id__.is_some() {
3257 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3258 }
3259 cdc_table_id__ = Some(map_.next_value()?);
3260 }
3261 GeneratedField::UpstreamDdl => {
3262 if upstream_ddl__.is_some() {
3263 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3264 }
3265 upstream_ddl__ = Some(map_.next_value()?);
3266 }
3267 GeneratedField::FailInfo => {
3268 if fail_info__.is_some() {
3269 return Err(serde::de::Error::duplicate_field("failInfo"));
3270 }
3271 fail_info__ = Some(map_.next_value()?);
3272 }
3273 }
3274 }
3275 Ok(event_log::EventAutoSchemaChangeFail {
3276 table_id: table_id__.unwrap_or_default(),
3277 table_name: table_name__.unwrap_or_default(),
3278 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3279 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3280 fail_info: fail_info__.unwrap_or_default(),
3281 })
3282 }
3283 }
3284 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3285 }
3286}
3287impl serde::Serialize for event_log::EventBarrierComplete {
3288 #[allow(deprecated)]
3289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3290 where
3291 S: serde::Serializer,
3292 {
3293 use serde::ser::SerializeStruct;
3294 let mut len = 0;
3295 if self.prev_epoch != 0 {
3296 len += 1;
3297 }
3298 if self.cur_epoch != 0 {
3299 len += 1;
3300 }
3301 if self.duration_sec != 0. {
3302 len += 1;
3303 }
3304 if !self.command.is_empty() {
3305 len += 1;
3306 }
3307 if !self.barrier_kind.is_empty() {
3308 len += 1;
3309 }
3310 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3311 if self.prev_epoch != 0 {
3312 #[allow(clippy::needless_borrow)]
3313 #[allow(clippy::needless_borrows_for_generic_args)]
3314 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3315 }
3316 if self.cur_epoch != 0 {
3317 #[allow(clippy::needless_borrow)]
3318 #[allow(clippy::needless_borrows_for_generic_args)]
3319 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3320 }
3321 if self.duration_sec != 0. {
3322 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3323 }
3324 if !self.command.is_empty() {
3325 struct_ser.serialize_field("command", &self.command)?;
3326 }
3327 if !self.barrier_kind.is_empty() {
3328 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3329 }
3330 struct_ser.end()
3331 }
3332}
3333impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3334 #[allow(deprecated)]
3335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3336 where
3337 D: serde::Deserializer<'de>,
3338 {
3339 const FIELDS: &[&str] = &[
3340 "prev_epoch",
3341 "prevEpoch",
3342 "cur_epoch",
3343 "curEpoch",
3344 "duration_sec",
3345 "durationSec",
3346 "command",
3347 "barrier_kind",
3348 "barrierKind",
3349 ];
3350
3351 #[allow(clippy::enum_variant_names)]
3352 enum GeneratedField {
3353 PrevEpoch,
3354 CurEpoch,
3355 DurationSec,
3356 Command,
3357 BarrierKind,
3358 }
3359 impl<'de> serde::Deserialize<'de> for GeneratedField {
3360 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3361 where
3362 D: serde::Deserializer<'de>,
3363 {
3364 struct GeneratedVisitor;
3365
3366 impl serde::de::Visitor<'_> for GeneratedVisitor {
3367 type Value = GeneratedField;
3368
3369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3370 write!(formatter, "expected one of: {:?}", &FIELDS)
3371 }
3372
3373 #[allow(unused_variables)]
3374 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3375 where
3376 E: serde::de::Error,
3377 {
3378 match value {
3379 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3380 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3381 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3382 "command" => Ok(GeneratedField::Command),
3383 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3385 }
3386 }
3387 }
3388 deserializer.deserialize_identifier(GeneratedVisitor)
3389 }
3390 }
3391 struct GeneratedVisitor;
3392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3393 type Value = event_log::EventBarrierComplete;
3394
3395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3396 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3397 }
3398
3399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3400 where
3401 V: serde::de::MapAccess<'de>,
3402 {
3403 let mut prev_epoch__ = None;
3404 let mut cur_epoch__ = None;
3405 let mut duration_sec__ = None;
3406 let mut command__ = None;
3407 let mut barrier_kind__ = None;
3408 while let Some(k) = map_.next_key()? {
3409 match k {
3410 GeneratedField::PrevEpoch => {
3411 if prev_epoch__.is_some() {
3412 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3413 }
3414 prev_epoch__ =
3415 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3416 ;
3417 }
3418 GeneratedField::CurEpoch => {
3419 if cur_epoch__.is_some() {
3420 return Err(serde::de::Error::duplicate_field("curEpoch"));
3421 }
3422 cur_epoch__ =
3423 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3424 ;
3425 }
3426 GeneratedField::DurationSec => {
3427 if duration_sec__.is_some() {
3428 return Err(serde::de::Error::duplicate_field("durationSec"));
3429 }
3430 duration_sec__ =
3431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3432 ;
3433 }
3434 GeneratedField::Command => {
3435 if command__.is_some() {
3436 return Err(serde::de::Error::duplicate_field("command"));
3437 }
3438 command__ = Some(map_.next_value()?);
3439 }
3440 GeneratedField::BarrierKind => {
3441 if barrier_kind__.is_some() {
3442 return Err(serde::de::Error::duplicate_field("barrierKind"));
3443 }
3444 barrier_kind__ = Some(map_.next_value()?);
3445 }
3446 }
3447 }
3448 Ok(event_log::EventBarrierComplete {
3449 prev_epoch: prev_epoch__.unwrap_or_default(),
3450 cur_epoch: cur_epoch__.unwrap_or_default(),
3451 duration_sec: duration_sec__.unwrap_or_default(),
3452 command: command__.unwrap_or_default(),
3453 barrier_kind: barrier_kind__.unwrap_or_default(),
3454 })
3455 }
3456 }
3457 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3458 }
3459}
3460impl serde::Serialize for event_log::EventCollectBarrierFail {
3461 #[allow(deprecated)]
3462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3463 where
3464 S: serde::Serializer,
3465 {
3466 use serde::ser::SerializeStruct;
3467 let mut len = 0;
3468 if !self.error.is_empty() {
3469 len += 1;
3470 }
3471 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3472 if !self.error.is_empty() {
3473 struct_ser.serialize_field("error", &self.error)?;
3474 }
3475 struct_ser.end()
3476 }
3477}
3478impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3479 #[allow(deprecated)]
3480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3481 where
3482 D: serde::Deserializer<'de>,
3483 {
3484 const FIELDS: &[&str] = &[
3485 "error",
3486 ];
3487
3488 #[allow(clippy::enum_variant_names)]
3489 enum GeneratedField {
3490 Error,
3491 }
3492 impl<'de> serde::Deserialize<'de> for GeneratedField {
3493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3494 where
3495 D: serde::Deserializer<'de>,
3496 {
3497 struct GeneratedVisitor;
3498
3499 impl serde::de::Visitor<'_> for GeneratedVisitor {
3500 type Value = GeneratedField;
3501
3502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3503 write!(formatter, "expected one of: {:?}", &FIELDS)
3504 }
3505
3506 #[allow(unused_variables)]
3507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3508 where
3509 E: serde::de::Error,
3510 {
3511 match value {
3512 "error" => Ok(GeneratedField::Error),
3513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3514 }
3515 }
3516 }
3517 deserializer.deserialize_identifier(GeneratedVisitor)
3518 }
3519 }
3520 struct GeneratedVisitor;
3521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3522 type Value = event_log::EventCollectBarrierFail;
3523
3524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3525 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3526 }
3527
3528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3529 where
3530 V: serde::de::MapAccess<'de>,
3531 {
3532 let mut error__ = None;
3533 while let Some(k) = map_.next_key()? {
3534 match k {
3535 GeneratedField::Error => {
3536 if error__.is_some() {
3537 return Err(serde::de::Error::duplicate_field("error"));
3538 }
3539 error__ = Some(map_.next_value()?);
3540 }
3541 }
3542 }
3543 Ok(event_log::EventCollectBarrierFail {
3544 error: error__.unwrap_or_default(),
3545 })
3546 }
3547 }
3548 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3549 }
3550}
3551impl serde::Serialize for event_log::EventCreateStreamJobFail {
3552 #[allow(deprecated)]
3553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3554 where
3555 S: serde::Serializer,
3556 {
3557 use serde::ser::SerializeStruct;
3558 let mut len = 0;
3559 if self.id != 0 {
3560 len += 1;
3561 }
3562 if !self.name.is_empty() {
3563 len += 1;
3564 }
3565 if !self.definition.is_empty() {
3566 len += 1;
3567 }
3568 if !self.error.is_empty() {
3569 len += 1;
3570 }
3571 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3572 if self.id != 0 {
3573 struct_ser.serialize_field("id", &self.id)?;
3574 }
3575 if !self.name.is_empty() {
3576 struct_ser.serialize_field("name", &self.name)?;
3577 }
3578 if !self.definition.is_empty() {
3579 struct_ser.serialize_field("definition", &self.definition)?;
3580 }
3581 if !self.error.is_empty() {
3582 struct_ser.serialize_field("error", &self.error)?;
3583 }
3584 struct_ser.end()
3585 }
3586}
3587impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3588 #[allow(deprecated)]
3589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3590 where
3591 D: serde::Deserializer<'de>,
3592 {
3593 const FIELDS: &[&str] = &[
3594 "id",
3595 "name",
3596 "definition",
3597 "error",
3598 ];
3599
3600 #[allow(clippy::enum_variant_names)]
3601 enum GeneratedField {
3602 Id,
3603 Name,
3604 Definition,
3605 Error,
3606 }
3607 impl<'de> serde::Deserialize<'de> for GeneratedField {
3608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3609 where
3610 D: serde::Deserializer<'de>,
3611 {
3612 struct GeneratedVisitor;
3613
3614 impl serde::de::Visitor<'_> for GeneratedVisitor {
3615 type Value = GeneratedField;
3616
3617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3618 write!(formatter, "expected one of: {:?}", &FIELDS)
3619 }
3620
3621 #[allow(unused_variables)]
3622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3623 where
3624 E: serde::de::Error,
3625 {
3626 match value {
3627 "id" => Ok(GeneratedField::Id),
3628 "name" => Ok(GeneratedField::Name),
3629 "definition" => Ok(GeneratedField::Definition),
3630 "error" => Ok(GeneratedField::Error),
3631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632 }
3633 }
3634 }
3635 deserializer.deserialize_identifier(GeneratedVisitor)
3636 }
3637 }
3638 struct GeneratedVisitor;
3639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640 type Value = event_log::EventCreateStreamJobFail;
3641
3642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3644 }
3645
3646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3647 where
3648 V: serde::de::MapAccess<'de>,
3649 {
3650 let mut id__ = None;
3651 let mut name__ = None;
3652 let mut definition__ = None;
3653 let mut error__ = None;
3654 while let Some(k) = map_.next_key()? {
3655 match k {
3656 GeneratedField::Id => {
3657 if id__.is_some() {
3658 return Err(serde::de::Error::duplicate_field("id"));
3659 }
3660 id__ =
3661 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3662 ;
3663 }
3664 GeneratedField::Name => {
3665 if name__.is_some() {
3666 return Err(serde::de::Error::duplicate_field("name"));
3667 }
3668 name__ = Some(map_.next_value()?);
3669 }
3670 GeneratedField::Definition => {
3671 if definition__.is_some() {
3672 return Err(serde::de::Error::duplicate_field("definition"));
3673 }
3674 definition__ = Some(map_.next_value()?);
3675 }
3676 GeneratedField::Error => {
3677 if error__.is_some() {
3678 return Err(serde::de::Error::duplicate_field("error"));
3679 }
3680 error__ = Some(map_.next_value()?);
3681 }
3682 }
3683 }
3684 Ok(event_log::EventCreateStreamJobFail {
3685 id: id__.unwrap_or_default(),
3686 name: name__.unwrap_or_default(),
3687 definition: definition__.unwrap_or_default(),
3688 error: error__.unwrap_or_default(),
3689 })
3690 }
3691 }
3692 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3693 }
3694}
3695impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3696 #[allow(deprecated)]
3697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3698 where
3699 S: serde::Serializer,
3700 {
3701 use serde::ser::SerializeStruct;
3702 let mut len = 0;
3703 if self.id != 0 {
3704 len += 1;
3705 }
3706 if !self.name.is_empty() {
3707 len += 1;
3708 }
3709 if !self.definition.is_empty() {
3710 len += 1;
3711 }
3712 if !self.error.is_empty() {
3713 len += 1;
3714 }
3715 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3716 if self.id != 0 {
3717 struct_ser.serialize_field("id", &self.id)?;
3718 }
3719 if !self.name.is_empty() {
3720 struct_ser.serialize_field("name", &self.name)?;
3721 }
3722 if !self.definition.is_empty() {
3723 struct_ser.serialize_field("definition", &self.definition)?;
3724 }
3725 if !self.error.is_empty() {
3726 struct_ser.serialize_field("error", &self.error)?;
3727 }
3728 struct_ser.end()
3729 }
3730}
3731impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3732 #[allow(deprecated)]
3733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3734 where
3735 D: serde::Deserializer<'de>,
3736 {
3737 const FIELDS: &[&str] = &[
3738 "id",
3739 "name",
3740 "definition",
3741 "error",
3742 ];
3743
3744 #[allow(clippy::enum_variant_names)]
3745 enum GeneratedField {
3746 Id,
3747 Name,
3748 Definition,
3749 Error,
3750 }
3751 impl<'de> serde::Deserialize<'de> for GeneratedField {
3752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3753 where
3754 D: serde::Deserializer<'de>,
3755 {
3756 struct GeneratedVisitor;
3757
3758 impl serde::de::Visitor<'_> for GeneratedVisitor {
3759 type Value = GeneratedField;
3760
3761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3762 write!(formatter, "expected one of: {:?}", &FIELDS)
3763 }
3764
3765 #[allow(unused_variables)]
3766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3767 where
3768 E: serde::de::Error,
3769 {
3770 match value {
3771 "id" => Ok(GeneratedField::Id),
3772 "name" => Ok(GeneratedField::Name),
3773 "definition" => Ok(GeneratedField::Definition),
3774 "error" => Ok(GeneratedField::Error),
3775 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3776 }
3777 }
3778 }
3779 deserializer.deserialize_identifier(GeneratedVisitor)
3780 }
3781 }
3782 struct GeneratedVisitor;
3783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3784 type Value = event_log::EventDirtyStreamJobClear;
3785
3786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3787 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3788 }
3789
3790 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3791 where
3792 V: serde::de::MapAccess<'de>,
3793 {
3794 let mut id__ = None;
3795 let mut name__ = None;
3796 let mut definition__ = None;
3797 let mut error__ = None;
3798 while let Some(k) = map_.next_key()? {
3799 match k {
3800 GeneratedField::Id => {
3801 if id__.is_some() {
3802 return Err(serde::de::Error::duplicate_field("id"));
3803 }
3804 id__ =
3805 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3806 ;
3807 }
3808 GeneratedField::Name => {
3809 if name__.is_some() {
3810 return Err(serde::de::Error::duplicate_field("name"));
3811 }
3812 name__ = Some(map_.next_value()?);
3813 }
3814 GeneratedField::Definition => {
3815 if definition__.is_some() {
3816 return Err(serde::de::Error::duplicate_field("definition"));
3817 }
3818 definition__ = Some(map_.next_value()?);
3819 }
3820 GeneratedField::Error => {
3821 if error__.is_some() {
3822 return Err(serde::de::Error::duplicate_field("error"));
3823 }
3824 error__ = Some(map_.next_value()?);
3825 }
3826 }
3827 }
3828 Ok(event_log::EventDirtyStreamJobClear {
3829 id: id__.unwrap_or_default(),
3830 name: name__.unwrap_or_default(),
3831 definition: definition__.unwrap_or_default(),
3832 error: error__.unwrap_or_default(),
3833 })
3834 }
3835 }
3836 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3837 }
3838}
3839impl serde::Serialize for event_log::EventInjectBarrierFail {
3840 #[allow(deprecated)]
3841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3842 where
3843 S: serde::Serializer,
3844 {
3845 use serde::ser::SerializeStruct;
3846 let mut len = 0;
3847 if self.prev_epoch != 0 {
3848 len += 1;
3849 }
3850 if self.cur_epoch != 0 {
3851 len += 1;
3852 }
3853 if !self.error.is_empty() {
3854 len += 1;
3855 }
3856 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3857 if self.prev_epoch != 0 {
3858 #[allow(clippy::needless_borrow)]
3859 #[allow(clippy::needless_borrows_for_generic_args)]
3860 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3861 }
3862 if self.cur_epoch != 0 {
3863 #[allow(clippy::needless_borrow)]
3864 #[allow(clippy::needless_borrows_for_generic_args)]
3865 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3866 }
3867 if !self.error.is_empty() {
3868 struct_ser.serialize_field("error", &self.error)?;
3869 }
3870 struct_ser.end()
3871 }
3872}
3873impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3874 #[allow(deprecated)]
3875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3876 where
3877 D: serde::Deserializer<'de>,
3878 {
3879 const FIELDS: &[&str] = &[
3880 "prev_epoch",
3881 "prevEpoch",
3882 "cur_epoch",
3883 "curEpoch",
3884 "error",
3885 ];
3886
3887 #[allow(clippy::enum_variant_names)]
3888 enum GeneratedField {
3889 PrevEpoch,
3890 CurEpoch,
3891 Error,
3892 }
3893 impl<'de> serde::Deserialize<'de> for GeneratedField {
3894 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3895 where
3896 D: serde::Deserializer<'de>,
3897 {
3898 struct GeneratedVisitor;
3899
3900 impl serde::de::Visitor<'_> for GeneratedVisitor {
3901 type Value = GeneratedField;
3902
3903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3904 write!(formatter, "expected one of: {:?}", &FIELDS)
3905 }
3906
3907 #[allow(unused_variables)]
3908 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3909 where
3910 E: serde::de::Error,
3911 {
3912 match value {
3913 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3914 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3915 "error" => Ok(GeneratedField::Error),
3916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3917 }
3918 }
3919 }
3920 deserializer.deserialize_identifier(GeneratedVisitor)
3921 }
3922 }
3923 struct GeneratedVisitor;
3924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3925 type Value = event_log::EventInjectBarrierFail;
3926
3927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3928 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3929 }
3930
3931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3932 where
3933 V: serde::de::MapAccess<'de>,
3934 {
3935 let mut prev_epoch__ = None;
3936 let mut cur_epoch__ = None;
3937 let mut error__ = None;
3938 while let Some(k) = map_.next_key()? {
3939 match k {
3940 GeneratedField::PrevEpoch => {
3941 if prev_epoch__.is_some() {
3942 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3943 }
3944 prev_epoch__ =
3945 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3946 ;
3947 }
3948 GeneratedField::CurEpoch => {
3949 if cur_epoch__.is_some() {
3950 return Err(serde::de::Error::duplicate_field("curEpoch"));
3951 }
3952 cur_epoch__ =
3953 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3954 ;
3955 }
3956 GeneratedField::Error => {
3957 if error__.is_some() {
3958 return Err(serde::de::Error::duplicate_field("error"));
3959 }
3960 error__ = Some(map_.next_value()?);
3961 }
3962 }
3963 }
3964 Ok(event_log::EventInjectBarrierFail {
3965 prev_epoch: prev_epoch__.unwrap_or_default(),
3966 cur_epoch: cur_epoch__.unwrap_or_default(),
3967 error: error__.unwrap_or_default(),
3968 })
3969 }
3970 }
3971 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3972 }
3973}
3974impl serde::Serialize for event_log::EventMetaNodeStart {
3975 #[allow(deprecated)]
3976 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3977 where
3978 S: serde::Serializer,
3979 {
3980 use serde::ser::SerializeStruct;
3981 let mut len = 0;
3982 if !self.advertise_addr.is_empty() {
3983 len += 1;
3984 }
3985 if !self.listen_addr.is_empty() {
3986 len += 1;
3987 }
3988 if !self.opts.is_empty() {
3989 len += 1;
3990 }
3991 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3992 if !self.advertise_addr.is_empty() {
3993 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3994 }
3995 if !self.listen_addr.is_empty() {
3996 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3997 }
3998 if !self.opts.is_empty() {
3999 struct_ser.serialize_field("opts", &self.opts)?;
4000 }
4001 struct_ser.end()
4002 }
4003}
4004impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
4005 #[allow(deprecated)]
4006 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4007 where
4008 D: serde::Deserializer<'de>,
4009 {
4010 const FIELDS: &[&str] = &[
4011 "advertise_addr",
4012 "advertiseAddr",
4013 "listen_addr",
4014 "listenAddr",
4015 "opts",
4016 ];
4017
4018 #[allow(clippy::enum_variant_names)]
4019 enum GeneratedField {
4020 AdvertiseAddr,
4021 ListenAddr,
4022 Opts,
4023 }
4024 impl<'de> serde::Deserialize<'de> for GeneratedField {
4025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4026 where
4027 D: serde::Deserializer<'de>,
4028 {
4029 struct GeneratedVisitor;
4030
4031 impl serde::de::Visitor<'_> for GeneratedVisitor {
4032 type Value = GeneratedField;
4033
4034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4035 write!(formatter, "expected one of: {:?}", &FIELDS)
4036 }
4037
4038 #[allow(unused_variables)]
4039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4040 where
4041 E: serde::de::Error,
4042 {
4043 match value {
4044 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
4045 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
4046 "opts" => Ok(GeneratedField::Opts),
4047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4048 }
4049 }
4050 }
4051 deserializer.deserialize_identifier(GeneratedVisitor)
4052 }
4053 }
4054 struct GeneratedVisitor;
4055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4056 type Value = event_log::EventMetaNodeStart;
4057
4058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4059 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
4060 }
4061
4062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
4063 where
4064 V: serde::de::MapAccess<'de>,
4065 {
4066 let mut advertise_addr__ = None;
4067 let mut listen_addr__ = None;
4068 let mut opts__ = None;
4069 while let Some(k) = map_.next_key()? {
4070 match k {
4071 GeneratedField::AdvertiseAddr => {
4072 if advertise_addr__.is_some() {
4073 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
4074 }
4075 advertise_addr__ = Some(map_.next_value()?);
4076 }
4077 GeneratedField::ListenAddr => {
4078 if listen_addr__.is_some() {
4079 return Err(serde::de::Error::duplicate_field("listenAddr"));
4080 }
4081 listen_addr__ = Some(map_.next_value()?);
4082 }
4083 GeneratedField::Opts => {
4084 if opts__.is_some() {
4085 return Err(serde::de::Error::duplicate_field("opts"));
4086 }
4087 opts__ = Some(map_.next_value()?);
4088 }
4089 }
4090 }
4091 Ok(event_log::EventMetaNodeStart {
4092 advertise_addr: advertise_addr__.unwrap_or_default(),
4093 listen_addr: listen_addr__.unwrap_or_default(),
4094 opts: opts__.unwrap_or_default(),
4095 })
4096 }
4097 }
4098 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
4099 }
4100}
4101impl serde::Serialize for event_log::EventRecovery {
4102 #[allow(deprecated)]
4103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4104 where
4105 S: serde::Serializer,
4106 {
4107 use serde::ser::SerializeStruct;
4108 let mut len = 0;
4109 if self.recovery_event.is_some() {
4110 len += 1;
4111 }
4112 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
4113 if let Some(v) = self.recovery_event.as_ref() {
4114 match v {
4115 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
4116 struct_ser.serialize_field("globalStart", v)?;
4117 }
4118 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
4119 struct_ser.serialize_field("globalSuccess", v)?;
4120 }
4121 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
4122 struct_ser.serialize_field("globalFailure", v)?;
4123 }
4124 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
4125 struct_ser.serialize_field("databaseStart", v)?;
4126 }
4127 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
4128 struct_ser.serialize_field("databaseFailure", v)?;
4129 }
4130 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
4131 struct_ser.serialize_field("databaseSuccess", v)?;
4132 }
4133 }
4134 }
4135 struct_ser.end()
4136 }
4137}
4138impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
4139 #[allow(deprecated)]
4140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4141 where
4142 D: serde::Deserializer<'de>,
4143 {
4144 const FIELDS: &[&str] = &[
4145 "global_start",
4146 "globalStart",
4147 "global_success",
4148 "globalSuccess",
4149 "global_failure",
4150 "globalFailure",
4151 "database_start",
4152 "databaseStart",
4153 "database_failure",
4154 "databaseFailure",
4155 "database_success",
4156 "databaseSuccess",
4157 ];
4158
4159 #[allow(clippy::enum_variant_names)]
4160 enum GeneratedField {
4161 GlobalStart,
4162 GlobalSuccess,
4163 GlobalFailure,
4164 DatabaseStart,
4165 DatabaseFailure,
4166 DatabaseSuccess,
4167 }
4168 impl<'de> serde::Deserialize<'de> for GeneratedField {
4169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4170 where
4171 D: serde::Deserializer<'de>,
4172 {
4173 struct GeneratedVisitor;
4174
4175 impl serde::de::Visitor<'_> for GeneratedVisitor {
4176 type Value = GeneratedField;
4177
4178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4179 write!(formatter, "expected one of: {:?}", &FIELDS)
4180 }
4181
4182 #[allow(unused_variables)]
4183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4184 where
4185 E: serde::de::Error,
4186 {
4187 match value {
4188 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
4189 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
4190 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
4191 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
4192 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
4193 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
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::EventRecovery;
4204
4205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4206 formatter.write_str("struct meta.EventLog.EventRecovery")
4207 }
4208
4209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
4210 where
4211 V: serde::de::MapAccess<'de>,
4212 {
4213 let mut recovery_event__ = None;
4214 while let Some(k) = map_.next_key()? {
4215 match k {
4216 GeneratedField::GlobalStart => {
4217 if recovery_event__.is_some() {
4218 return Err(serde::de::Error::duplicate_field("globalStart"));
4219 }
4220 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
4221;
4222 }
4223 GeneratedField::GlobalSuccess => {
4224 if recovery_event__.is_some() {
4225 return Err(serde::de::Error::duplicate_field("globalSuccess"));
4226 }
4227 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
4228;
4229 }
4230 GeneratedField::GlobalFailure => {
4231 if recovery_event__.is_some() {
4232 return Err(serde::de::Error::duplicate_field("globalFailure"));
4233 }
4234 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
4235;
4236 }
4237 GeneratedField::DatabaseStart => {
4238 if recovery_event__.is_some() {
4239 return Err(serde::de::Error::duplicate_field("databaseStart"));
4240 }
4241 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
4242;
4243 }
4244 GeneratedField::DatabaseFailure => {
4245 if recovery_event__.is_some() {
4246 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4247 }
4248 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4249;
4250 }
4251 GeneratedField::DatabaseSuccess => {
4252 if recovery_event__.is_some() {
4253 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4254 }
4255 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4256;
4257 }
4258 }
4259 }
4260 Ok(event_log::EventRecovery {
4261 recovery_event: recovery_event__,
4262 })
4263 }
4264 }
4265 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4266 }
4267}
4268impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4269 #[allow(deprecated)]
4270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4271 where
4272 S: serde::Serializer,
4273 {
4274 use serde::ser::SerializeStruct;
4275 let mut len = 0;
4276 if self.database_id != 0 {
4277 len += 1;
4278 }
4279 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4280 if self.database_id != 0 {
4281 struct_ser.serialize_field("databaseId", &self.database_id)?;
4282 }
4283 struct_ser.end()
4284 }
4285}
4286impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4287 #[allow(deprecated)]
4288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4289 where
4290 D: serde::Deserializer<'de>,
4291 {
4292 const FIELDS: &[&str] = &[
4293 "database_id",
4294 "databaseId",
4295 ];
4296
4297 #[allow(clippy::enum_variant_names)]
4298 enum GeneratedField {
4299 DatabaseId,
4300 }
4301 impl<'de> serde::Deserialize<'de> for GeneratedField {
4302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4303 where
4304 D: serde::Deserializer<'de>,
4305 {
4306 struct GeneratedVisitor;
4307
4308 impl serde::de::Visitor<'_> for GeneratedVisitor {
4309 type Value = GeneratedField;
4310
4311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4312 write!(formatter, "expected one of: {:?}", &FIELDS)
4313 }
4314
4315 #[allow(unused_variables)]
4316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4317 where
4318 E: serde::de::Error,
4319 {
4320 match value {
4321 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4323 }
4324 }
4325 }
4326 deserializer.deserialize_identifier(GeneratedVisitor)
4327 }
4328 }
4329 struct GeneratedVisitor;
4330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4331 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4332
4333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4334 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4335 }
4336
4337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4338 where
4339 V: serde::de::MapAccess<'de>,
4340 {
4341 let mut database_id__ = None;
4342 while let Some(k) = map_.next_key()? {
4343 match k {
4344 GeneratedField::DatabaseId => {
4345 if database_id__.is_some() {
4346 return Err(serde::de::Error::duplicate_field("databaseId"));
4347 }
4348 database_id__ =
4349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4350 ;
4351 }
4352 }
4353 }
4354 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4355 database_id: database_id__.unwrap_or_default(),
4356 })
4357 }
4358 }
4359 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4360 }
4361}
4362impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4363 #[allow(deprecated)]
4364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4365 where
4366 S: serde::Serializer,
4367 {
4368 use serde::ser::SerializeStruct;
4369 let mut len = 0;
4370 if self.database_id != 0 {
4371 len += 1;
4372 }
4373 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4374 if self.database_id != 0 {
4375 struct_ser.serialize_field("databaseId", &self.database_id)?;
4376 }
4377 struct_ser.end()
4378 }
4379}
4380impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4381 #[allow(deprecated)]
4382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4383 where
4384 D: serde::Deserializer<'de>,
4385 {
4386 const FIELDS: &[&str] = &[
4387 "database_id",
4388 "databaseId",
4389 ];
4390
4391 #[allow(clippy::enum_variant_names)]
4392 enum GeneratedField {
4393 DatabaseId,
4394 }
4395 impl<'de> serde::Deserialize<'de> for GeneratedField {
4396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4397 where
4398 D: serde::Deserializer<'de>,
4399 {
4400 struct GeneratedVisitor;
4401
4402 impl serde::de::Visitor<'_> for GeneratedVisitor {
4403 type Value = GeneratedField;
4404
4405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4406 write!(formatter, "expected one of: {:?}", &FIELDS)
4407 }
4408
4409 #[allow(unused_variables)]
4410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4411 where
4412 E: serde::de::Error,
4413 {
4414 match value {
4415 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4417 }
4418 }
4419 }
4420 deserializer.deserialize_identifier(GeneratedVisitor)
4421 }
4422 }
4423 struct GeneratedVisitor;
4424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4425 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4426
4427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4428 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4429 }
4430
4431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4432 where
4433 V: serde::de::MapAccess<'de>,
4434 {
4435 let mut database_id__ = None;
4436 while let Some(k) = map_.next_key()? {
4437 match k {
4438 GeneratedField::DatabaseId => {
4439 if database_id__.is_some() {
4440 return Err(serde::de::Error::duplicate_field("databaseId"));
4441 }
4442 database_id__ =
4443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4444 ;
4445 }
4446 }
4447 }
4448 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4449 database_id: database_id__.unwrap_or_default(),
4450 })
4451 }
4452 }
4453 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4454 }
4455}
4456impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4457 #[allow(deprecated)]
4458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4459 where
4460 S: serde::Serializer,
4461 {
4462 use serde::ser::SerializeStruct;
4463 let mut len = 0;
4464 if self.database_id != 0 {
4465 len += 1;
4466 }
4467 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4468 if self.database_id != 0 {
4469 struct_ser.serialize_field("databaseId", &self.database_id)?;
4470 }
4471 struct_ser.end()
4472 }
4473}
4474impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4475 #[allow(deprecated)]
4476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4477 where
4478 D: serde::Deserializer<'de>,
4479 {
4480 const FIELDS: &[&str] = &[
4481 "database_id",
4482 "databaseId",
4483 ];
4484
4485 #[allow(clippy::enum_variant_names)]
4486 enum GeneratedField {
4487 DatabaseId,
4488 }
4489 impl<'de> serde::Deserialize<'de> for GeneratedField {
4490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4491 where
4492 D: serde::Deserializer<'de>,
4493 {
4494 struct GeneratedVisitor;
4495
4496 impl serde::de::Visitor<'_> for GeneratedVisitor {
4497 type Value = GeneratedField;
4498
4499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4500 write!(formatter, "expected one of: {:?}", &FIELDS)
4501 }
4502
4503 #[allow(unused_variables)]
4504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4505 where
4506 E: serde::de::Error,
4507 {
4508 match value {
4509 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4511 }
4512 }
4513 }
4514 deserializer.deserialize_identifier(GeneratedVisitor)
4515 }
4516 }
4517 struct GeneratedVisitor;
4518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4519 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4520
4521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4522 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4523 }
4524
4525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4526 where
4527 V: serde::de::MapAccess<'de>,
4528 {
4529 let mut database_id__ = None;
4530 while let Some(k) = map_.next_key()? {
4531 match k {
4532 GeneratedField::DatabaseId => {
4533 if database_id__.is_some() {
4534 return Err(serde::de::Error::duplicate_field("databaseId"));
4535 }
4536 database_id__ =
4537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4538 ;
4539 }
4540 }
4541 }
4542 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4543 database_id: database_id__.unwrap_or_default(),
4544 })
4545 }
4546 }
4547 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4548 }
4549}
4550impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4551 #[allow(deprecated)]
4552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4553 where
4554 S: serde::Serializer,
4555 {
4556 use serde::ser::SerializeStruct;
4557 let mut len = 0;
4558 if !self.reason.is_empty() {
4559 len += 1;
4560 }
4561 if !self.error.is_empty() {
4562 len += 1;
4563 }
4564 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4565 if !self.reason.is_empty() {
4566 struct_ser.serialize_field("reason", &self.reason)?;
4567 }
4568 if !self.error.is_empty() {
4569 struct_ser.serialize_field("error", &self.error)?;
4570 }
4571 struct_ser.end()
4572 }
4573}
4574impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4575 #[allow(deprecated)]
4576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4577 where
4578 D: serde::Deserializer<'de>,
4579 {
4580 const FIELDS: &[&str] = &[
4581 "reason",
4582 "error",
4583 ];
4584
4585 #[allow(clippy::enum_variant_names)]
4586 enum GeneratedField {
4587 Reason,
4588 Error,
4589 }
4590 impl<'de> serde::Deserialize<'de> for GeneratedField {
4591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4592 where
4593 D: serde::Deserializer<'de>,
4594 {
4595 struct GeneratedVisitor;
4596
4597 impl serde::de::Visitor<'_> for GeneratedVisitor {
4598 type Value = GeneratedField;
4599
4600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4601 write!(formatter, "expected one of: {:?}", &FIELDS)
4602 }
4603
4604 #[allow(unused_variables)]
4605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4606 where
4607 E: serde::de::Error,
4608 {
4609 match value {
4610 "reason" => Ok(GeneratedField::Reason),
4611 "error" => Ok(GeneratedField::Error),
4612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4613 }
4614 }
4615 }
4616 deserializer.deserialize_identifier(GeneratedVisitor)
4617 }
4618 }
4619 struct GeneratedVisitor;
4620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4621 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4622
4623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4624 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4625 }
4626
4627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4628 where
4629 V: serde::de::MapAccess<'de>,
4630 {
4631 let mut reason__ = None;
4632 let mut error__ = 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::Error => {
4642 if error__.is_some() {
4643 return Err(serde::de::Error::duplicate_field("error"));
4644 }
4645 error__ = Some(map_.next_value()?);
4646 }
4647 }
4648 }
4649 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4650 reason: reason__.unwrap_or_default(),
4651 error: error__.unwrap_or_default(),
4652 })
4653 }
4654 }
4655 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4656 }
4657}
4658impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4659 #[allow(deprecated)]
4660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4661 where
4662 S: serde::Serializer,
4663 {
4664 use serde::ser::SerializeStruct;
4665 let mut len = 0;
4666 if !self.reason.is_empty() {
4667 len += 1;
4668 }
4669 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4670 if !self.reason.is_empty() {
4671 struct_ser.serialize_field("reason", &self.reason)?;
4672 }
4673 struct_ser.end()
4674 }
4675}
4676impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4677 #[allow(deprecated)]
4678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4679 where
4680 D: serde::Deserializer<'de>,
4681 {
4682 const FIELDS: &[&str] = &[
4683 "reason",
4684 ];
4685
4686 #[allow(clippy::enum_variant_names)]
4687 enum GeneratedField {
4688 Reason,
4689 }
4690 impl<'de> serde::Deserialize<'de> for GeneratedField {
4691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4692 where
4693 D: serde::Deserializer<'de>,
4694 {
4695 struct GeneratedVisitor;
4696
4697 impl serde::de::Visitor<'_> for GeneratedVisitor {
4698 type Value = GeneratedField;
4699
4700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4701 write!(formatter, "expected one of: {:?}", &FIELDS)
4702 }
4703
4704 #[allow(unused_variables)]
4705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4706 where
4707 E: serde::de::Error,
4708 {
4709 match value {
4710 "reason" => Ok(GeneratedField::Reason),
4711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4712 }
4713 }
4714 }
4715 deserializer.deserialize_identifier(GeneratedVisitor)
4716 }
4717 }
4718 struct GeneratedVisitor;
4719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4720 type Value = event_log::event_recovery::GlobalRecoveryStart;
4721
4722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4723 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4724 }
4725
4726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4727 where
4728 V: serde::de::MapAccess<'de>,
4729 {
4730 let mut reason__ = None;
4731 while let Some(k) = map_.next_key()? {
4732 match k {
4733 GeneratedField::Reason => {
4734 if reason__.is_some() {
4735 return Err(serde::de::Error::duplicate_field("reason"));
4736 }
4737 reason__ = Some(map_.next_value()?);
4738 }
4739 }
4740 }
4741 Ok(event_log::event_recovery::GlobalRecoveryStart {
4742 reason: reason__.unwrap_or_default(),
4743 })
4744 }
4745 }
4746 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4747 }
4748}
4749impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4750 #[allow(deprecated)]
4751 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4752 where
4753 S: serde::Serializer,
4754 {
4755 use serde::ser::SerializeStruct;
4756 let mut len = 0;
4757 if !self.reason.is_empty() {
4758 len += 1;
4759 }
4760 if self.duration_secs != 0. {
4761 len += 1;
4762 }
4763 if !self.running_database_ids.is_empty() {
4764 len += 1;
4765 }
4766 if !self.recovering_database_ids.is_empty() {
4767 len += 1;
4768 }
4769 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4770 if !self.reason.is_empty() {
4771 struct_ser.serialize_field("reason", &self.reason)?;
4772 }
4773 if self.duration_secs != 0. {
4774 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4775 }
4776 if !self.running_database_ids.is_empty() {
4777 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4778 }
4779 if !self.recovering_database_ids.is_empty() {
4780 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4781 }
4782 struct_ser.end()
4783 }
4784}
4785impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4786 #[allow(deprecated)]
4787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4788 where
4789 D: serde::Deserializer<'de>,
4790 {
4791 const FIELDS: &[&str] = &[
4792 "reason",
4793 "duration_secs",
4794 "durationSecs",
4795 "running_database_ids",
4796 "runningDatabaseIds",
4797 "recovering_database_ids",
4798 "recoveringDatabaseIds",
4799 ];
4800
4801 #[allow(clippy::enum_variant_names)]
4802 enum GeneratedField {
4803 Reason,
4804 DurationSecs,
4805 RunningDatabaseIds,
4806 RecoveringDatabaseIds,
4807 }
4808 impl<'de> serde::Deserialize<'de> for GeneratedField {
4809 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4810 where
4811 D: serde::Deserializer<'de>,
4812 {
4813 struct GeneratedVisitor;
4814
4815 impl serde::de::Visitor<'_> for GeneratedVisitor {
4816 type Value = GeneratedField;
4817
4818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4819 write!(formatter, "expected one of: {:?}", &FIELDS)
4820 }
4821
4822 #[allow(unused_variables)]
4823 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4824 where
4825 E: serde::de::Error,
4826 {
4827 match value {
4828 "reason" => Ok(GeneratedField::Reason),
4829 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4830 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4831 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4832 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4833 }
4834 }
4835 }
4836 deserializer.deserialize_identifier(GeneratedVisitor)
4837 }
4838 }
4839 struct GeneratedVisitor;
4840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4841 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4842
4843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4844 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4845 }
4846
4847 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4848 where
4849 V: serde::de::MapAccess<'de>,
4850 {
4851 let mut reason__ = None;
4852 let mut duration_secs__ = None;
4853 let mut running_database_ids__ = None;
4854 let mut recovering_database_ids__ = None;
4855 while let Some(k) = map_.next_key()? {
4856 match k {
4857 GeneratedField::Reason => {
4858 if reason__.is_some() {
4859 return Err(serde::de::Error::duplicate_field("reason"));
4860 }
4861 reason__ = Some(map_.next_value()?);
4862 }
4863 GeneratedField::DurationSecs => {
4864 if duration_secs__.is_some() {
4865 return Err(serde::de::Error::duplicate_field("durationSecs"));
4866 }
4867 duration_secs__ =
4868 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4869 ;
4870 }
4871 GeneratedField::RunningDatabaseIds => {
4872 if running_database_ids__.is_some() {
4873 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4874 }
4875 running_database_ids__ =
4876 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4877 .into_iter().map(|x| x.0).collect())
4878 ;
4879 }
4880 GeneratedField::RecoveringDatabaseIds => {
4881 if recovering_database_ids__.is_some() {
4882 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4883 }
4884 recovering_database_ids__ =
4885 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4886 .into_iter().map(|x| x.0).collect())
4887 ;
4888 }
4889 }
4890 }
4891 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4892 reason: reason__.unwrap_or_default(),
4893 duration_secs: duration_secs__.unwrap_or_default(),
4894 running_database_ids: running_database_ids__.unwrap_or_default(),
4895 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4896 })
4897 }
4898 }
4899 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4900 }
4901}
4902impl serde::Serialize for event_log::EventSinkFail {
4903 #[allow(deprecated)]
4904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4905 where
4906 S: serde::Serializer,
4907 {
4908 use serde::ser::SerializeStruct;
4909 let mut len = 0;
4910 if self.sink_id != 0 {
4911 len += 1;
4912 }
4913 if !self.sink_name.is_empty() {
4914 len += 1;
4915 }
4916 if !self.connector.is_empty() {
4917 len += 1;
4918 }
4919 if !self.error.is_empty() {
4920 len += 1;
4921 }
4922 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4923 if self.sink_id != 0 {
4924 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4925 }
4926 if !self.sink_name.is_empty() {
4927 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4928 }
4929 if !self.connector.is_empty() {
4930 struct_ser.serialize_field("connector", &self.connector)?;
4931 }
4932 if !self.error.is_empty() {
4933 struct_ser.serialize_field("error", &self.error)?;
4934 }
4935 struct_ser.end()
4936 }
4937}
4938impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4939 #[allow(deprecated)]
4940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4941 where
4942 D: serde::Deserializer<'de>,
4943 {
4944 const FIELDS: &[&str] = &[
4945 "sink_id",
4946 "sinkId",
4947 "sink_name",
4948 "sinkName",
4949 "connector",
4950 "error",
4951 ];
4952
4953 #[allow(clippy::enum_variant_names)]
4954 enum GeneratedField {
4955 SinkId,
4956 SinkName,
4957 Connector,
4958 Error,
4959 }
4960 impl<'de> serde::Deserialize<'de> for GeneratedField {
4961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4962 where
4963 D: serde::Deserializer<'de>,
4964 {
4965 struct GeneratedVisitor;
4966
4967 impl serde::de::Visitor<'_> for GeneratedVisitor {
4968 type Value = GeneratedField;
4969
4970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4971 write!(formatter, "expected one of: {:?}", &FIELDS)
4972 }
4973
4974 #[allow(unused_variables)]
4975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4976 where
4977 E: serde::de::Error,
4978 {
4979 match value {
4980 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4981 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4982 "connector" => Ok(GeneratedField::Connector),
4983 "error" => Ok(GeneratedField::Error),
4984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4985 }
4986 }
4987 }
4988 deserializer.deserialize_identifier(GeneratedVisitor)
4989 }
4990 }
4991 struct GeneratedVisitor;
4992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4993 type Value = event_log::EventSinkFail;
4994
4995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4996 formatter.write_str("struct meta.EventLog.EventSinkFail")
4997 }
4998
4999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
5000 where
5001 V: serde::de::MapAccess<'de>,
5002 {
5003 let mut sink_id__ = None;
5004 let mut sink_name__ = None;
5005 let mut connector__ = None;
5006 let mut error__ = None;
5007 while let Some(k) = map_.next_key()? {
5008 match k {
5009 GeneratedField::SinkId => {
5010 if sink_id__.is_some() {
5011 return Err(serde::de::Error::duplicate_field("sinkId"));
5012 }
5013 sink_id__ =
5014 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5015 ;
5016 }
5017 GeneratedField::SinkName => {
5018 if sink_name__.is_some() {
5019 return Err(serde::de::Error::duplicate_field("sinkName"));
5020 }
5021 sink_name__ = Some(map_.next_value()?);
5022 }
5023 GeneratedField::Connector => {
5024 if connector__.is_some() {
5025 return Err(serde::de::Error::duplicate_field("connector"));
5026 }
5027 connector__ = Some(map_.next_value()?);
5028 }
5029 GeneratedField::Error => {
5030 if error__.is_some() {
5031 return Err(serde::de::Error::duplicate_field("error"));
5032 }
5033 error__ = Some(map_.next_value()?);
5034 }
5035 }
5036 }
5037 Ok(event_log::EventSinkFail {
5038 sink_id: sink_id__.unwrap_or_default(),
5039 sink_name: sink_name__.unwrap_or_default(),
5040 connector: connector__.unwrap_or_default(),
5041 error: error__.unwrap_or_default(),
5042 })
5043 }
5044 }
5045 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
5046 }
5047}
5048impl serde::Serialize for event_log::EventWorkerNodePanic {
5049 #[allow(deprecated)]
5050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5051 where
5052 S: serde::Serializer,
5053 {
5054 use serde::ser::SerializeStruct;
5055 let mut len = 0;
5056 if self.worker_id != 0 {
5057 len += 1;
5058 }
5059 if self.worker_type != 0 {
5060 len += 1;
5061 }
5062 if self.host_addr.is_some() {
5063 len += 1;
5064 }
5065 if !self.panic_info.is_empty() {
5066 len += 1;
5067 }
5068 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
5069 if self.worker_id != 0 {
5070 struct_ser.serialize_field("workerId", &self.worker_id)?;
5071 }
5072 if self.worker_type != 0 {
5073 let v = super::common::WorkerType::try_from(self.worker_type)
5074 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
5075 struct_ser.serialize_field("workerType", &v)?;
5076 }
5077 if let Some(v) = self.host_addr.as_ref() {
5078 struct_ser.serialize_field("hostAddr", v)?;
5079 }
5080 if !self.panic_info.is_empty() {
5081 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
5082 }
5083 struct_ser.end()
5084 }
5085}
5086impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
5087 #[allow(deprecated)]
5088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5089 where
5090 D: serde::Deserializer<'de>,
5091 {
5092 const FIELDS: &[&str] = &[
5093 "worker_id",
5094 "workerId",
5095 "worker_type",
5096 "workerType",
5097 "host_addr",
5098 "hostAddr",
5099 "panic_info",
5100 "panicInfo",
5101 ];
5102
5103 #[allow(clippy::enum_variant_names)]
5104 enum GeneratedField {
5105 WorkerId,
5106 WorkerType,
5107 HostAddr,
5108 PanicInfo,
5109 }
5110 impl<'de> serde::Deserialize<'de> for GeneratedField {
5111 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5112 where
5113 D: serde::Deserializer<'de>,
5114 {
5115 struct GeneratedVisitor;
5116
5117 impl serde::de::Visitor<'_> for GeneratedVisitor {
5118 type Value = GeneratedField;
5119
5120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5121 write!(formatter, "expected one of: {:?}", &FIELDS)
5122 }
5123
5124 #[allow(unused_variables)]
5125 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5126 where
5127 E: serde::de::Error,
5128 {
5129 match value {
5130 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
5131 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
5132 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
5133 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
5134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5135 }
5136 }
5137 }
5138 deserializer.deserialize_identifier(GeneratedVisitor)
5139 }
5140 }
5141 struct GeneratedVisitor;
5142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5143 type Value = event_log::EventWorkerNodePanic;
5144
5145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5146 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
5147 }
5148
5149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
5150 where
5151 V: serde::de::MapAccess<'de>,
5152 {
5153 let mut worker_id__ = None;
5154 let mut worker_type__ = None;
5155 let mut host_addr__ = None;
5156 let mut panic_info__ = None;
5157 while let Some(k) = map_.next_key()? {
5158 match k {
5159 GeneratedField::WorkerId => {
5160 if worker_id__.is_some() {
5161 return Err(serde::de::Error::duplicate_field("workerId"));
5162 }
5163 worker_id__ =
5164 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5165 ;
5166 }
5167 GeneratedField::WorkerType => {
5168 if worker_type__.is_some() {
5169 return Err(serde::de::Error::duplicate_field("workerType"));
5170 }
5171 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
5172 }
5173 GeneratedField::HostAddr => {
5174 if host_addr__.is_some() {
5175 return Err(serde::de::Error::duplicate_field("hostAddr"));
5176 }
5177 host_addr__ = map_.next_value()?;
5178 }
5179 GeneratedField::PanicInfo => {
5180 if panic_info__.is_some() {
5181 return Err(serde::de::Error::duplicate_field("panicInfo"));
5182 }
5183 panic_info__ = Some(map_.next_value()?);
5184 }
5185 }
5186 }
5187 Ok(event_log::EventWorkerNodePanic {
5188 worker_id: worker_id__.unwrap_or_default(),
5189 worker_type: worker_type__.unwrap_or_default(),
5190 host_addr: host_addr__,
5191 panic_info: panic_info__.unwrap_or_default(),
5192 })
5193 }
5194 }
5195 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
5196 }
5197}
5198impl serde::Serialize for FlushRequest {
5199 #[allow(deprecated)]
5200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5201 where
5202 S: serde::Serializer,
5203 {
5204 use serde::ser::SerializeStruct;
5205 let mut len = 0;
5206 if self.database_id != 0 {
5207 len += 1;
5208 }
5209 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
5210 if self.database_id != 0 {
5211 struct_ser.serialize_field("databaseId", &self.database_id)?;
5212 }
5213 struct_ser.end()
5214 }
5215}
5216impl<'de> serde::Deserialize<'de> for FlushRequest {
5217 #[allow(deprecated)]
5218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5219 where
5220 D: serde::Deserializer<'de>,
5221 {
5222 const FIELDS: &[&str] = &[
5223 "database_id",
5224 "databaseId",
5225 ];
5226
5227 #[allow(clippy::enum_variant_names)]
5228 enum GeneratedField {
5229 DatabaseId,
5230 }
5231 impl<'de> serde::Deserialize<'de> for GeneratedField {
5232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5233 where
5234 D: serde::Deserializer<'de>,
5235 {
5236 struct GeneratedVisitor;
5237
5238 impl serde::de::Visitor<'_> for GeneratedVisitor {
5239 type Value = GeneratedField;
5240
5241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5242 write!(formatter, "expected one of: {:?}", &FIELDS)
5243 }
5244
5245 #[allow(unused_variables)]
5246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5247 where
5248 E: serde::de::Error,
5249 {
5250 match value {
5251 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5253 }
5254 }
5255 }
5256 deserializer.deserialize_identifier(GeneratedVisitor)
5257 }
5258 }
5259 struct GeneratedVisitor;
5260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5261 type Value = FlushRequest;
5262
5263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5264 formatter.write_str("struct meta.FlushRequest")
5265 }
5266
5267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5268 where
5269 V: serde::de::MapAccess<'de>,
5270 {
5271 let mut database_id__ = None;
5272 while let Some(k) = map_.next_key()? {
5273 match k {
5274 GeneratedField::DatabaseId => {
5275 if database_id__.is_some() {
5276 return Err(serde::de::Error::duplicate_field("databaseId"));
5277 }
5278 database_id__ =
5279 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5280 ;
5281 }
5282 }
5283 }
5284 Ok(FlushRequest {
5285 database_id: database_id__.unwrap_or_default(),
5286 })
5287 }
5288 }
5289 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5290 }
5291}
5292impl serde::Serialize for FlushResponse {
5293 #[allow(deprecated)]
5294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5295 where
5296 S: serde::Serializer,
5297 {
5298 use serde::ser::SerializeStruct;
5299 let mut len = 0;
5300 if self.status.is_some() {
5301 len += 1;
5302 }
5303 if self.hummock_version_id != 0 {
5304 len += 1;
5305 }
5306 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5307 if let Some(v) = self.status.as_ref() {
5308 struct_ser.serialize_field("status", v)?;
5309 }
5310 if self.hummock_version_id != 0 {
5311 #[allow(clippy::needless_borrow)]
5312 #[allow(clippy::needless_borrows_for_generic_args)]
5313 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5314 }
5315 struct_ser.end()
5316 }
5317}
5318impl<'de> serde::Deserialize<'de> for FlushResponse {
5319 #[allow(deprecated)]
5320 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5321 where
5322 D: serde::Deserializer<'de>,
5323 {
5324 const FIELDS: &[&str] = &[
5325 "status",
5326 "hummock_version_id",
5327 "hummockVersionId",
5328 ];
5329
5330 #[allow(clippy::enum_variant_names)]
5331 enum GeneratedField {
5332 Status,
5333 HummockVersionId,
5334 }
5335 impl<'de> serde::Deserialize<'de> for GeneratedField {
5336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5337 where
5338 D: serde::Deserializer<'de>,
5339 {
5340 struct GeneratedVisitor;
5341
5342 impl serde::de::Visitor<'_> for GeneratedVisitor {
5343 type Value = GeneratedField;
5344
5345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5346 write!(formatter, "expected one of: {:?}", &FIELDS)
5347 }
5348
5349 #[allow(unused_variables)]
5350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5351 where
5352 E: serde::de::Error,
5353 {
5354 match value {
5355 "status" => Ok(GeneratedField::Status),
5356 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5357 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5358 }
5359 }
5360 }
5361 deserializer.deserialize_identifier(GeneratedVisitor)
5362 }
5363 }
5364 struct GeneratedVisitor;
5365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5366 type Value = FlushResponse;
5367
5368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5369 formatter.write_str("struct meta.FlushResponse")
5370 }
5371
5372 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5373 where
5374 V: serde::de::MapAccess<'de>,
5375 {
5376 let mut status__ = None;
5377 let mut hummock_version_id__ = None;
5378 while let Some(k) = map_.next_key()? {
5379 match k {
5380 GeneratedField::Status => {
5381 if status__.is_some() {
5382 return Err(serde::de::Error::duplicate_field("status"));
5383 }
5384 status__ = map_.next_value()?;
5385 }
5386 GeneratedField::HummockVersionId => {
5387 if hummock_version_id__.is_some() {
5388 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5389 }
5390 hummock_version_id__ =
5391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5392 ;
5393 }
5394 }
5395 }
5396 Ok(FlushResponse {
5397 status: status__,
5398 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5399 })
5400 }
5401 }
5402 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5403 }
5404}
5405impl serde::Serialize for FragmentDistribution {
5406 #[allow(deprecated)]
5407 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5408 where
5409 S: serde::Serializer,
5410 {
5411 use serde::ser::SerializeStruct;
5412 let mut len = 0;
5413 if self.fragment_id != 0 {
5414 len += 1;
5415 }
5416 if self.table_id != 0 {
5417 len += 1;
5418 }
5419 if self.distribution_type != 0 {
5420 len += 1;
5421 }
5422 if !self.state_table_ids.is_empty() {
5423 len += 1;
5424 }
5425 if !self.upstream_fragment_ids.is_empty() {
5426 len += 1;
5427 }
5428 if self.fragment_type_mask != 0 {
5429 len += 1;
5430 }
5431 if self.parallelism != 0 {
5432 len += 1;
5433 }
5434 if self.vnode_count != 0 {
5435 len += 1;
5436 }
5437 if self.node.is_some() {
5438 len += 1;
5439 }
5440 if !self.parallelism_policy.is_empty() {
5441 len += 1;
5442 }
5443 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5444 if self.fragment_id != 0 {
5445 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5446 }
5447 if self.table_id != 0 {
5448 struct_ser.serialize_field("tableId", &self.table_id)?;
5449 }
5450 if self.distribution_type != 0 {
5451 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5452 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5453 struct_ser.serialize_field("distributionType", &v)?;
5454 }
5455 if !self.state_table_ids.is_empty() {
5456 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5457 }
5458 if !self.upstream_fragment_ids.is_empty() {
5459 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5460 }
5461 if self.fragment_type_mask != 0 {
5462 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5463 }
5464 if self.parallelism != 0 {
5465 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5466 }
5467 if self.vnode_count != 0 {
5468 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5469 }
5470 if let Some(v) = self.node.as_ref() {
5471 struct_ser.serialize_field("node", v)?;
5472 }
5473 if !self.parallelism_policy.is_empty() {
5474 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5475 }
5476 struct_ser.end()
5477 }
5478}
5479impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5480 #[allow(deprecated)]
5481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5482 where
5483 D: serde::Deserializer<'de>,
5484 {
5485 const FIELDS: &[&str] = &[
5486 "fragment_id",
5487 "fragmentId",
5488 "table_id",
5489 "tableId",
5490 "distribution_type",
5491 "distributionType",
5492 "state_table_ids",
5493 "stateTableIds",
5494 "upstream_fragment_ids",
5495 "upstreamFragmentIds",
5496 "fragment_type_mask",
5497 "fragmentTypeMask",
5498 "parallelism",
5499 "vnode_count",
5500 "vnodeCount",
5501 "node",
5502 "parallelism_policy",
5503 "parallelismPolicy",
5504 ];
5505
5506 #[allow(clippy::enum_variant_names)]
5507 enum GeneratedField {
5508 FragmentId,
5509 TableId,
5510 DistributionType,
5511 StateTableIds,
5512 UpstreamFragmentIds,
5513 FragmentTypeMask,
5514 Parallelism,
5515 VnodeCount,
5516 Node,
5517 ParallelismPolicy,
5518 }
5519 impl<'de> serde::Deserialize<'de> for GeneratedField {
5520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5521 where
5522 D: serde::Deserializer<'de>,
5523 {
5524 struct GeneratedVisitor;
5525
5526 impl serde::de::Visitor<'_> for GeneratedVisitor {
5527 type Value = GeneratedField;
5528
5529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5530 write!(formatter, "expected one of: {:?}", &FIELDS)
5531 }
5532
5533 #[allow(unused_variables)]
5534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5535 where
5536 E: serde::de::Error,
5537 {
5538 match value {
5539 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5540 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5541 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5542 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5543 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5544 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5545 "parallelism" => Ok(GeneratedField::Parallelism),
5546 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5547 "node" => Ok(GeneratedField::Node),
5548 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5550 }
5551 }
5552 }
5553 deserializer.deserialize_identifier(GeneratedVisitor)
5554 }
5555 }
5556 struct GeneratedVisitor;
5557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5558 type Value = FragmentDistribution;
5559
5560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5561 formatter.write_str("struct meta.FragmentDistribution")
5562 }
5563
5564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5565 where
5566 V: serde::de::MapAccess<'de>,
5567 {
5568 let mut fragment_id__ = None;
5569 let mut table_id__ = None;
5570 let mut distribution_type__ = None;
5571 let mut state_table_ids__ = None;
5572 let mut upstream_fragment_ids__ = None;
5573 let mut fragment_type_mask__ = None;
5574 let mut parallelism__ = None;
5575 let mut vnode_count__ = None;
5576 let mut node__ = None;
5577 let mut parallelism_policy__ = None;
5578 while let Some(k) = map_.next_key()? {
5579 match k {
5580 GeneratedField::FragmentId => {
5581 if fragment_id__.is_some() {
5582 return Err(serde::de::Error::duplicate_field("fragmentId"));
5583 }
5584 fragment_id__ =
5585 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5586 ;
5587 }
5588 GeneratedField::TableId => {
5589 if table_id__.is_some() {
5590 return Err(serde::de::Error::duplicate_field("tableId"));
5591 }
5592 table_id__ =
5593 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5594 ;
5595 }
5596 GeneratedField::DistributionType => {
5597 if distribution_type__.is_some() {
5598 return Err(serde::de::Error::duplicate_field("distributionType"));
5599 }
5600 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5601 }
5602 GeneratedField::StateTableIds => {
5603 if state_table_ids__.is_some() {
5604 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5605 }
5606 state_table_ids__ =
5607 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5608 .into_iter().map(|x| x.0).collect())
5609 ;
5610 }
5611 GeneratedField::UpstreamFragmentIds => {
5612 if upstream_fragment_ids__.is_some() {
5613 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5614 }
5615 upstream_fragment_ids__ =
5616 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5617 .into_iter().map(|x| x.0).collect())
5618 ;
5619 }
5620 GeneratedField::FragmentTypeMask => {
5621 if fragment_type_mask__.is_some() {
5622 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5623 }
5624 fragment_type_mask__ =
5625 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5626 ;
5627 }
5628 GeneratedField::Parallelism => {
5629 if parallelism__.is_some() {
5630 return Err(serde::de::Error::duplicate_field("parallelism"));
5631 }
5632 parallelism__ =
5633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5634 ;
5635 }
5636 GeneratedField::VnodeCount => {
5637 if vnode_count__.is_some() {
5638 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5639 }
5640 vnode_count__ =
5641 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5642 ;
5643 }
5644 GeneratedField::Node => {
5645 if node__.is_some() {
5646 return Err(serde::de::Error::duplicate_field("node"));
5647 }
5648 node__ = map_.next_value()?;
5649 }
5650 GeneratedField::ParallelismPolicy => {
5651 if parallelism_policy__.is_some() {
5652 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5653 }
5654 parallelism_policy__ = Some(map_.next_value()?);
5655 }
5656 }
5657 }
5658 Ok(FragmentDistribution {
5659 fragment_id: fragment_id__.unwrap_or_default(),
5660 table_id: table_id__.unwrap_or_default(),
5661 distribution_type: distribution_type__.unwrap_or_default(),
5662 state_table_ids: state_table_ids__.unwrap_or_default(),
5663 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5664 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5665 parallelism: parallelism__.unwrap_or_default(),
5666 vnode_count: vnode_count__.unwrap_or_default(),
5667 node: node__,
5668 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5669 })
5670 }
5671 }
5672 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5673 }
5674}
5675impl serde::Serialize for FragmentIdToActorIdMap {
5676 #[allow(deprecated)]
5677 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5678 where
5679 S: serde::Serializer,
5680 {
5681 use serde::ser::SerializeStruct;
5682 let mut len = 0;
5683 if !self.map.is_empty() {
5684 len += 1;
5685 }
5686 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5687 if !self.map.is_empty() {
5688 struct_ser.serialize_field("map", &self.map)?;
5689 }
5690 struct_ser.end()
5691 }
5692}
5693impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5694 #[allow(deprecated)]
5695 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5696 where
5697 D: serde::Deserializer<'de>,
5698 {
5699 const FIELDS: &[&str] = &[
5700 "map",
5701 ];
5702
5703 #[allow(clippy::enum_variant_names)]
5704 enum GeneratedField {
5705 Map,
5706 }
5707 impl<'de> serde::Deserialize<'de> for GeneratedField {
5708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5709 where
5710 D: serde::Deserializer<'de>,
5711 {
5712 struct GeneratedVisitor;
5713
5714 impl serde::de::Visitor<'_> for GeneratedVisitor {
5715 type Value = GeneratedField;
5716
5717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5718 write!(formatter, "expected one of: {:?}", &FIELDS)
5719 }
5720
5721 #[allow(unused_variables)]
5722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5723 where
5724 E: serde::de::Error,
5725 {
5726 match value {
5727 "map" => Ok(GeneratedField::Map),
5728 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5729 }
5730 }
5731 }
5732 deserializer.deserialize_identifier(GeneratedVisitor)
5733 }
5734 }
5735 struct GeneratedVisitor;
5736 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5737 type Value = FragmentIdToActorIdMap;
5738
5739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5740 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5741 }
5742
5743 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5744 where
5745 V: serde::de::MapAccess<'de>,
5746 {
5747 let mut map__ = None;
5748 while let Some(k) = map_.next_key()? {
5749 match k {
5750 GeneratedField::Map => {
5751 if map__.is_some() {
5752 return Err(serde::de::Error::duplicate_field("map"));
5753 }
5754 map__ = Some(
5755 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5756 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5757 );
5758 }
5759 }
5760 }
5761 Ok(FragmentIdToActorIdMap {
5762 map: map__.unwrap_or_default(),
5763 })
5764 }
5765 }
5766 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5767 }
5768}
5769impl serde::Serialize for FragmentToRelationMap {
5770 #[allow(deprecated)]
5771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5772 where
5773 S: serde::Serializer,
5774 {
5775 use serde::ser::SerializeStruct;
5776 let mut len = 0;
5777 if !self.fragment_to_relation_map.is_empty() {
5778 len += 1;
5779 }
5780 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5781 if !self.fragment_to_relation_map.is_empty() {
5782 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5783 }
5784 struct_ser.end()
5785 }
5786}
5787impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5788 #[allow(deprecated)]
5789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5790 where
5791 D: serde::Deserializer<'de>,
5792 {
5793 const FIELDS: &[&str] = &[
5794 "fragment_to_relation_map",
5795 "fragmentToRelationMap",
5796 ];
5797
5798 #[allow(clippy::enum_variant_names)]
5799 enum GeneratedField {
5800 FragmentToRelationMap,
5801 }
5802 impl<'de> serde::Deserialize<'de> for GeneratedField {
5803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5804 where
5805 D: serde::Deserializer<'de>,
5806 {
5807 struct GeneratedVisitor;
5808
5809 impl serde::de::Visitor<'_> for GeneratedVisitor {
5810 type Value = GeneratedField;
5811
5812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5813 write!(formatter, "expected one of: {:?}", &FIELDS)
5814 }
5815
5816 #[allow(unused_variables)]
5817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5818 where
5819 E: serde::de::Error,
5820 {
5821 match value {
5822 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5823 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5824 }
5825 }
5826 }
5827 deserializer.deserialize_identifier(GeneratedVisitor)
5828 }
5829 }
5830 struct GeneratedVisitor;
5831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5832 type Value = FragmentToRelationMap;
5833
5834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5835 formatter.write_str("struct meta.FragmentToRelationMap")
5836 }
5837
5838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5839 where
5840 V: serde::de::MapAccess<'de>,
5841 {
5842 let mut fragment_to_relation_map__ = None;
5843 while let Some(k) = map_.next_key()? {
5844 match k {
5845 GeneratedField::FragmentToRelationMap => {
5846 if fragment_to_relation_map__.is_some() {
5847 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5848 }
5849 fragment_to_relation_map__ = Some(
5850 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5851 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
5852 );
5853 }
5854 }
5855 }
5856 Ok(FragmentToRelationMap {
5857 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5858 })
5859 }
5860 }
5861 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5862 }
5863}
5864impl serde::Serialize for FragmentWorkerSlotMapping {
5865 #[allow(deprecated)]
5866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5867 where
5868 S: serde::Serializer,
5869 {
5870 use serde::ser::SerializeStruct;
5871 let mut len = 0;
5872 if self.fragment_id != 0 {
5873 len += 1;
5874 }
5875 if self.mapping.is_some() {
5876 len += 1;
5877 }
5878 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5879 if self.fragment_id != 0 {
5880 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5881 }
5882 if let Some(v) = self.mapping.as_ref() {
5883 struct_ser.serialize_field("mapping", v)?;
5884 }
5885 struct_ser.end()
5886 }
5887}
5888impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5889 #[allow(deprecated)]
5890 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5891 where
5892 D: serde::Deserializer<'de>,
5893 {
5894 const FIELDS: &[&str] = &[
5895 "fragment_id",
5896 "fragmentId",
5897 "mapping",
5898 ];
5899
5900 #[allow(clippy::enum_variant_names)]
5901 enum GeneratedField {
5902 FragmentId,
5903 Mapping,
5904 }
5905 impl<'de> serde::Deserialize<'de> for GeneratedField {
5906 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5907 where
5908 D: serde::Deserializer<'de>,
5909 {
5910 struct GeneratedVisitor;
5911
5912 impl serde::de::Visitor<'_> for GeneratedVisitor {
5913 type Value = GeneratedField;
5914
5915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5916 write!(formatter, "expected one of: {:?}", &FIELDS)
5917 }
5918
5919 #[allow(unused_variables)]
5920 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5921 where
5922 E: serde::de::Error,
5923 {
5924 match value {
5925 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5926 "mapping" => Ok(GeneratedField::Mapping),
5927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5928 }
5929 }
5930 }
5931 deserializer.deserialize_identifier(GeneratedVisitor)
5932 }
5933 }
5934 struct GeneratedVisitor;
5935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5936 type Value = FragmentWorkerSlotMapping;
5937
5938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5939 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5940 }
5941
5942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5943 where
5944 V: serde::de::MapAccess<'de>,
5945 {
5946 let mut fragment_id__ = None;
5947 let mut mapping__ = None;
5948 while let Some(k) = map_.next_key()? {
5949 match k {
5950 GeneratedField::FragmentId => {
5951 if fragment_id__.is_some() {
5952 return Err(serde::de::Error::duplicate_field("fragmentId"));
5953 }
5954 fragment_id__ =
5955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5956 ;
5957 }
5958 GeneratedField::Mapping => {
5959 if mapping__.is_some() {
5960 return Err(serde::de::Error::duplicate_field("mapping"));
5961 }
5962 mapping__ = map_.next_value()?;
5963 }
5964 }
5965 }
5966 Ok(FragmentWorkerSlotMapping {
5967 fragment_id: fragment_id__.unwrap_or_default(),
5968 mapping: mapping__,
5969 })
5970 }
5971 }
5972 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5973 }
5974}
5975impl serde::Serialize for FragmentWorkerSlotMappings {
5976 #[allow(deprecated)]
5977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5978 where
5979 S: serde::Serializer,
5980 {
5981 use serde::ser::SerializeStruct;
5982 let mut len = 0;
5983 if !self.mappings.is_empty() {
5984 len += 1;
5985 }
5986 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5987 if !self.mappings.is_empty() {
5988 struct_ser.serialize_field("mappings", &self.mappings)?;
5989 }
5990 struct_ser.end()
5991 }
5992}
5993impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5994 #[allow(deprecated)]
5995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5996 where
5997 D: serde::Deserializer<'de>,
5998 {
5999 const FIELDS: &[&str] = &[
6000 "mappings",
6001 ];
6002
6003 #[allow(clippy::enum_variant_names)]
6004 enum GeneratedField {
6005 Mappings,
6006 }
6007 impl<'de> serde::Deserialize<'de> for GeneratedField {
6008 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6009 where
6010 D: serde::Deserializer<'de>,
6011 {
6012 struct GeneratedVisitor;
6013
6014 impl serde::de::Visitor<'_> for GeneratedVisitor {
6015 type Value = GeneratedField;
6016
6017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6018 write!(formatter, "expected one of: {:?}", &FIELDS)
6019 }
6020
6021 #[allow(unused_variables)]
6022 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6023 where
6024 E: serde::de::Error,
6025 {
6026 match value {
6027 "mappings" => Ok(GeneratedField::Mappings),
6028 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6029 }
6030 }
6031 }
6032 deserializer.deserialize_identifier(GeneratedVisitor)
6033 }
6034 }
6035 struct GeneratedVisitor;
6036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6037 type Value = FragmentWorkerSlotMappings;
6038
6039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6040 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
6041 }
6042
6043 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
6044 where
6045 V: serde::de::MapAccess<'de>,
6046 {
6047 let mut mappings__ = None;
6048 while let Some(k) = map_.next_key()? {
6049 match k {
6050 GeneratedField::Mappings => {
6051 if mappings__.is_some() {
6052 return Err(serde::de::Error::duplicate_field("mappings"));
6053 }
6054 mappings__ = Some(map_.next_value()?);
6055 }
6056 }
6057 }
6058 Ok(FragmentWorkerSlotMappings {
6059 mappings: mappings__.unwrap_or_default(),
6060 })
6061 }
6062 }
6063 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
6064 }
6065}
6066impl serde::Serialize for GetActorVnodesRequest {
6067 #[allow(deprecated)]
6068 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6069 where
6070 S: serde::Serializer,
6071 {
6072 use serde::ser::SerializeStruct;
6073 let mut len = 0;
6074 if self.actor_id != 0 {
6075 len += 1;
6076 }
6077 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
6078 if self.actor_id != 0 {
6079 struct_ser.serialize_field("actorId", &self.actor_id)?;
6080 }
6081 struct_ser.end()
6082 }
6083}
6084impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
6085 #[allow(deprecated)]
6086 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6087 where
6088 D: serde::Deserializer<'de>,
6089 {
6090 const FIELDS: &[&str] = &[
6091 "actor_id",
6092 "actorId",
6093 ];
6094
6095 #[allow(clippy::enum_variant_names)]
6096 enum GeneratedField {
6097 ActorId,
6098 }
6099 impl<'de> serde::Deserialize<'de> for GeneratedField {
6100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6101 where
6102 D: serde::Deserializer<'de>,
6103 {
6104 struct GeneratedVisitor;
6105
6106 impl serde::de::Visitor<'_> for GeneratedVisitor {
6107 type Value = GeneratedField;
6108
6109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6110 write!(formatter, "expected one of: {:?}", &FIELDS)
6111 }
6112
6113 #[allow(unused_variables)]
6114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6115 where
6116 E: serde::de::Error,
6117 {
6118 match value {
6119 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
6120 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6121 }
6122 }
6123 }
6124 deserializer.deserialize_identifier(GeneratedVisitor)
6125 }
6126 }
6127 struct GeneratedVisitor;
6128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6129 type Value = GetActorVnodesRequest;
6130
6131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6132 formatter.write_str("struct meta.GetActorVnodesRequest")
6133 }
6134
6135 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
6136 where
6137 V: serde::de::MapAccess<'de>,
6138 {
6139 let mut actor_id__ = None;
6140 while let Some(k) = map_.next_key()? {
6141 match k {
6142 GeneratedField::ActorId => {
6143 if actor_id__.is_some() {
6144 return Err(serde::de::Error::duplicate_field("actorId"));
6145 }
6146 actor_id__ =
6147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6148 ;
6149 }
6150 }
6151 }
6152 Ok(GetActorVnodesRequest {
6153 actor_id: actor_id__.unwrap_or_default(),
6154 })
6155 }
6156 }
6157 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
6158 }
6159}
6160impl serde::Serialize for GetActorVnodesResponse {
6161 #[allow(deprecated)]
6162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6163 where
6164 S: serde::Serializer,
6165 {
6166 use serde::ser::SerializeStruct;
6167 let mut len = 0;
6168 if !self.vnode_indices.is_empty() {
6169 len += 1;
6170 }
6171 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
6172 if !self.vnode_indices.is_empty() {
6173 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6174 }
6175 struct_ser.end()
6176 }
6177}
6178impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
6179 #[allow(deprecated)]
6180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6181 where
6182 D: serde::Deserializer<'de>,
6183 {
6184 const FIELDS: &[&str] = &[
6185 "vnode_indices",
6186 "vnodeIndices",
6187 ];
6188
6189 #[allow(clippy::enum_variant_names)]
6190 enum GeneratedField {
6191 VnodeIndices,
6192 }
6193 impl<'de> serde::Deserialize<'de> for GeneratedField {
6194 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6195 where
6196 D: serde::Deserializer<'de>,
6197 {
6198 struct GeneratedVisitor;
6199
6200 impl serde::de::Visitor<'_> for GeneratedVisitor {
6201 type Value = GeneratedField;
6202
6203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6204 write!(formatter, "expected one of: {:?}", &FIELDS)
6205 }
6206
6207 #[allow(unused_variables)]
6208 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6209 where
6210 E: serde::de::Error,
6211 {
6212 match value {
6213 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
6214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6215 }
6216 }
6217 }
6218 deserializer.deserialize_identifier(GeneratedVisitor)
6219 }
6220 }
6221 struct GeneratedVisitor;
6222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6223 type Value = GetActorVnodesResponse;
6224
6225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6226 formatter.write_str("struct meta.GetActorVnodesResponse")
6227 }
6228
6229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
6230 where
6231 V: serde::de::MapAccess<'de>,
6232 {
6233 let mut vnode_indices__ = None;
6234 while let Some(k) = map_.next_key()? {
6235 match k {
6236 GeneratedField::VnodeIndices => {
6237 if vnode_indices__.is_some() {
6238 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
6239 }
6240 vnode_indices__ =
6241 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6242 .into_iter().map(|x| x.0).collect())
6243 ;
6244 }
6245 }
6246 }
6247 Ok(GetActorVnodesResponse {
6248 vnode_indices: vnode_indices__.unwrap_or_default(),
6249 })
6250 }
6251 }
6252 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6253 }
6254}
6255impl serde::Serialize for GetClusterInfoRequest {
6256 #[allow(deprecated)]
6257 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6258 where
6259 S: serde::Serializer,
6260 {
6261 use serde::ser::SerializeStruct;
6262 let len = 0;
6263 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6264 struct_ser.end()
6265 }
6266}
6267impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6268 #[allow(deprecated)]
6269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6270 where
6271 D: serde::Deserializer<'de>,
6272 {
6273 const FIELDS: &[&str] = &[
6274 ];
6275
6276 #[allow(clippy::enum_variant_names)]
6277 enum GeneratedField {
6278 }
6279 impl<'de> serde::Deserialize<'de> for GeneratedField {
6280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6281 where
6282 D: serde::Deserializer<'de>,
6283 {
6284 struct GeneratedVisitor;
6285
6286 impl serde::de::Visitor<'_> for GeneratedVisitor {
6287 type Value = GeneratedField;
6288
6289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6290 write!(formatter, "expected one of: {:?}", &FIELDS)
6291 }
6292
6293 #[allow(unused_variables)]
6294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6295 where
6296 E: serde::de::Error,
6297 {
6298 Err(serde::de::Error::unknown_field(value, FIELDS))
6299 }
6300 }
6301 deserializer.deserialize_identifier(GeneratedVisitor)
6302 }
6303 }
6304 struct GeneratedVisitor;
6305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6306 type Value = GetClusterInfoRequest;
6307
6308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6309 formatter.write_str("struct meta.GetClusterInfoRequest")
6310 }
6311
6312 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6313 where
6314 V: serde::de::MapAccess<'de>,
6315 {
6316 while map_.next_key::<GeneratedField>()?.is_some() {
6317 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6318 }
6319 Ok(GetClusterInfoRequest {
6320 })
6321 }
6322 }
6323 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6324 }
6325}
6326impl serde::Serialize for GetClusterInfoResponse {
6327 #[allow(deprecated)]
6328 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6329 where
6330 S: serde::Serializer,
6331 {
6332 use serde::ser::SerializeStruct;
6333 let mut len = 0;
6334 if !self.worker_nodes.is_empty() {
6335 len += 1;
6336 }
6337 if !self.table_fragments.is_empty() {
6338 len += 1;
6339 }
6340 if !self.actor_splits.is_empty() {
6341 len += 1;
6342 }
6343 if !self.source_infos.is_empty() {
6344 len += 1;
6345 }
6346 if self.revision != 0 {
6347 len += 1;
6348 }
6349 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6350 if !self.worker_nodes.is_empty() {
6351 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6352 }
6353 if !self.table_fragments.is_empty() {
6354 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6355 }
6356 if !self.actor_splits.is_empty() {
6357 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6358 }
6359 if !self.source_infos.is_empty() {
6360 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6361 }
6362 if self.revision != 0 {
6363 #[allow(clippy::needless_borrow)]
6364 #[allow(clippy::needless_borrows_for_generic_args)]
6365 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6366 }
6367 struct_ser.end()
6368 }
6369}
6370impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6371 #[allow(deprecated)]
6372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6373 where
6374 D: serde::Deserializer<'de>,
6375 {
6376 const FIELDS: &[&str] = &[
6377 "worker_nodes",
6378 "workerNodes",
6379 "table_fragments",
6380 "tableFragments",
6381 "actor_splits",
6382 "actorSplits",
6383 "source_infos",
6384 "sourceInfos",
6385 "revision",
6386 ];
6387
6388 #[allow(clippy::enum_variant_names)]
6389 enum GeneratedField {
6390 WorkerNodes,
6391 TableFragments,
6392 ActorSplits,
6393 SourceInfos,
6394 Revision,
6395 }
6396 impl<'de> serde::Deserialize<'de> for GeneratedField {
6397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6398 where
6399 D: serde::Deserializer<'de>,
6400 {
6401 struct GeneratedVisitor;
6402
6403 impl serde::de::Visitor<'_> for GeneratedVisitor {
6404 type Value = GeneratedField;
6405
6406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6407 write!(formatter, "expected one of: {:?}", &FIELDS)
6408 }
6409
6410 #[allow(unused_variables)]
6411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6412 where
6413 E: serde::de::Error,
6414 {
6415 match value {
6416 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6417 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6418 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6419 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6420 "revision" => Ok(GeneratedField::Revision),
6421 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6422 }
6423 }
6424 }
6425 deserializer.deserialize_identifier(GeneratedVisitor)
6426 }
6427 }
6428 struct GeneratedVisitor;
6429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6430 type Value = GetClusterInfoResponse;
6431
6432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6433 formatter.write_str("struct meta.GetClusterInfoResponse")
6434 }
6435
6436 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6437 where
6438 V: serde::de::MapAccess<'de>,
6439 {
6440 let mut worker_nodes__ = None;
6441 let mut table_fragments__ = None;
6442 let mut actor_splits__ = None;
6443 let mut source_infos__ = None;
6444 let mut revision__ = None;
6445 while let Some(k) = map_.next_key()? {
6446 match k {
6447 GeneratedField::WorkerNodes => {
6448 if worker_nodes__.is_some() {
6449 return Err(serde::de::Error::duplicate_field("workerNodes"));
6450 }
6451 worker_nodes__ = Some(map_.next_value()?);
6452 }
6453 GeneratedField::TableFragments => {
6454 if table_fragments__.is_some() {
6455 return Err(serde::de::Error::duplicate_field("tableFragments"));
6456 }
6457 table_fragments__ = Some(map_.next_value()?);
6458 }
6459 GeneratedField::ActorSplits => {
6460 if actor_splits__.is_some() {
6461 return Err(serde::de::Error::duplicate_field("actorSplits"));
6462 }
6463 actor_splits__ = Some(
6464 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6465 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6466 );
6467 }
6468 GeneratedField::SourceInfos => {
6469 if source_infos__.is_some() {
6470 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6471 }
6472 source_infos__ = Some(
6473 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6474 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6475 );
6476 }
6477 GeneratedField::Revision => {
6478 if revision__.is_some() {
6479 return Err(serde::de::Error::duplicate_field("revision"));
6480 }
6481 revision__ =
6482 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6483 ;
6484 }
6485 }
6486 }
6487 Ok(GetClusterInfoResponse {
6488 worker_nodes: worker_nodes__.unwrap_or_default(),
6489 table_fragments: table_fragments__.unwrap_or_default(),
6490 actor_splits: actor_splits__.unwrap_or_default(),
6491 source_infos: source_infos__.unwrap_or_default(),
6492 revision: revision__.unwrap_or_default(),
6493 })
6494 }
6495 }
6496 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6497 }
6498}
6499impl serde::Serialize for GetClusterLimitsRequest {
6500 #[allow(deprecated)]
6501 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6502 where
6503 S: serde::Serializer,
6504 {
6505 use serde::ser::SerializeStruct;
6506 let len = 0;
6507 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6508 struct_ser.end()
6509 }
6510}
6511impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6512 #[allow(deprecated)]
6513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6514 where
6515 D: serde::Deserializer<'de>,
6516 {
6517 const FIELDS: &[&str] = &[
6518 ];
6519
6520 #[allow(clippy::enum_variant_names)]
6521 enum GeneratedField {
6522 }
6523 impl<'de> serde::Deserialize<'de> for GeneratedField {
6524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6525 where
6526 D: serde::Deserializer<'de>,
6527 {
6528 struct GeneratedVisitor;
6529
6530 impl serde::de::Visitor<'_> for GeneratedVisitor {
6531 type Value = GeneratedField;
6532
6533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6534 write!(formatter, "expected one of: {:?}", &FIELDS)
6535 }
6536
6537 #[allow(unused_variables)]
6538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6539 where
6540 E: serde::de::Error,
6541 {
6542 Err(serde::de::Error::unknown_field(value, FIELDS))
6543 }
6544 }
6545 deserializer.deserialize_identifier(GeneratedVisitor)
6546 }
6547 }
6548 struct GeneratedVisitor;
6549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6550 type Value = GetClusterLimitsRequest;
6551
6552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6553 formatter.write_str("struct meta.GetClusterLimitsRequest")
6554 }
6555
6556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6557 where
6558 V: serde::de::MapAccess<'de>,
6559 {
6560 while map_.next_key::<GeneratedField>()?.is_some() {
6561 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6562 }
6563 Ok(GetClusterLimitsRequest {
6564 })
6565 }
6566 }
6567 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6568 }
6569}
6570impl serde::Serialize for GetClusterLimitsResponse {
6571 #[allow(deprecated)]
6572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6573 where
6574 S: serde::Serializer,
6575 {
6576 use serde::ser::SerializeStruct;
6577 let mut len = 0;
6578 if !self.active_limits.is_empty() {
6579 len += 1;
6580 }
6581 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6582 if !self.active_limits.is_empty() {
6583 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6584 }
6585 struct_ser.end()
6586 }
6587}
6588impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6589 #[allow(deprecated)]
6590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6591 where
6592 D: serde::Deserializer<'de>,
6593 {
6594 const FIELDS: &[&str] = &[
6595 "active_limits",
6596 "activeLimits",
6597 ];
6598
6599 #[allow(clippy::enum_variant_names)]
6600 enum GeneratedField {
6601 ActiveLimits,
6602 }
6603 impl<'de> serde::Deserialize<'de> for GeneratedField {
6604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6605 where
6606 D: serde::Deserializer<'de>,
6607 {
6608 struct GeneratedVisitor;
6609
6610 impl serde::de::Visitor<'_> for GeneratedVisitor {
6611 type Value = GeneratedField;
6612
6613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6614 write!(formatter, "expected one of: {:?}", &FIELDS)
6615 }
6616
6617 #[allow(unused_variables)]
6618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6619 where
6620 E: serde::de::Error,
6621 {
6622 match value {
6623 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6625 }
6626 }
6627 }
6628 deserializer.deserialize_identifier(GeneratedVisitor)
6629 }
6630 }
6631 struct GeneratedVisitor;
6632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6633 type Value = GetClusterLimitsResponse;
6634
6635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6636 formatter.write_str("struct meta.GetClusterLimitsResponse")
6637 }
6638
6639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6640 where
6641 V: serde::de::MapAccess<'de>,
6642 {
6643 let mut active_limits__ = None;
6644 while let Some(k) = map_.next_key()? {
6645 match k {
6646 GeneratedField::ActiveLimits => {
6647 if active_limits__.is_some() {
6648 return Err(serde::de::Error::duplicate_field("activeLimits"));
6649 }
6650 active_limits__ = Some(map_.next_value()?);
6651 }
6652 }
6653 }
6654 Ok(GetClusterLimitsResponse {
6655 active_limits: active_limits__.unwrap_or_default(),
6656 })
6657 }
6658 }
6659 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6660 }
6661}
6662impl serde::Serialize for GetClusterRecoveryStatusRequest {
6663 #[allow(deprecated)]
6664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6665 where
6666 S: serde::Serializer,
6667 {
6668 use serde::ser::SerializeStruct;
6669 let len = 0;
6670 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6671 struct_ser.end()
6672 }
6673}
6674impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6675 #[allow(deprecated)]
6676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6677 where
6678 D: serde::Deserializer<'de>,
6679 {
6680 const FIELDS: &[&str] = &[
6681 ];
6682
6683 #[allow(clippy::enum_variant_names)]
6684 enum GeneratedField {
6685 }
6686 impl<'de> serde::Deserialize<'de> for GeneratedField {
6687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6688 where
6689 D: serde::Deserializer<'de>,
6690 {
6691 struct GeneratedVisitor;
6692
6693 impl serde::de::Visitor<'_> for GeneratedVisitor {
6694 type Value = GeneratedField;
6695
6696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6697 write!(formatter, "expected one of: {:?}", &FIELDS)
6698 }
6699
6700 #[allow(unused_variables)]
6701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6702 where
6703 E: serde::de::Error,
6704 {
6705 Err(serde::de::Error::unknown_field(value, FIELDS))
6706 }
6707 }
6708 deserializer.deserialize_identifier(GeneratedVisitor)
6709 }
6710 }
6711 struct GeneratedVisitor;
6712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6713 type Value = GetClusterRecoveryStatusRequest;
6714
6715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6716 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6717 }
6718
6719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6720 where
6721 V: serde::de::MapAccess<'de>,
6722 {
6723 while map_.next_key::<GeneratedField>()?.is_some() {
6724 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6725 }
6726 Ok(GetClusterRecoveryStatusRequest {
6727 })
6728 }
6729 }
6730 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6731 }
6732}
6733impl serde::Serialize for GetClusterRecoveryStatusResponse {
6734 #[allow(deprecated)]
6735 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6736 where
6737 S: serde::Serializer,
6738 {
6739 use serde::ser::SerializeStruct;
6740 let mut len = 0;
6741 if self.status != 0 {
6742 len += 1;
6743 }
6744 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6745 if self.status != 0 {
6746 let v = RecoveryStatus::try_from(self.status)
6747 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6748 struct_ser.serialize_field("status", &v)?;
6749 }
6750 struct_ser.end()
6751 }
6752}
6753impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6754 #[allow(deprecated)]
6755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6756 where
6757 D: serde::Deserializer<'de>,
6758 {
6759 const FIELDS: &[&str] = &[
6760 "status",
6761 ];
6762
6763 #[allow(clippy::enum_variant_names)]
6764 enum GeneratedField {
6765 Status,
6766 }
6767 impl<'de> serde::Deserialize<'de> for GeneratedField {
6768 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6769 where
6770 D: serde::Deserializer<'de>,
6771 {
6772 struct GeneratedVisitor;
6773
6774 impl serde::de::Visitor<'_> for GeneratedVisitor {
6775 type Value = GeneratedField;
6776
6777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6778 write!(formatter, "expected one of: {:?}", &FIELDS)
6779 }
6780
6781 #[allow(unused_variables)]
6782 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6783 where
6784 E: serde::de::Error,
6785 {
6786 match value {
6787 "status" => Ok(GeneratedField::Status),
6788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6789 }
6790 }
6791 }
6792 deserializer.deserialize_identifier(GeneratedVisitor)
6793 }
6794 }
6795 struct GeneratedVisitor;
6796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6797 type Value = GetClusterRecoveryStatusResponse;
6798
6799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6800 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6801 }
6802
6803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6804 where
6805 V: serde::de::MapAccess<'de>,
6806 {
6807 let mut status__ = None;
6808 while let Some(k) = map_.next_key()? {
6809 match k {
6810 GeneratedField::Status => {
6811 if status__.is_some() {
6812 return Err(serde::de::Error::duplicate_field("status"));
6813 }
6814 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6815 }
6816 }
6817 }
6818 Ok(GetClusterRecoveryStatusResponse {
6819 status: status__.unwrap_or_default(),
6820 })
6821 }
6822 }
6823 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6824 }
6825}
6826impl serde::Serialize for GetFragmentByIdRequest {
6827 #[allow(deprecated)]
6828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6829 where
6830 S: serde::Serializer,
6831 {
6832 use serde::ser::SerializeStruct;
6833 let mut len = 0;
6834 if self.fragment_id != 0 {
6835 len += 1;
6836 }
6837 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6838 if self.fragment_id != 0 {
6839 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6840 }
6841 struct_ser.end()
6842 }
6843}
6844impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6845 #[allow(deprecated)]
6846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6847 where
6848 D: serde::Deserializer<'de>,
6849 {
6850 const FIELDS: &[&str] = &[
6851 "fragment_id",
6852 "fragmentId",
6853 ];
6854
6855 #[allow(clippy::enum_variant_names)]
6856 enum GeneratedField {
6857 FragmentId,
6858 }
6859 impl<'de> serde::Deserialize<'de> for GeneratedField {
6860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6861 where
6862 D: serde::Deserializer<'de>,
6863 {
6864 struct GeneratedVisitor;
6865
6866 impl serde::de::Visitor<'_> for GeneratedVisitor {
6867 type Value = GeneratedField;
6868
6869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6870 write!(formatter, "expected one of: {:?}", &FIELDS)
6871 }
6872
6873 #[allow(unused_variables)]
6874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6875 where
6876 E: serde::de::Error,
6877 {
6878 match value {
6879 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6880 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6881 }
6882 }
6883 }
6884 deserializer.deserialize_identifier(GeneratedVisitor)
6885 }
6886 }
6887 struct GeneratedVisitor;
6888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6889 type Value = GetFragmentByIdRequest;
6890
6891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6892 formatter.write_str("struct meta.GetFragmentByIdRequest")
6893 }
6894
6895 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6896 where
6897 V: serde::de::MapAccess<'de>,
6898 {
6899 let mut fragment_id__ = None;
6900 while let Some(k) = map_.next_key()? {
6901 match k {
6902 GeneratedField::FragmentId => {
6903 if fragment_id__.is_some() {
6904 return Err(serde::de::Error::duplicate_field("fragmentId"));
6905 }
6906 fragment_id__ =
6907 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6908 ;
6909 }
6910 }
6911 }
6912 Ok(GetFragmentByIdRequest {
6913 fragment_id: fragment_id__.unwrap_or_default(),
6914 })
6915 }
6916 }
6917 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6918 }
6919}
6920impl serde::Serialize for GetFragmentByIdResponse {
6921 #[allow(deprecated)]
6922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6923 where
6924 S: serde::Serializer,
6925 {
6926 use serde::ser::SerializeStruct;
6927 let mut len = 0;
6928 if self.distribution.is_some() {
6929 len += 1;
6930 }
6931 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6932 if let Some(v) = self.distribution.as_ref() {
6933 struct_ser.serialize_field("distribution", v)?;
6934 }
6935 struct_ser.end()
6936 }
6937}
6938impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6939 #[allow(deprecated)]
6940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6941 where
6942 D: serde::Deserializer<'de>,
6943 {
6944 const FIELDS: &[&str] = &[
6945 "distribution",
6946 ];
6947
6948 #[allow(clippy::enum_variant_names)]
6949 enum GeneratedField {
6950 Distribution,
6951 }
6952 impl<'de> serde::Deserialize<'de> for GeneratedField {
6953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6954 where
6955 D: serde::Deserializer<'de>,
6956 {
6957 struct GeneratedVisitor;
6958
6959 impl serde::de::Visitor<'_> for GeneratedVisitor {
6960 type Value = GeneratedField;
6961
6962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6963 write!(formatter, "expected one of: {:?}", &FIELDS)
6964 }
6965
6966 #[allow(unused_variables)]
6967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6968 where
6969 E: serde::de::Error,
6970 {
6971 match value {
6972 "distribution" => Ok(GeneratedField::Distribution),
6973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6974 }
6975 }
6976 }
6977 deserializer.deserialize_identifier(GeneratedVisitor)
6978 }
6979 }
6980 struct GeneratedVisitor;
6981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6982 type Value = GetFragmentByIdResponse;
6983
6984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6985 formatter.write_str("struct meta.GetFragmentByIdResponse")
6986 }
6987
6988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6989 where
6990 V: serde::de::MapAccess<'de>,
6991 {
6992 let mut distribution__ = None;
6993 while let Some(k) = map_.next_key()? {
6994 match k {
6995 GeneratedField::Distribution => {
6996 if distribution__.is_some() {
6997 return Err(serde::de::Error::duplicate_field("distribution"));
6998 }
6999 distribution__ = map_.next_value()?;
7000 }
7001 }
7002 }
7003 Ok(GetFragmentByIdResponse {
7004 distribution: distribution__,
7005 })
7006 }
7007 }
7008 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
7009 }
7010}
7011impl serde::Serialize for GetFragmentVnodesRequest {
7012 #[allow(deprecated)]
7013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7014 where
7015 S: serde::Serializer,
7016 {
7017 use serde::ser::SerializeStruct;
7018 let mut len = 0;
7019 if self.fragment_id != 0 {
7020 len += 1;
7021 }
7022 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
7023 if self.fragment_id != 0 {
7024 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7025 }
7026 struct_ser.end()
7027 }
7028}
7029impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
7030 #[allow(deprecated)]
7031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7032 where
7033 D: serde::Deserializer<'de>,
7034 {
7035 const FIELDS: &[&str] = &[
7036 "fragment_id",
7037 "fragmentId",
7038 ];
7039
7040 #[allow(clippy::enum_variant_names)]
7041 enum GeneratedField {
7042 FragmentId,
7043 }
7044 impl<'de> serde::Deserialize<'de> for GeneratedField {
7045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7046 where
7047 D: serde::Deserializer<'de>,
7048 {
7049 struct GeneratedVisitor;
7050
7051 impl serde::de::Visitor<'_> for GeneratedVisitor {
7052 type Value = GeneratedField;
7053
7054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7055 write!(formatter, "expected one of: {:?}", &FIELDS)
7056 }
7057
7058 #[allow(unused_variables)]
7059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7060 where
7061 E: serde::de::Error,
7062 {
7063 match value {
7064 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7066 }
7067 }
7068 }
7069 deserializer.deserialize_identifier(GeneratedVisitor)
7070 }
7071 }
7072 struct GeneratedVisitor;
7073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7074 type Value = GetFragmentVnodesRequest;
7075
7076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7077 formatter.write_str("struct meta.GetFragmentVnodesRequest")
7078 }
7079
7080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
7081 where
7082 V: serde::de::MapAccess<'de>,
7083 {
7084 let mut fragment_id__ = None;
7085 while let Some(k) = map_.next_key()? {
7086 match k {
7087 GeneratedField::FragmentId => {
7088 if fragment_id__.is_some() {
7089 return Err(serde::de::Error::duplicate_field("fragmentId"));
7090 }
7091 fragment_id__ =
7092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7093 ;
7094 }
7095 }
7096 }
7097 Ok(GetFragmentVnodesRequest {
7098 fragment_id: fragment_id__.unwrap_or_default(),
7099 })
7100 }
7101 }
7102 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
7103 }
7104}
7105impl serde::Serialize for GetFragmentVnodesResponse {
7106 #[allow(deprecated)]
7107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7108 where
7109 S: serde::Serializer,
7110 {
7111 use serde::ser::SerializeStruct;
7112 let mut len = 0;
7113 if !self.actor_vnodes.is_empty() {
7114 len += 1;
7115 }
7116 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
7117 if !self.actor_vnodes.is_empty() {
7118 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
7119 }
7120 struct_ser.end()
7121 }
7122}
7123impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
7124 #[allow(deprecated)]
7125 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7126 where
7127 D: serde::Deserializer<'de>,
7128 {
7129 const FIELDS: &[&str] = &[
7130 "actor_vnodes",
7131 "actorVnodes",
7132 ];
7133
7134 #[allow(clippy::enum_variant_names)]
7135 enum GeneratedField {
7136 ActorVnodes,
7137 }
7138 impl<'de> serde::Deserialize<'de> for GeneratedField {
7139 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7140 where
7141 D: serde::Deserializer<'de>,
7142 {
7143 struct GeneratedVisitor;
7144
7145 impl serde::de::Visitor<'_> for GeneratedVisitor {
7146 type Value = GeneratedField;
7147
7148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7149 write!(formatter, "expected one of: {:?}", &FIELDS)
7150 }
7151
7152 #[allow(unused_variables)]
7153 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7154 where
7155 E: serde::de::Error,
7156 {
7157 match value {
7158 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
7159 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7160 }
7161 }
7162 }
7163 deserializer.deserialize_identifier(GeneratedVisitor)
7164 }
7165 }
7166 struct GeneratedVisitor;
7167 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7168 type Value = GetFragmentVnodesResponse;
7169
7170 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7171 formatter.write_str("struct meta.GetFragmentVnodesResponse")
7172 }
7173
7174 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
7175 where
7176 V: serde::de::MapAccess<'de>,
7177 {
7178 let mut actor_vnodes__ = None;
7179 while let Some(k) = map_.next_key()? {
7180 match k {
7181 GeneratedField::ActorVnodes => {
7182 if actor_vnodes__.is_some() {
7183 return Err(serde::de::Error::duplicate_field("actorVnodes"));
7184 }
7185 actor_vnodes__ = Some(map_.next_value()?);
7186 }
7187 }
7188 }
7189 Ok(GetFragmentVnodesResponse {
7190 actor_vnodes: actor_vnodes__.unwrap_or_default(),
7191 })
7192 }
7193 }
7194 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
7195 }
7196}
7197impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
7198 #[allow(deprecated)]
7199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7200 where
7201 S: serde::Serializer,
7202 {
7203 use serde::ser::SerializeStruct;
7204 let mut len = 0;
7205 if self.actor_id != 0 {
7206 len += 1;
7207 }
7208 if !self.vnode_indices.is_empty() {
7209 len += 1;
7210 }
7211 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
7212 if self.actor_id != 0 {
7213 struct_ser.serialize_field("actorId", &self.actor_id)?;
7214 }
7215 if !self.vnode_indices.is_empty() {
7216 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
7217 }
7218 struct_ser.end()
7219 }
7220}
7221impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
7222 #[allow(deprecated)]
7223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7224 where
7225 D: serde::Deserializer<'de>,
7226 {
7227 const FIELDS: &[&str] = &[
7228 "actor_id",
7229 "actorId",
7230 "vnode_indices",
7231 "vnodeIndices",
7232 ];
7233
7234 #[allow(clippy::enum_variant_names)]
7235 enum GeneratedField {
7236 ActorId,
7237 VnodeIndices,
7238 }
7239 impl<'de> serde::Deserialize<'de> for GeneratedField {
7240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7241 where
7242 D: serde::Deserializer<'de>,
7243 {
7244 struct GeneratedVisitor;
7245
7246 impl serde::de::Visitor<'_> for GeneratedVisitor {
7247 type Value = GeneratedField;
7248
7249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7250 write!(formatter, "expected one of: {:?}", &FIELDS)
7251 }
7252
7253 #[allow(unused_variables)]
7254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7255 where
7256 E: serde::de::Error,
7257 {
7258 match value {
7259 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7260 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7261 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7262 }
7263 }
7264 }
7265 deserializer.deserialize_identifier(GeneratedVisitor)
7266 }
7267 }
7268 struct GeneratedVisitor;
7269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7270 type Value = get_fragment_vnodes_response::ActorVnodes;
7271
7272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7273 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7274 }
7275
7276 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7277 where
7278 V: serde::de::MapAccess<'de>,
7279 {
7280 let mut actor_id__ = None;
7281 let mut vnode_indices__ = None;
7282 while let Some(k) = map_.next_key()? {
7283 match k {
7284 GeneratedField::ActorId => {
7285 if actor_id__.is_some() {
7286 return Err(serde::de::Error::duplicate_field("actorId"));
7287 }
7288 actor_id__ =
7289 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7290 ;
7291 }
7292 GeneratedField::VnodeIndices => {
7293 if vnode_indices__.is_some() {
7294 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7295 }
7296 vnode_indices__ =
7297 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7298 .into_iter().map(|x| x.0).collect())
7299 ;
7300 }
7301 }
7302 }
7303 Ok(get_fragment_vnodes_response::ActorVnodes {
7304 actor_id: actor_id__.unwrap_or_default(),
7305 vnode_indices: vnode_indices__.unwrap_or_default(),
7306 })
7307 }
7308 }
7309 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7310 }
7311}
7312impl serde::Serialize for GetMetaStoreInfoRequest {
7313 #[allow(deprecated)]
7314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7315 where
7316 S: serde::Serializer,
7317 {
7318 use serde::ser::SerializeStruct;
7319 let len = 0;
7320 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7321 struct_ser.end()
7322 }
7323}
7324impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7325 #[allow(deprecated)]
7326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7327 where
7328 D: serde::Deserializer<'de>,
7329 {
7330 const FIELDS: &[&str] = &[
7331 ];
7332
7333 #[allow(clippy::enum_variant_names)]
7334 enum GeneratedField {
7335 }
7336 impl<'de> serde::Deserialize<'de> for GeneratedField {
7337 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7338 where
7339 D: serde::Deserializer<'de>,
7340 {
7341 struct GeneratedVisitor;
7342
7343 impl serde::de::Visitor<'_> for GeneratedVisitor {
7344 type Value = GeneratedField;
7345
7346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7347 write!(formatter, "expected one of: {:?}", &FIELDS)
7348 }
7349
7350 #[allow(unused_variables)]
7351 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7352 where
7353 E: serde::de::Error,
7354 {
7355 Err(serde::de::Error::unknown_field(value, FIELDS))
7356 }
7357 }
7358 deserializer.deserialize_identifier(GeneratedVisitor)
7359 }
7360 }
7361 struct GeneratedVisitor;
7362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7363 type Value = GetMetaStoreInfoRequest;
7364
7365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7366 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7367 }
7368
7369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7370 where
7371 V: serde::de::MapAccess<'de>,
7372 {
7373 while map_.next_key::<GeneratedField>()?.is_some() {
7374 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7375 }
7376 Ok(GetMetaStoreInfoRequest {
7377 })
7378 }
7379 }
7380 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7381 }
7382}
7383impl serde::Serialize for GetMetaStoreInfoResponse {
7384 #[allow(deprecated)]
7385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7386 where
7387 S: serde::Serializer,
7388 {
7389 use serde::ser::SerializeStruct;
7390 let mut len = 0;
7391 if !self.meta_store_endpoint.is_empty() {
7392 len += 1;
7393 }
7394 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7395 if !self.meta_store_endpoint.is_empty() {
7396 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7397 }
7398 struct_ser.end()
7399 }
7400}
7401impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7402 #[allow(deprecated)]
7403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7404 where
7405 D: serde::Deserializer<'de>,
7406 {
7407 const FIELDS: &[&str] = &[
7408 "meta_store_endpoint",
7409 "metaStoreEndpoint",
7410 ];
7411
7412 #[allow(clippy::enum_variant_names)]
7413 enum GeneratedField {
7414 MetaStoreEndpoint,
7415 }
7416 impl<'de> serde::Deserialize<'de> for GeneratedField {
7417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7418 where
7419 D: serde::Deserializer<'de>,
7420 {
7421 struct GeneratedVisitor;
7422
7423 impl serde::de::Visitor<'_> for GeneratedVisitor {
7424 type Value = GeneratedField;
7425
7426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7427 write!(formatter, "expected one of: {:?}", &FIELDS)
7428 }
7429
7430 #[allow(unused_variables)]
7431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7432 where
7433 E: serde::de::Error,
7434 {
7435 match value {
7436 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7438 }
7439 }
7440 }
7441 deserializer.deserialize_identifier(GeneratedVisitor)
7442 }
7443 }
7444 struct GeneratedVisitor;
7445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7446 type Value = GetMetaStoreInfoResponse;
7447
7448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7449 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7450 }
7451
7452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7453 where
7454 V: serde::de::MapAccess<'de>,
7455 {
7456 let mut meta_store_endpoint__ = None;
7457 while let Some(k) = map_.next_key()? {
7458 match k {
7459 GeneratedField::MetaStoreEndpoint => {
7460 if meta_store_endpoint__.is_some() {
7461 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7462 }
7463 meta_store_endpoint__ = Some(map_.next_value()?);
7464 }
7465 }
7466 }
7467 Ok(GetMetaStoreInfoResponse {
7468 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7469 })
7470 }
7471 }
7472 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7473 }
7474}
7475impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7476 #[allow(deprecated)]
7477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7478 where
7479 S: serde::Serializer,
7480 {
7481 use serde::ser::SerializeStruct;
7482 let len = 0;
7483 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7484 struct_ser.end()
7485 }
7486}
7487impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
7488 #[allow(deprecated)]
7489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7490 where
7491 D: serde::Deserializer<'de>,
7492 {
7493 const FIELDS: &[&str] = &[
7494 ];
7495
7496 #[allow(clippy::enum_variant_names)]
7497 enum GeneratedField {
7498 }
7499 impl<'de> serde::Deserialize<'de> for GeneratedField {
7500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7501 where
7502 D: serde::Deserializer<'de>,
7503 {
7504 struct GeneratedVisitor;
7505
7506 impl serde::de::Visitor<'_> for GeneratedVisitor {
7507 type Value = GeneratedField;
7508
7509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7510 write!(formatter, "expected one of: {:?}", &FIELDS)
7511 }
7512
7513 #[allow(unused_variables)]
7514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7515 where
7516 E: serde::de::Error,
7517 {
7518 Err(serde::de::Error::unknown_field(value, FIELDS))
7519 }
7520 }
7521 deserializer.deserialize_identifier(GeneratedVisitor)
7522 }
7523 }
7524 struct GeneratedVisitor;
7525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7526 type Value = GetServerlessStreamingJobsStatusRequest;
7527
7528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7529 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7530 }
7531
7532 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7533 where
7534 V: serde::de::MapAccess<'de>,
7535 {
7536 while map_.next_key::<GeneratedField>()?.is_some() {
7537 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7538 }
7539 Ok(GetServerlessStreamingJobsStatusRequest {
7540 })
7541 }
7542 }
7543 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7544 }
7545}
7546impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
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 mut len = 0;
7554 if !self.streaming_job_statuses.is_empty() {
7555 len += 1;
7556 }
7557 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7558 if !self.streaming_job_statuses.is_empty() {
7559 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7560 }
7561 struct_ser.end()
7562 }
7563}
7564impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7565 #[allow(deprecated)]
7566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7567 where
7568 D: serde::Deserializer<'de>,
7569 {
7570 const FIELDS: &[&str] = &[
7571 "streaming_job_statuses",
7572 "streamingJobStatuses",
7573 ];
7574
7575 #[allow(clippy::enum_variant_names)]
7576 enum GeneratedField {
7577 StreamingJobStatuses,
7578 }
7579 impl<'de> serde::Deserialize<'de> for GeneratedField {
7580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7581 where
7582 D: serde::Deserializer<'de>,
7583 {
7584 struct GeneratedVisitor;
7585
7586 impl serde::de::Visitor<'_> for GeneratedVisitor {
7587 type Value = GeneratedField;
7588
7589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7590 write!(formatter, "expected one of: {:?}", &FIELDS)
7591 }
7592
7593 #[allow(unused_variables)]
7594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7595 where
7596 E: serde::de::Error,
7597 {
7598 match value {
7599 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7601 }
7602 }
7603 }
7604 deserializer.deserialize_identifier(GeneratedVisitor)
7605 }
7606 }
7607 struct GeneratedVisitor;
7608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7609 type Value = GetServerlessStreamingJobsStatusResponse;
7610
7611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7612 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7613 }
7614
7615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7616 where
7617 V: serde::de::MapAccess<'de>,
7618 {
7619 let mut streaming_job_statuses__ = None;
7620 while let Some(k) = map_.next_key()? {
7621 match k {
7622 GeneratedField::StreamingJobStatuses => {
7623 if streaming_job_statuses__.is_some() {
7624 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7625 }
7626 streaming_job_statuses__ = Some(map_.next_value()?);
7627 }
7628 }
7629 }
7630 Ok(GetServerlessStreamingJobsStatusResponse {
7631 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7632 })
7633 }
7634 }
7635 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7636 }
7637}
7638impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7639 #[allow(deprecated)]
7640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7641 where
7642 S: serde::Serializer,
7643 {
7644 use serde::ser::SerializeStruct;
7645 let mut len = 0;
7646 if self.table_id != 0 {
7647 len += 1;
7648 }
7649 if !self.node_label.is_empty() {
7650 len += 1;
7651 }
7652 if self.backfill_done {
7653 len += 1;
7654 }
7655 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7656 if self.table_id != 0 {
7657 struct_ser.serialize_field("tableId", &self.table_id)?;
7658 }
7659 if !self.node_label.is_empty() {
7660 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7661 }
7662 if self.backfill_done {
7663 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7664 }
7665 struct_ser.end()
7666 }
7667}
7668impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7669 #[allow(deprecated)]
7670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7671 where
7672 D: serde::Deserializer<'de>,
7673 {
7674 const FIELDS: &[&str] = &[
7675 "table_id",
7676 "tableId",
7677 "node_label",
7678 "nodeLabel",
7679 "backfill_done",
7680 "backfillDone",
7681 ];
7682
7683 #[allow(clippy::enum_variant_names)]
7684 enum GeneratedField {
7685 TableId,
7686 NodeLabel,
7687 BackfillDone,
7688 }
7689 impl<'de> serde::Deserialize<'de> for GeneratedField {
7690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7691 where
7692 D: serde::Deserializer<'de>,
7693 {
7694 struct GeneratedVisitor;
7695
7696 impl serde::de::Visitor<'_> for GeneratedVisitor {
7697 type Value = GeneratedField;
7698
7699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7700 write!(formatter, "expected one of: {:?}", &FIELDS)
7701 }
7702
7703 #[allow(unused_variables)]
7704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7705 where
7706 E: serde::de::Error,
7707 {
7708 match value {
7709 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7710 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7711 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7713 }
7714 }
7715 }
7716 deserializer.deserialize_identifier(GeneratedVisitor)
7717 }
7718 }
7719 struct GeneratedVisitor;
7720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7721 type Value = get_serverless_streaming_jobs_status_response::Status;
7722
7723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7724 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7725 }
7726
7727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7728 where
7729 V: serde::de::MapAccess<'de>,
7730 {
7731 let mut table_id__ = None;
7732 let mut node_label__ = None;
7733 let mut backfill_done__ = None;
7734 while let Some(k) = map_.next_key()? {
7735 match k {
7736 GeneratedField::TableId => {
7737 if table_id__.is_some() {
7738 return Err(serde::de::Error::duplicate_field("tableId"));
7739 }
7740 table_id__ =
7741 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7742 ;
7743 }
7744 GeneratedField::NodeLabel => {
7745 if node_label__.is_some() {
7746 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7747 }
7748 node_label__ = Some(map_.next_value()?);
7749 }
7750 GeneratedField::BackfillDone => {
7751 if backfill_done__.is_some() {
7752 return Err(serde::de::Error::duplicate_field("backfillDone"));
7753 }
7754 backfill_done__ = Some(map_.next_value()?);
7755 }
7756 }
7757 }
7758 Ok(get_serverless_streaming_jobs_status_response::Status {
7759 table_id: table_id__.unwrap_or_default(),
7760 node_label: node_label__.unwrap_or_default(),
7761 backfill_done: backfill_done__.unwrap_or_default(),
7762 })
7763 }
7764 }
7765 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7766 }
7767}
7768impl serde::Serialize for GetServingVnodeMappingsRequest {
7769 #[allow(deprecated)]
7770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7771 where
7772 S: serde::Serializer,
7773 {
7774 use serde::ser::SerializeStruct;
7775 let len = 0;
7776 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7777 struct_ser.end()
7778 }
7779}
7780impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7781 #[allow(deprecated)]
7782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7783 where
7784 D: serde::Deserializer<'de>,
7785 {
7786 const FIELDS: &[&str] = &[
7787 ];
7788
7789 #[allow(clippy::enum_variant_names)]
7790 enum GeneratedField {
7791 }
7792 impl<'de> serde::Deserialize<'de> for GeneratedField {
7793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7794 where
7795 D: serde::Deserializer<'de>,
7796 {
7797 struct GeneratedVisitor;
7798
7799 impl serde::de::Visitor<'_> for GeneratedVisitor {
7800 type Value = GeneratedField;
7801
7802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7803 write!(formatter, "expected one of: {:?}", &FIELDS)
7804 }
7805
7806 #[allow(unused_variables)]
7807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7808 where
7809 E: serde::de::Error,
7810 {
7811 Err(serde::de::Error::unknown_field(value, FIELDS))
7812 }
7813 }
7814 deserializer.deserialize_identifier(GeneratedVisitor)
7815 }
7816 }
7817 struct GeneratedVisitor;
7818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7819 type Value = GetServingVnodeMappingsRequest;
7820
7821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7822 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7823 }
7824
7825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7826 where
7827 V: serde::de::MapAccess<'de>,
7828 {
7829 while map_.next_key::<GeneratedField>()?.is_some() {
7830 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7831 }
7832 Ok(GetServingVnodeMappingsRequest {
7833 })
7834 }
7835 }
7836 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7837 }
7838}
7839impl serde::Serialize for GetServingVnodeMappingsResponse {
7840 #[allow(deprecated)]
7841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7842 where
7843 S: serde::Serializer,
7844 {
7845 use serde::ser::SerializeStruct;
7846 let mut len = 0;
7847 if !self.fragment_to_table.is_empty() {
7848 len += 1;
7849 }
7850 if !self.worker_slot_mappings.is_empty() {
7851 len += 1;
7852 }
7853 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7854 if !self.fragment_to_table.is_empty() {
7855 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7856 }
7857 if !self.worker_slot_mappings.is_empty() {
7858 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7859 }
7860 struct_ser.end()
7861 }
7862}
7863impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7864 #[allow(deprecated)]
7865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7866 where
7867 D: serde::Deserializer<'de>,
7868 {
7869 const FIELDS: &[&str] = &[
7870 "fragment_to_table",
7871 "fragmentToTable",
7872 "worker_slot_mappings",
7873 "workerSlotMappings",
7874 ];
7875
7876 #[allow(clippy::enum_variant_names)]
7877 enum GeneratedField {
7878 FragmentToTable,
7879 WorkerSlotMappings,
7880 }
7881 impl<'de> serde::Deserialize<'de> for GeneratedField {
7882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7883 where
7884 D: serde::Deserializer<'de>,
7885 {
7886 struct GeneratedVisitor;
7887
7888 impl serde::de::Visitor<'_> for GeneratedVisitor {
7889 type Value = GeneratedField;
7890
7891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7892 write!(formatter, "expected one of: {:?}", &FIELDS)
7893 }
7894
7895 #[allow(unused_variables)]
7896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7897 where
7898 E: serde::de::Error,
7899 {
7900 match value {
7901 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7902 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7904 }
7905 }
7906 }
7907 deserializer.deserialize_identifier(GeneratedVisitor)
7908 }
7909 }
7910 struct GeneratedVisitor;
7911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7912 type Value = GetServingVnodeMappingsResponse;
7913
7914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7915 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7916 }
7917
7918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7919 where
7920 V: serde::de::MapAccess<'de>,
7921 {
7922 let mut fragment_to_table__ = None;
7923 let mut worker_slot_mappings__ = None;
7924 while let Some(k) = map_.next_key()? {
7925 match k {
7926 GeneratedField::FragmentToTable => {
7927 if fragment_to_table__.is_some() {
7928 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7929 }
7930 fragment_to_table__ = Some(
7931 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7932 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
7933 );
7934 }
7935 GeneratedField::WorkerSlotMappings => {
7936 if worker_slot_mappings__.is_some() {
7937 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7938 }
7939 worker_slot_mappings__ = Some(map_.next_value()?);
7940 }
7941 }
7942 }
7943 Ok(GetServingVnodeMappingsResponse {
7944 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7945 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7946 })
7947 }
7948 }
7949 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7950 }
7951}
7952impl serde::Serialize for GetSessionParamsRequest {
7953 #[allow(deprecated)]
7954 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7955 where
7956 S: serde::Serializer,
7957 {
7958 use serde::ser::SerializeStruct;
7959 let len = 0;
7960 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7961 struct_ser.end()
7962 }
7963}
7964impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7965 #[allow(deprecated)]
7966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7967 where
7968 D: serde::Deserializer<'de>,
7969 {
7970 const FIELDS: &[&str] = &[
7971 ];
7972
7973 #[allow(clippy::enum_variant_names)]
7974 enum GeneratedField {
7975 }
7976 impl<'de> serde::Deserialize<'de> for GeneratedField {
7977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7978 where
7979 D: serde::Deserializer<'de>,
7980 {
7981 struct GeneratedVisitor;
7982
7983 impl serde::de::Visitor<'_> for GeneratedVisitor {
7984 type Value = GeneratedField;
7985
7986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7987 write!(formatter, "expected one of: {:?}", &FIELDS)
7988 }
7989
7990 #[allow(unused_variables)]
7991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7992 where
7993 E: serde::de::Error,
7994 {
7995 Err(serde::de::Error::unknown_field(value, FIELDS))
7996 }
7997 }
7998 deserializer.deserialize_identifier(GeneratedVisitor)
7999 }
8000 }
8001 struct GeneratedVisitor;
8002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8003 type Value = GetSessionParamsRequest;
8004
8005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8006 formatter.write_str("struct meta.GetSessionParamsRequest")
8007 }
8008
8009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
8010 where
8011 V: serde::de::MapAccess<'de>,
8012 {
8013 while map_.next_key::<GeneratedField>()?.is_some() {
8014 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8015 }
8016 Ok(GetSessionParamsRequest {
8017 })
8018 }
8019 }
8020 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
8021 }
8022}
8023impl serde::Serialize for GetSessionParamsResponse {
8024 #[allow(deprecated)]
8025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8026 where
8027 S: serde::Serializer,
8028 {
8029 use serde::ser::SerializeStruct;
8030 let mut len = 0;
8031 if !self.params.is_empty() {
8032 len += 1;
8033 }
8034 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
8035 if !self.params.is_empty() {
8036 struct_ser.serialize_field("params", &self.params)?;
8037 }
8038 struct_ser.end()
8039 }
8040}
8041impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
8042 #[allow(deprecated)]
8043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8044 where
8045 D: serde::Deserializer<'de>,
8046 {
8047 const FIELDS: &[&str] = &[
8048 "params",
8049 ];
8050
8051 #[allow(clippy::enum_variant_names)]
8052 enum GeneratedField {
8053 Params,
8054 }
8055 impl<'de> serde::Deserialize<'de> for GeneratedField {
8056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8057 where
8058 D: serde::Deserializer<'de>,
8059 {
8060 struct GeneratedVisitor;
8061
8062 impl serde::de::Visitor<'_> for GeneratedVisitor {
8063 type Value = GeneratedField;
8064
8065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8066 write!(formatter, "expected one of: {:?}", &FIELDS)
8067 }
8068
8069 #[allow(unused_variables)]
8070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8071 where
8072 E: serde::de::Error,
8073 {
8074 match value {
8075 "params" => Ok(GeneratedField::Params),
8076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8077 }
8078 }
8079 }
8080 deserializer.deserialize_identifier(GeneratedVisitor)
8081 }
8082 }
8083 struct GeneratedVisitor;
8084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8085 type Value = GetSessionParamsResponse;
8086
8087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8088 formatter.write_str("struct meta.GetSessionParamsResponse")
8089 }
8090
8091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
8092 where
8093 V: serde::de::MapAccess<'de>,
8094 {
8095 let mut params__ = None;
8096 while let Some(k) = map_.next_key()? {
8097 match k {
8098 GeneratedField::Params => {
8099 if params__.is_some() {
8100 return Err(serde::de::Error::duplicate_field("params"));
8101 }
8102 params__ = Some(map_.next_value()?);
8103 }
8104 }
8105 }
8106 Ok(GetSessionParamsResponse {
8107 params: params__.unwrap_or_default(),
8108 })
8109 }
8110 }
8111 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
8112 }
8113}
8114impl serde::Serialize for GetSystemParamsRequest {
8115 #[allow(deprecated)]
8116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8117 where
8118 S: serde::Serializer,
8119 {
8120 use serde::ser::SerializeStruct;
8121 let len = 0;
8122 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
8123 struct_ser.end()
8124 }
8125}
8126impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
8127 #[allow(deprecated)]
8128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8129 where
8130 D: serde::Deserializer<'de>,
8131 {
8132 const FIELDS: &[&str] = &[
8133 ];
8134
8135 #[allow(clippy::enum_variant_names)]
8136 enum GeneratedField {
8137 }
8138 impl<'de> serde::Deserialize<'de> for GeneratedField {
8139 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8140 where
8141 D: serde::Deserializer<'de>,
8142 {
8143 struct GeneratedVisitor;
8144
8145 impl serde::de::Visitor<'_> for GeneratedVisitor {
8146 type Value = GeneratedField;
8147
8148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8149 write!(formatter, "expected one of: {:?}", &FIELDS)
8150 }
8151
8152 #[allow(unused_variables)]
8153 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8154 where
8155 E: serde::de::Error,
8156 {
8157 Err(serde::de::Error::unknown_field(value, FIELDS))
8158 }
8159 }
8160 deserializer.deserialize_identifier(GeneratedVisitor)
8161 }
8162 }
8163 struct GeneratedVisitor;
8164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8165 type Value = GetSystemParamsRequest;
8166
8167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8168 formatter.write_str("struct meta.GetSystemParamsRequest")
8169 }
8170
8171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
8172 where
8173 V: serde::de::MapAccess<'de>,
8174 {
8175 while map_.next_key::<GeneratedField>()?.is_some() {
8176 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8177 }
8178 Ok(GetSystemParamsRequest {
8179 })
8180 }
8181 }
8182 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
8183 }
8184}
8185impl serde::Serialize for GetSystemParamsResponse {
8186 #[allow(deprecated)]
8187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8188 where
8189 S: serde::Serializer,
8190 {
8191 use serde::ser::SerializeStruct;
8192 let mut len = 0;
8193 if self.params.is_some() {
8194 len += 1;
8195 }
8196 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
8197 if let Some(v) = self.params.as_ref() {
8198 struct_ser.serialize_field("params", v)?;
8199 }
8200 struct_ser.end()
8201 }
8202}
8203impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
8204 #[allow(deprecated)]
8205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8206 where
8207 D: serde::Deserializer<'de>,
8208 {
8209 const FIELDS: &[&str] = &[
8210 "params",
8211 ];
8212
8213 #[allow(clippy::enum_variant_names)]
8214 enum GeneratedField {
8215 Params,
8216 }
8217 impl<'de> serde::Deserialize<'de> for GeneratedField {
8218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8219 where
8220 D: serde::Deserializer<'de>,
8221 {
8222 struct GeneratedVisitor;
8223
8224 impl serde::de::Visitor<'_> for GeneratedVisitor {
8225 type Value = GeneratedField;
8226
8227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8228 write!(formatter, "expected one of: {:?}", &FIELDS)
8229 }
8230
8231 #[allow(unused_variables)]
8232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8233 where
8234 E: serde::de::Error,
8235 {
8236 match value {
8237 "params" => Ok(GeneratedField::Params),
8238 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8239 }
8240 }
8241 }
8242 deserializer.deserialize_identifier(GeneratedVisitor)
8243 }
8244 }
8245 struct GeneratedVisitor;
8246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8247 type Value = GetSystemParamsResponse;
8248
8249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8250 formatter.write_str("struct meta.GetSystemParamsResponse")
8251 }
8252
8253 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8254 where
8255 V: serde::de::MapAccess<'de>,
8256 {
8257 let mut params__ = None;
8258 while let Some(k) = map_.next_key()? {
8259 match k {
8260 GeneratedField::Params => {
8261 if params__.is_some() {
8262 return Err(serde::de::Error::duplicate_field("params"));
8263 }
8264 params__ = map_.next_value()?;
8265 }
8266 }
8267 }
8268 Ok(GetSystemParamsResponse {
8269 params: params__,
8270 })
8271 }
8272 }
8273 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8274 }
8275}
8276impl serde::Serialize for GetTelemetryInfoRequest {
8277 #[allow(deprecated)]
8278 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8279 where
8280 S: serde::Serializer,
8281 {
8282 use serde::ser::SerializeStruct;
8283 let len = 0;
8284 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8285 struct_ser.end()
8286 }
8287}
8288impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8289 #[allow(deprecated)]
8290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8291 where
8292 D: serde::Deserializer<'de>,
8293 {
8294 const FIELDS: &[&str] = &[
8295 ];
8296
8297 #[allow(clippy::enum_variant_names)]
8298 enum GeneratedField {
8299 }
8300 impl<'de> serde::Deserialize<'de> for GeneratedField {
8301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8302 where
8303 D: serde::Deserializer<'de>,
8304 {
8305 struct GeneratedVisitor;
8306
8307 impl serde::de::Visitor<'_> for GeneratedVisitor {
8308 type Value = GeneratedField;
8309
8310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8311 write!(formatter, "expected one of: {:?}", &FIELDS)
8312 }
8313
8314 #[allow(unused_variables)]
8315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8316 where
8317 E: serde::de::Error,
8318 {
8319 Err(serde::de::Error::unknown_field(value, FIELDS))
8320 }
8321 }
8322 deserializer.deserialize_identifier(GeneratedVisitor)
8323 }
8324 }
8325 struct GeneratedVisitor;
8326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8327 type Value = GetTelemetryInfoRequest;
8328
8329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8330 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8331 }
8332
8333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8334 where
8335 V: serde::de::MapAccess<'de>,
8336 {
8337 while map_.next_key::<GeneratedField>()?.is_some() {
8338 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8339 }
8340 Ok(GetTelemetryInfoRequest {
8341 })
8342 }
8343 }
8344 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8345 }
8346}
8347impl serde::Serialize for HeartbeatRequest {
8348 #[allow(deprecated)]
8349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8350 where
8351 S: serde::Serializer,
8352 {
8353 use serde::ser::SerializeStruct;
8354 let mut len = 0;
8355 if self.node_id != 0 {
8356 len += 1;
8357 }
8358 if self.resource.is_some() {
8359 len += 1;
8360 }
8361 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8362 if self.node_id != 0 {
8363 struct_ser.serialize_field("nodeId", &self.node_id)?;
8364 }
8365 if let Some(v) = self.resource.as_ref() {
8366 struct_ser.serialize_field("resource", v)?;
8367 }
8368 struct_ser.end()
8369 }
8370}
8371impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8372 #[allow(deprecated)]
8373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8374 where
8375 D: serde::Deserializer<'de>,
8376 {
8377 const FIELDS: &[&str] = &[
8378 "node_id",
8379 "nodeId",
8380 "resource",
8381 ];
8382
8383 #[allow(clippy::enum_variant_names)]
8384 enum GeneratedField {
8385 NodeId,
8386 Resource,
8387 }
8388 impl<'de> serde::Deserialize<'de> for GeneratedField {
8389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8390 where
8391 D: serde::Deserializer<'de>,
8392 {
8393 struct GeneratedVisitor;
8394
8395 impl serde::de::Visitor<'_> for GeneratedVisitor {
8396 type Value = GeneratedField;
8397
8398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8399 write!(formatter, "expected one of: {:?}", &FIELDS)
8400 }
8401
8402 #[allow(unused_variables)]
8403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8404 where
8405 E: serde::de::Error,
8406 {
8407 match value {
8408 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8409 "resource" => Ok(GeneratedField::Resource),
8410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8411 }
8412 }
8413 }
8414 deserializer.deserialize_identifier(GeneratedVisitor)
8415 }
8416 }
8417 struct GeneratedVisitor;
8418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8419 type Value = HeartbeatRequest;
8420
8421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8422 formatter.write_str("struct meta.HeartbeatRequest")
8423 }
8424
8425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8426 where
8427 V: serde::de::MapAccess<'de>,
8428 {
8429 let mut node_id__ = None;
8430 let mut resource__ = None;
8431 while let Some(k) = map_.next_key()? {
8432 match k {
8433 GeneratedField::NodeId => {
8434 if node_id__.is_some() {
8435 return Err(serde::de::Error::duplicate_field("nodeId"));
8436 }
8437 node_id__ =
8438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8439 ;
8440 }
8441 GeneratedField::Resource => {
8442 if resource__.is_some() {
8443 return Err(serde::de::Error::duplicate_field("resource"));
8444 }
8445 resource__ = map_.next_value()?;
8446 }
8447 }
8448 }
8449 Ok(HeartbeatRequest {
8450 node_id: node_id__.unwrap_or_default(),
8451 resource: resource__,
8452 })
8453 }
8454 }
8455 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8456 }
8457}
8458impl serde::Serialize for HeartbeatResponse {
8459 #[allow(deprecated)]
8460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8461 where
8462 S: serde::Serializer,
8463 {
8464 use serde::ser::SerializeStruct;
8465 let mut len = 0;
8466 if self.status.is_some() {
8467 len += 1;
8468 }
8469 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8470 if let Some(v) = self.status.as_ref() {
8471 struct_ser.serialize_field("status", v)?;
8472 }
8473 struct_ser.end()
8474 }
8475}
8476impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8477 #[allow(deprecated)]
8478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8479 where
8480 D: serde::Deserializer<'de>,
8481 {
8482 const FIELDS: &[&str] = &[
8483 "status",
8484 ];
8485
8486 #[allow(clippy::enum_variant_names)]
8487 enum GeneratedField {
8488 Status,
8489 }
8490 impl<'de> serde::Deserialize<'de> for GeneratedField {
8491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8492 where
8493 D: serde::Deserializer<'de>,
8494 {
8495 struct GeneratedVisitor;
8496
8497 impl serde::de::Visitor<'_> for GeneratedVisitor {
8498 type Value = GeneratedField;
8499
8500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8501 write!(formatter, "expected one of: {:?}", &FIELDS)
8502 }
8503
8504 #[allow(unused_variables)]
8505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8506 where
8507 E: serde::de::Error,
8508 {
8509 match value {
8510 "status" => Ok(GeneratedField::Status),
8511 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8512 }
8513 }
8514 }
8515 deserializer.deserialize_identifier(GeneratedVisitor)
8516 }
8517 }
8518 struct GeneratedVisitor;
8519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8520 type Value = HeartbeatResponse;
8521
8522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8523 formatter.write_str("struct meta.HeartbeatResponse")
8524 }
8525
8526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8527 where
8528 V: serde::de::MapAccess<'de>,
8529 {
8530 let mut status__ = None;
8531 while let Some(k) = map_.next_key()? {
8532 match k {
8533 GeneratedField::Status => {
8534 if status__.is_some() {
8535 return Err(serde::de::Error::duplicate_field("status"));
8536 }
8537 status__ = map_.next_value()?;
8538 }
8539 }
8540 }
8541 Ok(HeartbeatResponse {
8542 status: status__,
8543 })
8544 }
8545 }
8546 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8547 }
8548}
8549impl serde::Serialize for InjectSourceOffsetsRequest {
8550 #[allow(deprecated)]
8551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8552 where
8553 S: serde::Serializer,
8554 {
8555 use serde::ser::SerializeStruct;
8556 let mut len = 0;
8557 if self.source_id != 0 {
8558 len += 1;
8559 }
8560 if !self.split_offsets.is_empty() {
8561 len += 1;
8562 }
8563 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsRequest", len)?;
8564 if self.source_id != 0 {
8565 struct_ser.serialize_field("sourceId", &self.source_id)?;
8566 }
8567 if !self.split_offsets.is_empty() {
8568 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
8569 }
8570 struct_ser.end()
8571 }
8572}
8573impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsRequest {
8574 #[allow(deprecated)]
8575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8576 where
8577 D: serde::Deserializer<'de>,
8578 {
8579 const FIELDS: &[&str] = &[
8580 "source_id",
8581 "sourceId",
8582 "split_offsets",
8583 "splitOffsets",
8584 ];
8585
8586 #[allow(clippy::enum_variant_names)]
8587 enum GeneratedField {
8588 SourceId,
8589 SplitOffsets,
8590 }
8591 impl<'de> serde::Deserialize<'de> for GeneratedField {
8592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8593 where
8594 D: serde::Deserializer<'de>,
8595 {
8596 struct GeneratedVisitor;
8597
8598 impl serde::de::Visitor<'_> for GeneratedVisitor {
8599 type Value = GeneratedField;
8600
8601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8602 write!(formatter, "expected one of: {:?}", &FIELDS)
8603 }
8604
8605 #[allow(unused_variables)]
8606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8607 where
8608 E: serde::de::Error,
8609 {
8610 match value {
8611 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8612 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
8613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8614 }
8615 }
8616 }
8617 deserializer.deserialize_identifier(GeneratedVisitor)
8618 }
8619 }
8620 struct GeneratedVisitor;
8621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8622 type Value = InjectSourceOffsetsRequest;
8623
8624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8625 formatter.write_str("struct meta.InjectSourceOffsetsRequest")
8626 }
8627
8628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsRequest, V::Error>
8629 where
8630 V: serde::de::MapAccess<'de>,
8631 {
8632 let mut source_id__ = None;
8633 let mut split_offsets__ = None;
8634 while let Some(k) = map_.next_key()? {
8635 match k {
8636 GeneratedField::SourceId => {
8637 if source_id__.is_some() {
8638 return Err(serde::de::Error::duplicate_field("sourceId"));
8639 }
8640 source_id__ =
8641 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8642 ;
8643 }
8644 GeneratedField::SplitOffsets => {
8645 if split_offsets__.is_some() {
8646 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8647 }
8648 split_offsets__ = Some(
8649 map_.next_value::<std::collections::HashMap<_, _>>()?
8650 );
8651 }
8652 }
8653 }
8654 Ok(InjectSourceOffsetsRequest {
8655 source_id: source_id__.unwrap_or_default(),
8656 split_offsets: split_offsets__.unwrap_or_default(),
8657 })
8658 }
8659 }
8660 deserializer.deserialize_struct("meta.InjectSourceOffsetsRequest", FIELDS, GeneratedVisitor)
8661 }
8662}
8663impl serde::Serialize for InjectSourceOffsetsResponse {
8664 #[allow(deprecated)]
8665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8666 where
8667 S: serde::Serializer,
8668 {
8669 use serde::ser::SerializeStruct;
8670 let mut len = 0;
8671 if !self.applied_split_ids.is_empty() {
8672 len += 1;
8673 }
8674 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsResponse", len)?;
8675 if !self.applied_split_ids.is_empty() {
8676 struct_ser.serialize_field("appliedSplitIds", &self.applied_split_ids)?;
8677 }
8678 struct_ser.end()
8679 }
8680}
8681impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsResponse {
8682 #[allow(deprecated)]
8683 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8684 where
8685 D: serde::Deserializer<'de>,
8686 {
8687 const FIELDS: &[&str] = &[
8688 "applied_split_ids",
8689 "appliedSplitIds",
8690 ];
8691
8692 #[allow(clippy::enum_variant_names)]
8693 enum GeneratedField {
8694 AppliedSplitIds,
8695 }
8696 impl<'de> serde::Deserialize<'de> for GeneratedField {
8697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8698 where
8699 D: serde::Deserializer<'de>,
8700 {
8701 struct GeneratedVisitor;
8702
8703 impl serde::de::Visitor<'_> for GeneratedVisitor {
8704 type Value = GeneratedField;
8705
8706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8707 write!(formatter, "expected one of: {:?}", &FIELDS)
8708 }
8709
8710 #[allow(unused_variables)]
8711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8712 where
8713 E: serde::de::Error,
8714 {
8715 match value {
8716 "appliedSplitIds" | "applied_split_ids" => Ok(GeneratedField::AppliedSplitIds),
8717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8718 }
8719 }
8720 }
8721 deserializer.deserialize_identifier(GeneratedVisitor)
8722 }
8723 }
8724 struct GeneratedVisitor;
8725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8726 type Value = InjectSourceOffsetsResponse;
8727
8728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8729 formatter.write_str("struct meta.InjectSourceOffsetsResponse")
8730 }
8731
8732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsResponse, V::Error>
8733 where
8734 V: serde::de::MapAccess<'de>,
8735 {
8736 let mut applied_split_ids__ = None;
8737 while let Some(k) = map_.next_key()? {
8738 match k {
8739 GeneratedField::AppliedSplitIds => {
8740 if applied_split_ids__.is_some() {
8741 return Err(serde::de::Error::duplicate_field("appliedSplitIds"));
8742 }
8743 applied_split_ids__ = Some(map_.next_value()?);
8744 }
8745 }
8746 }
8747 Ok(InjectSourceOffsetsResponse {
8748 applied_split_ids: applied_split_ids__.unwrap_or_default(),
8749 })
8750 }
8751 }
8752 deserializer.deserialize_struct("meta.InjectSourceOffsetsResponse", FIELDS, GeneratedVisitor)
8753 }
8754}
8755impl serde::Serialize for ListActorSplitsRequest {
8756 #[allow(deprecated)]
8757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8758 where
8759 S: serde::Serializer,
8760 {
8761 use serde::ser::SerializeStruct;
8762 let len = 0;
8763 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8764 struct_ser.end()
8765 }
8766}
8767impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8768 #[allow(deprecated)]
8769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8770 where
8771 D: serde::Deserializer<'de>,
8772 {
8773 const FIELDS: &[&str] = &[
8774 ];
8775
8776 #[allow(clippy::enum_variant_names)]
8777 enum GeneratedField {
8778 }
8779 impl<'de> serde::Deserialize<'de> for GeneratedField {
8780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8781 where
8782 D: serde::Deserializer<'de>,
8783 {
8784 struct GeneratedVisitor;
8785
8786 impl serde::de::Visitor<'_> for GeneratedVisitor {
8787 type Value = GeneratedField;
8788
8789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8790 write!(formatter, "expected one of: {:?}", &FIELDS)
8791 }
8792
8793 #[allow(unused_variables)]
8794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8795 where
8796 E: serde::de::Error,
8797 {
8798 Err(serde::de::Error::unknown_field(value, FIELDS))
8799 }
8800 }
8801 deserializer.deserialize_identifier(GeneratedVisitor)
8802 }
8803 }
8804 struct GeneratedVisitor;
8805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8806 type Value = ListActorSplitsRequest;
8807
8808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8809 formatter.write_str("struct meta.ListActorSplitsRequest")
8810 }
8811
8812 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8813 where
8814 V: serde::de::MapAccess<'de>,
8815 {
8816 while map_.next_key::<GeneratedField>()?.is_some() {
8817 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8818 }
8819 Ok(ListActorSplitsRequest {
8820 })
8821 }
8822 }
8823 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
8824 }
8825}
8826impl serde::Serialize for ListActorSplitsResponse {
8827 #[allow(deprecated)]
8828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8829 where
8830 S: serde::Serializer,
8831 {
8832 use serde::ser::SerializeStruct;
8833 let mut len = 0;
8834 if !self.actor_splits.is_empty() {
8835 len += 1;
8836 }
8837 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
8838 if !self.actor_splits.is_empty() {
8839 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
8840 }
8841 struct_ser.end()
8842 }
8843}
8844impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
8845 #[allow(deprecated)]
8846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8847 where
8848 D: serde::Deserializer<'de>,
8849 {
8850 const FIELDS: &[&str] = &[
8851 "actor_splits",
8852 "actorSplits",
8853 ];
8854
8855 #[allow(clippy::enum_variant_names)]
8856 enum GeneratedField {
8857 ActorSplits,
8858 }
8859 impl<'de> serde::Deserialize<'de> for GeneratedField {
8860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8861 where
8862 D: serde::Deserializer<'de>,
8863 {
8864 struct GeneratedVisitor;
8865
8866 impl serde::de::Visitor<'_> for GeneratedVisitor {
8867 type Value = GeneratedField;
8868
8869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8870 write!(formatter, "expected one of: {:?}", &FIELDS)
8871 }
8872
8873 #[allow(unused_variables)]
8874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8875 where
8876 E: serde::de::Error,
8877 {
8878 match value {
8879 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
8880 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8881 }
8882 }
8883 }
8884 deserializer.deserialize_identifier(GeneratedVisitor)
8885 }
8886 }
8887 struct GeneratedVisitor;
8888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8889 type Value = ListActorSplitsResponse;
8890
8891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8892 formatter.write_str("struct meta.ListActorSplitsResponse")
8893 }
8894
8895 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
8896 where
8897 V: serde::de::MapAccess<'de>,
8898 {
8899 let mut actor_splits__ = None;
8900 while let Some(k) = map_.next_key()? {
8901 match k {
8902 GeneratedField::ActorSplits => {
8903 if actor_splits__.is_some() {
8904 return Err(serde::de::Error::duplicate_field("actorSplits"));
8905 }
8906 actor_splits__ = Some(map_.next_value()?);
8907 }
8908 }
8909 }
8910 Ok(ListActorSplitsResponse {
8911 actor_splits: actor_splits__.unwrap_or_default(),
8912 })
8913 }
8914 }
8915 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
8916 }
8917}
8918impl serde::Serialize for list_actor_splits_response::ActorSplit {
8919 #[allow(deprecated)]
8920 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8921 where
8922 S: serde::Serializer,
8923 {
8924 use serde::ser::SerializeStruct;
8925 let mut len = 0;
8926 if self.actor_id != 0 {
8927 len += 1;
8928 }
8929 if self.fragment_id != 0 {
8930 len += 1;
8931 }
8932 if self.source_id != 0 {
8933 len += 1;
8934 }
8935 if !self.split_id.is_empty() {
8936 len += 1;
8937 }
8938 if self.fragment_type != 0 {
8939 len += 1;
8940 }
8941 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
8942 if self.actor_id != 0 {
8943 struct_ser.serialize_field("actorId", &self.actor_id)?;
8944 }
8945 if self.fragment_id != 0 {
8946 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8947 }
8948 if self.source_id != 0 {
8949 struct_ser.serialize_field("sourceId", &self.source_id)?;
8950 }
8951 if !self.split_id.is_empty() {
8952 struct_ser.serialize_field("splitId", &self.split_id)?;
8953 }
8954 if self.fragment_type != 0 {
8955 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
8956 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8957 struct_ser.serialize_field("fragmentType", &v)?;
8958 }
8959 struct_ser.end()
8960 }
8961}
8962impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8963 #[allow(deprecated)]
8964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8965 where
8966 D: serde::Deserializer<'de>,
8967 {
8968 const FIELDS: &[&str] = &[
8969 "actor_id",
8970 "actorId",
8971 "fragment_id",
8972 "fragmentId",
8973 "source_id",
8974 "sourceId",
8975 "split_id",
8976 "splitId",
8977 "fragment_type",
8978 "fragmentType",
8979 ];
8980
8981 #[allow(clippy::enum_variant_names)]
8982 enum GeneratedField {
8983 ActorId,
8984 FragmentId,
8985 SourceId,
8986 SplitId,
8987 FragmentType,
8988 }
8989 impl<'de> serde::Deserialize<'de> for GeneratedField {
8990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8991 where
8992 D: serde::Deserializer<'de>,
8993 {
8994 struct GeneratedVisitor;
8995
8996 impl serde::de::Visitor<'_> for GeneratedVisitor {
8997 type Value = GeneratedField;
8998
8999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9000 write!(formatter, "expected one of: {:?}", &FIELDS)
9001 }
9002
9003 #[allow(unused_variables)]
9004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9005 where
9006 E: serde::de::Error,
9007 {
9008 match value {
9009 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9010 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9011 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9012 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
9013 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
9014 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9015 }
9016 }
9017 }
9018 deserializer.deserialize_identifier(GeneratedVisitor)
9019 }
9020 }
9021 struct GeneratedVisitor;
9022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9023 type Value = list_actor_splits_response::ActorSplit;
9024
9025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9026 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
9027 }
9028
9029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
9030 where
9031 V: serde::de::MapAccess<'de>,
9032 {
9033 let mut actor_id__ = None;
9034 let mut fragment_id__ = None;
9035 let mut source_id__ = None;
9036 let mut split_id__ = None;
9037 let mut fragment_type__ = None;
9038 while let Some(k) = map_.next_key()? {
9039 match k {
9040 GeneratedField::ActorId => {
9041 if actor_id__.is_some() {
9042 return Err(serde::de::Error::duplicate_field("actorId"));
9043 }
9044 actor_id__ =
9045 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9046 ;
9047 }
9048 GeneratedField::FragmentId => {
9049 if fragment_id__.is_some() {
9050 return Err(serde::de::Error::duplicate_field("fragmentId"));
9051 }
9052 fragment_id__ =
9053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9054 ;
9055 }
9056 GeneratedField::SourceId => {
9057 if source_id__.is_some() {
9058 return Err(serde::de::Error::duplicate_field("sourceId"));
9059 }
9060 source_id__ =
9061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9062 ;
9063 }
9064 GeneratedField::SplitId => {
9065 if split_id__.is_some() {
9066 return Err(serde::de::Error::duplicate_field("splitId"));
9067 }
9068 split_id__ = Some(map_.next_value()?);
9069 }
9070 GeneratedField::FragmentType => {
9071 if fragment_type__.is_some() {
9072 return Err(serde::de::Error::duplicate_field("fragmentType"));
9073 }
9074 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
9075 }
9076 }
9077 }
9078 Ok(list_actor_splits_response::ActorSplit {
9079 actor_id: actor_id__.unwrap_or_default(),
9080 fragment_id: fragment_id__.unwrap_or_default(),
9081 source_id: source_id__.unwrap_or_default(),
9082 split_id: split_id__.unwrap_or_default(),
9083 fragment_type: fragment_type__.unwrap_or_default(),
9084 })
9085 }
9086 }
9087 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
9088 }
9089}
9090impl serde::Serialize for list_actor_splits_response::FragmentType {
9091 #[allow(deprecated)]
9092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9093 where
9094 S: serde::Serializer,
9095 {
9096 let variant = match self {
9097 Self::Unspecified => "UNSPECIFIED",
9098 Self::NonSharedSource => "NON_SHARED_SOURCE",
9099 Self::SharedSource => "SHARED_SOURCE",
9100 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
9101 };
9102 serializer.serialize_str(variant)
9103 }
9104}
9105impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
9106 #[allow(deprecated)]
9107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9108 where
9109 D: serde::Deserializer<'de>,
9110 {
9111 const FIELDS: &[&str] = &[
9112 "UNSPECIFIED",
9113 "NON_SHARED_SOURCE",
9114 "SHARED_SOURCE",
9115 "SHARED_SOURCE_BACKFILL",
9116 ];
9117
9118 struct GeneratedVisitor;
9119
9120 impl serde::de::Visitor<'_> for GeneratedVisitor {
9121 type Value = list_actor_splits_response::FragmentType;
9122
9123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9124 write!(formatter, "expected one of: {:?}", &FIELDS)
9125 }
9126
9127 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9128 where
9129 E: serde::de::Error,
9130 {
9131 i32::try_from(v)
9132 .ok()
9133 .and_then(|x| x.try_into().ok())
9134 .ok_or_else(|| {
9135 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9136 })
9137 }
9138
9139 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9140 where
9141 E: serde::de::Error,
9142 {
9143 i32::try_from(v)
9144 .ok()
9145 .and_then(|x| x.try_into().ok())
9146 .ok_or_else(|| {
9147 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9148 })
9149 }
9150
9151 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9152 where
9153 E: serde::de::Error,
9154 {
9155 match value {
9156 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
9157 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
9158 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
9159 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
9160 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9161 }
9162 }
9163 }
9164 deserializer.deserialize_any(GeneratedVisitor)
9165 }
9166}
9167impl serde::Serialize for ListActorStatesRequest {
9168 #[allow(deprecated)]
9169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9170 where
9171 S: serde::Serializer,
9172 {
9173 use serde::ser::SerializeStruct;
9174 let len = 0;
9175 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
9176 struct_ser.end()
9177 }
9178}
9179impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
9180 #[allow(deprecated)]
9181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9182 where
9183 D: serde::Deserializer<'de>,
9184 {
9185 const FIELDS: &[&str] = &[
9186 ];
9187
9188 #[allow(clippy::enum_variant_names)]
9189 enum GeneratedField {
9190 }
9191 impl<'de> serde::Deserialize<'de> for GeneratedField {
9192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9193 where
9194 D: serde::Deserializer<'de>,
9195 {
9196 struct GeneratedVisitor;
9197
9198 impl serde::de::Visitor<'_> for GeneratedVisitor {
9199 type Value = GeneratedField;
9200
9201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9202 write!(formatter, "expected one of: {:?}", &FIELDS)
9203 }
9204
9205 #[allow(unused_variables)]
9206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9207 where
9208 E: serde::de::Error,
9209 {
9210 Err(serde::de::Error::unknown_field(value, FIELDS))
9211 }
9212 }
9213 deserializer.deserialize_identifier(GeneratedVisitor)
9214 }
9215 }
9216 struct GeneratedVisitor;
9217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9218 type Value = ListActorStatesRequest;
9219
9220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9221 formatter.write_str("struct meta.ListActorStatesRequest")
9222 }
9223
9224 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
9225 where
9226 V: serde::de::MapAccess<'de>,
9227 {
9228 while map_.next_key::<GeneratedField>()?.is_some() {
9229 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9230 }
9231 Ok(ListActorStatesRequest {
9232 })
9233 }
9234 }
9235 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
9236 }
9237}
9238impl serde::Serialize for ListActorStatesResponse {
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 mut len = 0;
9246 if !self.states.is_empty() {
9247 len += 1;
9248 }
9249 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
9250 if !self.states.is_empty() {
9251 struct_ser.serialize_field("states", &self.states)?;
9252 }
9253 struct_ser.end()
9254 }
9255}
9256impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
9257 #[allow(deprecated)]
9258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9259 where
9260 D: serde::Deserializer<'de>,
9261 {
9262 const FIELDS: &[&str] = &[
9263 "states",
9264 ];
9265
9266 #[allow(clippy::enum_variant_names)]
9267 enum GeneratedField {
9268 States,
9269 }
9270 impl<'de> serde::Deserialize<'de> for GeneratedField {
9271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9272 where
9273 D: serde::Deserializer<'de>,
9274 {
9275 struct GeneratedVisitor;
9276
9277 impl serde::de::Visitor<'_> for GeneratedVisitor {
9278 type Value = GeneratedField;
9279
9280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9281 write!(formatter, "expected one of: {:?}", &FIELDS)
9282 }
9283
9284 #[allow(unused_variables)]
9285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9286 where
9287 E: serde::de::Error,
9288 {
9289 match value {
9290 "states" => Ok(GeneratedField::States),
9291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9292 }
9293 }
9294 }
9295 deserializer.deserialize_identifier(GeneratedVisitor)
9296 }
9297 }
9298 struct GeneratedVisitor;
9299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9300 type Value = ListActorStatesResponse;
9301
9302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9303 formatter.write_str("struct meta.ListActorStatesResponse")
9304 }
9305
9306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
9307 where
9308 V: serde::de::MapAccess<'de>,
9309 {
9310 let mut states__ = None;
9311 while let Some(k) = map_.next_key()? {
9312 match k {
9313 GeneratedField::States => {
9314 if states__.is_some() {
9315 return Err(serde::de::Error::duplicate_field("states"));
9316 }
9317 states__ = Some(map_.next_value()?);
9318 }
9319 }
9320 }
9321 Ok(ListActorStatesResponse {
9322 states: states__.unwrap_or_default(),
9323 })
9324 }
9325 }
9326 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
9327 }
9328}
9329impl serde::Serialize for list_actor_states_response::ActorState {
9330 #[allow(deprecated)]
9331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9332 where
9333 S: serde::Serializer,
9334 {
9335 use serde::ser::SerializeStruct;
9336 let mut len = 0;
9337 if self.actor_id != 0 {
9338 len += 1;
9339 }
9340 if self.fragment_id != 0 {
9341 len += 1;
9342 }
9343 if self.worker_id != 0 {
9344 len += 1;
9345 }
9346 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
9347 if self.actor_id != 0 {
9348 struct_ser.serialize_field("actorId", &self.actor_id)?;
9349 }
9350 if self.fragment_id != 0 {
9351 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9352 }
9353 if self.worker_id != 0 {
9354 struct_ser.serialize_field("workerId", &self.worker_id)?;
9355 }
9356 struct_ser.end()
9357 }
9358}
9359impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
9360 #[allow(deprecated)]
9361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9362 where
9363 D: serde::Deserializer<'de>,
9364 {
9365 const FIELDS: &[&str] = &[
9366 "actor_id",
9367 "actorId",
9368 "fragment_id",
9369 "fragmentId",
9370 "worker_id",
9371 "workerId",
9372 ];
9373
9374 #[allow(clippy::enum_variant_names)]
9375 enum GeneratedField {
9376 ActorId,
9377 FragmentId,
9378 WorkerId,
9379 }
9380 impl<'de> serde::Deserialize<'de> for GeneratedField {
9381 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9382 where
9383 D: serde::Deserializer<'de>,
9384 {
9385 struct GeneratedVisitor;
9386
9387 impl serde::de::Visitor<'_> for GeneratedVisitor {
9388 type Value = GeneratedField;
9389
9390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9391 write!(formatter, "expected one of: {:?}", &FIELDS)
9392 }
9393
9394 #[allow(unused_variables)]
9395 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9396 where
9397 E: serde::de::Error,
9398 {
9399 match value {
9400 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9401 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9402 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
9403 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9404 }
9405 }
9406 }
9407 deserializer.deserialize_identifier(GeneratedVisitor)
9408 }
9409 }
9410 struct GeneratedVisitor;
9411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9412 type Value = list_actor_states_response::ActorState;
9413
9414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9415 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
9416 }
9417
9418 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
9419 where
9420 V: serde::de::MapAccess<'de>,
9421 {
9422 let mut actor_id__ = None;
9423 let mut fragment_id__ = None;
9424 let mut worker_id__ = None;
9425 while let Some(k) = map_.next_key()? {
9426 match k {
9427 GeneratedField::ActorId => {
9428 if actor_id__.is_some() {
9429 return Err(serde::de::Error::duplicate_field("actorId"));
9430 }
9431 actor_id__ =
9432 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9433 ;
9434 }
9435 GeneratedField::FragmentId => {
9436 if fragment_id__.is_some() {
9437 return Err(serde::de::Error::duplicate_field("fragmentId"));
9438 }
9439 fragment_id__ =
9440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9441 ;
9442 }
9443 GeneratedField::WorkerId => {
9444 if worker_id__.is_some() {
9445 return Err(serde::de::Error::duplicate_field("workerId"));
9446 }
9447 worker_id__ =
9448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9449 ;
9450 }
9451 }
9452 }
9453 Ok(list_actor_states_response::ActorState {
9454 actor_id: actor_id__.unwrap_or_default(),
9455 fragment_id: fragment_id__.unwrap_or_default(),
9456 worker_id: worker_id__.unwrap_or_default(),
9457 })
9458 }
9459 }
9460 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
9461 }
9462}
9463impl serde::Serialize for ListAllNodesRequest {
9464 #[allow(deprecated)]
9465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9466 where
9467 S: serde::Serializer,
9468 {
9469 use serde::ser::SerializeStruct;
9470 let mut len = 0;
9471 if self.worker_type.is_some() {
9472 len += 1;
9473 }
9474 if self.include_starting_nodes {
9475 len += 1;
9476 }
9477 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9478 if let Some(v) = self.worker_type.as_ref() {
9479 let v = super::common::WorkerType::try_from(*v)
9480 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9481 struct_ser.serialize_field("workerType", &v)?;
9482 }
9483 if self.include_starting_nodes {
9484 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9485 }
9486 struct_ser.end()
9487 }
9488}
9489impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9490 #[allow(deprecated)]
9491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9492 where
9493 D: serde::Deserializer<'de>,
9494 {
9495 const FIELDS: &[&str] = &[
9496 "worker_type",
9497 "workerType",
9498 "include_starting_nodes",
9499 "includeStartingNodes",
9500 ];
9501
9502 #[allow(clippy::enum_variant_names)]
9503 enum GeneratedField {
9504 WorkerType,
9505 IncludeStartingNodes,
9506 }
9507 impl<'de> serde::Deserialize<'de> for GeneratedField {
9508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9509 where
9510 D: serde::Deserializer<'de>,
9511 {
9512 struct GeneratedVisitor;
9513
9514 impl serde::de::Visitor<'_> for GeneratedVisitor {
9515 type Value = GeneratedField;
9516
9517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9518 write!(formatter, "expected one of: {:?}", &FIELDS)
9519 }
9520
9521 #[allow(unused_variables)]
9522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9523 where
9524 E: serde::de::Error,
9525 {
9526 match value {
9527 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9528 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9530 }
9531 }
9532 }
9533 deserializer.deserialize_identifier(GeneratedVisitor)
9534 }
9535 }
9536 struct GeneratedVisitor;
9537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9538 type Value = ListAllNodesRequest;
9539
9540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9541 formatter.write_str("struct meta.ListAllNodesRequest")
9542 }
9543
9544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9545 where
9546 V: serde::de::MapAccess<'de>,
9547 {
9548 let mut worker_type__ = None;
9549 let mut include_starting_nodes__ = None;
9550 while let Some(k) = map_.next_key()? {
9551 match k {
9552 GeneratedField::WorkerType => {
9553 if worker_type__.is_some() {
9554 return Err(serde::de::Error::duplicate_field("workerType"));
9555 }
9556 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9557 }
9558 GeneratedField::IncludeStartingNodes => {
9559 if include_starting_nodes__.is_some() {
9560 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9561 }
9562 include_starting_nodes__ = Some(map_.next_value()?);
9563 }
9564 }
9565 }
9566 Ok(ListAllNodesRequest {
9567 worker_type: worker_type__,
9568 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9569 })
9570 }
9571 }
9572 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9573 }
9574}
9575impl serde::Serialize for ListAllNodesResponse {
9576 #[allow(deprecated)]
9577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9578 where
9579 S: serde::Serializer,
9580 {
9581 use serde::ser::SerializeStruct;
9582 let mut len = 0;
9583 if self.status.is_some() {
9584 len += 1;
9585 }
9586 if !self.nodes.is_empty() {
9587 len += 1;
9588 }
9589 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9590 if let Some(v) = self.status.as_ref() {
9591 struct_ser.serialize_field("status", v)?;
9592 }
9593 if !self.nodes.is_empty() {
9594 struct_ser.serialize_field("nodes", &self.nodes)?;
9595 }
9596 struct_ser.end()
9597 }
9598}
9599impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9600 #[allow(deprecated)]
9601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9602 where
9603 D: serde::Deserializer<'de>,
9604 {
9605 const FIELDS: &[&str] = &[
9606 "status",
9607 "nodes",
9608 ];
9609
9610 #[allow(clippy::enum_variant_names)]
9611 enum GeneratedField {
9612 Status,
9613 Nodes,
9614 }
9615 impl<'de> serde::Deserialize<'de> for GeneratedField {
9616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9617 where
9618 D: serde::Deserializer<'de>,
9619 {
9620 struct GeneratedVisitor;
9621
9622 impl serde::de::Visitor<'_> for GeneratedVisitor {
9623 type Value = GeneratedField;
9624
9625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9626 write!(formatter, "expected one of: {:?}", &FIELDS)
9627 }
9628
9629 #[allow(unused_variables)]
9630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9631 where
9632 E: serde::de::Error,
9633 {
9634 match value {
9635 "status" => Ok(GeneratedField::Status),
9636 "nodes" => Ok(GeneratedField::Nodes),
9637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9638 }
9639 }
9640 }
9641 deserializer.deserialize_identifier(GeneratedVisitor)
9642 }
9643 }
9644 struct GeneratedVisitor;
9645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9646 type Value = ListAllNodesResponse;
9647
9648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9649 formatter.write_str("struct meta.ListAllNodesResponse")
9650 }
9651
9652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9653 where
9654 V: serde::de::MapAccess<'de>,
9655 {
9656 let mut status__ = None;
9657 let mut nodes__ = None;
9658 while let Some(k) = map_.next_key()? {
9659 match k {
9660 GeneratedField::Status => {
9661 if status__.is_some() {
9662 return Err(serde::de::Error::duplicate_field("status"));
9663 }
9664 status__ = map_.next_value()?;
9665 }
9666 GeneratedField::Nodes => {
9667 if nodes__.is_some() {
9668 return Err(serde::de::Error::duplicate_field("nodes"));
9669 }
9670 nodes__ = Some(map_.next_value()?);
9671 }
9672 }
9673 }
9674 Ok(ListAllNodesResponse {
9675 status: status__,
9676 nodes: nodes__.unwrap_or_default(),
9677 })
9678 }
9679 }
9680 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9681 }
9682}
9683impl serde::Serialize for ListCdcProgressRequest {
9684 #[allow(deprecated)]
9685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9686 where
9687 S: serde::Serializer,
9688 {
9689 use serde::ser::SerializeStruct;
9690 let len = 0;
9691 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9692 struct_ser.end()
9693 }
9694}
9695impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9696 #[allow(deprecated)]
9697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9698 where
9699 D: serde::Deserializer<'de>,
9700 {
9701 const FIELDS: &[&str] = &[
9702 ];
9703
9704 #[allow(clippy::enum_variant_names)]
9705 enum GeneratedField {
9706 }
9707 impl<'de> serde::Deserialize<'de> for GeneratedField {
9708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9709 where
9710 D: serde::Deserializer<'de>,
9711 {
9712 struct GeneratedVisitor;
9713
9714 impl serde::de::Visitor<'_> for GeneratedVisitor {
9715 type Value = GeneratedField;
9716
9717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9718 write!(formatter, "expected one of: {:?}", &FIELDS)
9719 }
9720
9721 #[allow(unused_variables)]
9722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9723 where
9724 E: serde::de::Error,
9725 {
9726 Err(serde::de::Error::unknown_field(value, FIELDS))
9727 }
9728 }
9729 deserializer.deserialize_identifier(GeneratedVisitor)
9730 }
9731 }
9732 struct GeneratedVisitor;
9733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9734 type Value = ListCdcProgressRequest;
9735
9736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9737 formatter.write_str("struct meta.ListCdcProgressRequest")
9738 }
9739
9740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9741 where
9742 V: serde::de::MapAccess<'de>,
9743 {
9744 while map_.next_key::<GeneratedField>()?.is_some() {
9745 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9746 }
9747 Ok(ListCdcProgressRequest {
9748 })
9749 }
9750 }
9751 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9752 }
9753}
9754impl serde::Serialize for ListCdcProgressResponse {
9755 #[allow(deprecated)]
9756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9757 where
9758 S: serde::Serializer,
9759 {
9760 use serde::ser::SerializeStruct;
9761 let mut len = 0;
9762 if !self.cdc_progress.is_empty() {
9763 len += 1;
9764 }
9765 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9766 if !self.cdc_progress.is_empty() {
9767 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9768 }
9769 struct_ser.end()
9770 }
9771}
9772impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9773 #[allow(deprecated)]
9774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9775 where
9776 D: serde::Deserializer<'de>,
9777 {
9778 const FIELDS: &[&str] = &[
9779 "cdc_progress",
9780 "cdcProgress",
9781 ];
9782
9783 #[allow(clippy::enum_variant_names)]
9784 enum GeneratedField {
9785 CdcProgress,
9786 }
9787 impl<'de> serde::Deserialize<'de> for GeneratedField {
9788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9789 where
9790 D: serde::Deserializer<'de>,
9791 {
9792 struct GeneratedVisitor;
9793
9794 impl serde::de::Visitor<'_> for GeneratedVisitor {
9795 type Value = GeneratedField;
9796
9797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9798 write!(formatter, "expected one of: {:?}", &FIELDS)
9799 }
9800
9801 #[allow(unused_variables)]
9802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9803 where
9804 E: serde::de::Error,
9805 {
9806 match value {
9807 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9809 }
9810 }
9811 }
9812 deserializer.deserialize_identifier(GeneratedVisitor)
9813 }
9814 }
9815 struct GeneratedVisitor;
9816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9817 type Value = ListCdcProgressResponse;
9818
9819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9820 formatter.write_str("struct meta.ListCdcProgressResponse")
9821 }
9822
9823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
9824 where
9825 V: serde::de::MapAccess<'de>,
9826 {
9827 let mut cdc_progress__ = None;
9828 while let Some(k) = map_.next_key()? {
9829 match k {
9830 GeneratedField::CdcProgress => {
9831 if cdc_progress__.is_some() {
9832 return Err(serde::de::Error::duplicate_field("cdcProgress"));
9833 }
9834 cdc_progress__ = Some(
9835 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9836 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9837 );
9838 }
9839 }
9840 }
9841 Ok(ListCdcProgressResponse {
9842 cdc_progress: cdc_progress__.unwrap_or_default(),
9843 })
9844 }
9845 }
9846 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
9847 }
9848}
9849impl serde::Serialize for list_cdc_progress_response::CdcProgress {
9850 #[allow(deprecated)]
9851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9852 where
9853 S: serde::Serializer,
9854 {
9855 use serde::ser::SerializeStruct;
9856 let mut len = 0;
9857 if self.split_total_count != 0 {
9858 len += 1;
9859 }
9860 if self.split_backfilled_count != 0 {
9861 len += 1;
9862 }
9863 if self.split_completed_count != 0 {
9864 len += 1;
9865 }
9866 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
9867 if self.split_total_count != 0 {
9868 #[allow(clippy::needless_borrow)]
9869 #[allow(clippy::needless_borrows_for_generic_args)]
9870 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
9871 }
9872 if self.split_backfilled_count != 0 {
9873 #[allow(clippy::needless_borrow)]
9874 #[allow(clippy::needless_borrows_for_generic_args)]
9875 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
9876 }
9877 if self.split_completed_count != 0 {
9878 #[allow(clippy::needless_borrow)]
9879 #[allow(clippy::needless_borrows_for_generic_args)]
9880 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
9881 }
9882 struct_ser.end()
9883 }
9884}
9885impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
9886 #[allow(deprecated)]
9887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9888 where
9889 D: serde::Deserializer<'de>,
9890 {
9891 const FIELDS: &[&str] = &[
9892 "split_total_count",
9893 "splitTotalCount",
9894 "split_backfilled_count",
9895 "splitBackfilledCount",
9896 "split_completed_count",
9897 "splitCompletedCount",
9898 ];
9899
9900 #[allow(clippy::enum_variant_names)]
9901 enum GeneratedField {
9902 SplitTotalCount,
9903 SplitBackfilledCount,
9904 SplitCompletedCount,
9905 }
9906 impl<'de> serde::Deserialize<'de> for GeneratedField {
9907 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9908 where
9909 D: serde::Deserializer<'de>,
9910 {
9911 struct GeneratedVisitor;
9912
9913 impl serde::de::Visitor<'_> for GeneratedVisitor {
9914 type Value = GeneratedField;
9915
9916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9917 write!(formatter, "expected one of: {:?}", &FIELDS)
9918 }
9919
9920 #[allow(unused_variables)]
9921 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9922 where
9923 E: serde::de::Error,
9924 {
9925 match value {
9926 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
9927 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
9928 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
9929 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9930 }
9931 }
9932 }
9933 deserializer.deserialize_identifier(GeneratedVisitor)
9934 }
9935 }
9936 struct GeneratedVisitor;
9937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9938 type Value = list_cdc_progress_response::CdcProgress;
9939
9940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9941 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
9942 }
9943
9944 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
9945 where
9946 V: serde::de::MapAccess<'de>,
9947 {
9948 let mut split_total_count__ = None;
9949 let mut split_backfilled_count__ = None;
9950 let mut split_completed_count__ = None;
9951 while let Some(k) = map_.next_key()? {
9952 match k {
9953 GeneratedField::SplitTotalCount => {
9954 if split_total_count__.is_some() {
9955 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9956 }
9957 split_total_count__ =
9958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9959 ;
9960 }
9961 GeneratedField::SplitBackfilledCount => {
9962 if split_backfilled_count__.is_some() {
9963 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9964 }
9965 split_backfilled_count__ =
9966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9967 ;
9968 }
9969 GeneratedField::SplitCompletedCount => {
9970 if split_completed_count__.is_some() {
9971 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9972 }
9973 split_completed_count__ =
9974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9975 ;
9976 }
9977 }
9978 }
9979 Ok(list_cdc_progress_response::CdcProgress {
9980 split_total_count: split_total_count__.unwrap_or_default(),
9981 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9982 split_completed_count: split_completed_count__.unwrap_or_default(),
9983 })
9984 }
9985 }
9986 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9987 }
9988}
9989impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9990 #[allow(deprecated)]
9991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9992 where
9993 S: serde::Serializer,
9994 {
9995 use serde::ser::SerializeStruct;
9996 let mut len = 0;
9997 if self.include_node.is_some() {
9998 len += 1;
9999 }
10000 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
10001 if let Some(v) = self.include_node.as_ref() {
10002 struct_ser.serialize_field("includeNode", v)?;
10003 }
10004 struct_ser.end()
10005 }
10006}
10007impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
10008 #[allow(deprecated)]
10009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10010 where
10011 D: serde::Deserializer<'de>,
10012 {
10013 const FIELDS: &[&str] = &[
10014 "include_node",
10015 "includeNode",
10016 ];
10017
10018 #[allow(clippy::enum_variant_names)]
10019 enum GeneratedField {
10020 IncludeNode,
10021 }
10022 impl<'de> serde::Deserialize<'de> for GeneratedField {
10023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10024 where
10025 D: serde::Deserializer<'de>,
10026 {
10027 struct GeneratedVisitor;
10028
10029 impl serde::de::Visitor<'_> for GeneratedVisitor {
10030 type Value = GeneratedField;
10031
10032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10033 write!(formatter, "expected one of: {:?}", &FIELDS)
10034 }
10035
10036 #[allow(unused_variables)]
10037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10038 where
10039 E: serde::de::Error,
10040 {
10041 match value {
10042 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10043 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10044 }
10045 }
10046 }
10047 deserializer.deserialize_identifier(GeneratedVisitor)
10048 }
10049 }
10050 struct GeneratedVisitor;
10051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10052 type Value = ListCreatingFragmentDistributionRequest;
10053
10054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10055 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
10056 }
10057
10058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
10059 where
10060 V: serde::de::MapAccess<'de>,
10061 {
10062 let mut include_node__ = None;
10063 while let Some(k) = map_.next_key()? {
10064 match k {
10065 GeneratedField::IncludeNode => {
10066 if include_node__.is_some() {
10067 return Err(serde::de::Error::duplicate_field("includeNode"));
10068 }
10069 include_node__ = map_.next_value()?;
10070 }
10071 }
10072 }
10073 Ok(ListCreatingFragmentDistributionRequest {
10074 include_node: include_node__,
10075 })
10076 }
10077 }
10078 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10079 }
10080}
10081impl serde::Serialize for ListCreatingFragmentDistributionResponse {
10082 #[allow(deprecated)]
10083 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10084 where
10085 S: serde::Serializer,
10086 {
10087 use serde::ser::SerializeStruct;
10088 let mut len = 0;
10089 if !self.distributions.is_empty() {
10090 len += 1;
10091 }
10092 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
10093 if !self.distributions.is_empty() {
10094 struct_ser.serialize_field("distributions", &self.distributions)?;
10095 }
10096 struct_ser.end()
10097 }
10098}
10099impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
10100 #[allow(deprecated)]
10101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10102 where
10103 D: serde::Deserializer<'de>,
10104 {
10105 const FIELDS: &[&str] = &[
10106 "distributions",
10107 ];
10108
10109 #[allow(clippy::enum_variant_names)]
10110 enum GeneratedField {
10111 Distributions,
10112 }
10113 impl<'de> serde::Deserialize<'de> for GeneratedField {
10114 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10115 where
10116 D: serde::Deserializer<'de>,
10117 {
10118 struct GeneratedVisitor;
10119
10120 impl serde::de::Visitor<'_> for GeneratedVisitor {
10121 type Value = GeneratedField;
10122
10123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10124 write!(formatter, "expected one of: {:?}", &FIELDS)
10125 }
10126
10127 #[allow(unused_variables)]
10128 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10129 where
10130 E: serde::de::Error,
10131 {
10132 match value {
10133 "distributions" => Ok(GeneratedField::Distributions),
10134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10135 }
10136 }
10137 }
10138 deserializer.deserialize_identifier(GeneratedVisitor)
10139 }
10140 }
10141 struct GeneratedVisitor;
10142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10143 type Value = ListCreatingFragmentDistributionResponse;
10144
10145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10146 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
10147 }
10148
10149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
10150 where
10151 V: serde::de::MapAccess<'de>,
10152 {
10153 let mut distributions__ = None;
10154 while let Some(k) = map_.next_key()? {
10155 match k {
10156 GeneratedField::Distributions => {
10157 if distributions__.is_some() {
10158 return Err(serde::de::Error::duplicate_field("distributions"));
10159 }
10160 distributions__ = Some(map_.next_value()?);
10161 }
10162 }
10163 }
10164 Ok(ListCreatingFragmentDistributionResponse {
10165 distributions: distributions__.unwrap_or_default(),
10166 })
10167 }
10168 }
10169 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10170 }
10171}
10172impl serde::Serialize for ListEventLogRequest {
10173 #[allow(deprecated)]
10174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10175 where
10176 S: serde::Serializer,
10177 {
10178 use serde::ser::SerializeStruct;
10179 let len = 0;
10180 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
10181 struct_ser.end()
10182 }
10183}
10184impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
10185 #[allow(deprecated)]
10186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10187 where
10188 D: serde::Deserializer<'de>,
10189 {
10190 const FIELDS: &[&str] = &[
10191 ];
10192
10193 #[allow(clippy::enum_variant_names)]
10194 enum GeneratedField {
10195 }
10196 impl<'de> serde::Deserialize<'de> for GeneratedField {
10197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10198 where
10199 D: serde::Deserializer<'de>,
10200 {
10201 struct GeneratedVisitor;
10202
10203 impl serde::de::Visitor<'_> for GeneratedVisitor {
10204 type Value = GeneratedField;
10205
10206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10207 write!(formatter, "expected one of: {:?}", &FIELDS)
10208 }
10209
10210 #[allow(unused_variables)]
10211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10212 where
10213 E: serde::de::Error,
10214 {
10215 Err(serde::de::Error::unknown_field(value, FIELDS))
10216 }
10217 }
10218 deserializer.deserialize_identifier(GeneratedVisitor)
10219 }
10220 }
10221 struct GeneratedVisitor;
10222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10223 type Value = ListEventLogRequest;
10224
10225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10226 formatter.write_str("struct meta.ListEventLogRequest")
10227 }
10228
10229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
10230 where
10231 V: serde::de::MapAccess<'de>,
10232 {
10233 while map_.next_key::<GeneratedField>()?.is_some() {
10234 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10235 }
10236 Ok(ListEventLogRequest {
10237 })
10238 }
10239 }
10240 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
10241 }
10242}
10243impl serde::Serialize for ListEventLogResponse {
10244 #[allow(deprecated)]
10245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10246 where
10247 S: serde::Serializer,
10248 {
10249 use serde::ser::SerializeStruct;
10250 let mut len = 0;
10251 if !self.event_logs.is_empty() {
10252 len += 1;
10253 }
10254 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
10255 if !self.event_logs.is_empty() {
10256 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
10257 }
10258 struct_ser.end()
10259 }
10260}
10261impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
10262 #[allow(deprecated)]
10263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10264 where
10265 D: serde::Deserializer<'de>,
10266 {
10267 const FIELDS: &[&str] = &[
10268 "event_logs",
10269 "eventLogs",
10270 ];
10271
10272 #[allow(clippy::enum_variant_names)]
10273 enum GeneratedField {
10274 EventLogs,
10275 }
10276 impl<'de> serde::Deserialize<'de> for GeneratedField {
10277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10278 where
10279 D: serde::Deserializer<'de>,
10280 {
10281 struct GeneratedVisitor;
10282
10283 impl serde::de::Visitor<'_> for GeneratedVisitor {
10284 type Value = GeneratedField;
10285
10286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10287 write!(formatter, "expected one of: {:?}", &FIELDS)
10288 }
10289
10290 #[allow(unused_variables)]
10291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10292 where
10293 E: serde::de::Error,
10294 {
10295 match value {
10296 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
10297 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10298 }
10299 }
10300 }
10301 deserializer.deserialize_identifier(GeneratedVisitor)
10302 }
10303 }
10304 struct GeneratedVisitor;
10305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10306 type Value = ListEventLogResponse;
10307
10308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10309 formatter.write_str("struct meta.ListEventLogResponse")
10310 }
10311
10312 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
10313 where
10314 V: serde::de::MapAccess<'de>,
10315 {
10316 let mut event_logs__ = None;
10317 while let Some(k) = map_.next_key()? {
10318 match k {
10319 GeneratedField::EventLogs => {
10320 if event_logs__.is_some() {
10321 return Err(serde::de::Error::duplicate_field("eventLogs"));
10322 }
10323 event_logs__ = Some(map_.next_value()?);
10324 }
10325 }
10326 }
10327 Ok(ListEventLogResponse {
10328 event_logs: event_logs__.unwrap_or_default(),
10329 })
10330 }
10331 }
10332 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
10333 }
10334}
10335impl serde::Serialize for ListFragmentDistributionRequest {
10336 #[allow(deprecated)]
10337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10338 where
10339 S: serde::Serializer,
10340 {
10341 use serde::ser::SerializeStruct;
10342 let mut len = 0;
10343 if self.include_node.is_some() {
10344 len += 1;
10345 }
10346 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
10347 if let Some(v) = self.include_node.as_ref() {
10348 struct_ser.serialize_field("includeNode", v)?;
10349 }
10350 struct_ser.end()
10351 }
10352}
10353impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
10354 #[allow(deprecated)]
10355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10356 where
10357 D: serde::Deserializer<'de>,
10358 {
10359 const FIELDS: &[&str] = &[
10360 "include_node",
10361 "includeNode",
10362 ];
10363
10364 #[allow(clippy::enum_variant_names)]
10365 enum GeneratedField {
10366 IncludeNode,
10367 }
10368 impl<'de> serde::Deserialize<'de> for GeneratedField {
10369 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10370 where
10371 D: serde::Deserializer<'de>,
10372 {
10373 struct GeneratedVisitor;
10374
10375 impl serde::de::Visitor<'_> for GeneratedVisitor {
10376 type Value = GeneratedField;
10377
10378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10379 write!(formatter, "expected one of: {:?}", &FIELDS)
10380 }
10381
10382 #[allow(unused_variables)]
10383 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10384 where
10385 E: serde::de::Error,
10386 {
10387 match value {
10388 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10389 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10390 }
10391 }
10392 }
10393 deserializer.deserialize_identifier(GeneratedVisitor)
10394 }
10395 }
10396 struct GeneratedVisitor;
10397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10398 type Value = ListFragmentDistributionRequest;
10399
10400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10401 formatter.write_str("struct meta.ListFragmentDistributionRequest")
10402 }
10403
10404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
10405 where
10406 V: serde::de::MapAccess<'de>,
10407 {
10408 let mut include_node__ = None;
10409 while let Some(k) = map_.next_key()? {
10410 match k {
10411 GeneratedField::IncludeNode => {
10412 if include_node__.is_some() {
10413 return Err(serde::de::Error::duplicate_field("includeNode"));
10414 }
10415 include_node__ = map_.next_value()?;
10416 }
10417 }
10418 }
10419 Ok(ListFragmentDistributionRequest {
10420 include_node: include_node__,
10421 })
10422 }
10423 }
10424 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10425 }
10426}
10427impl serde::Serialize for ListFragmentDistributionResponse {
10428 #[allow(deprecated)]
10429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10430 where
10431 S: serde::Serializer,
10432 {
10433 use serde::ser::SerializeStruct;
10434 let mut len = 0;
10435 if !self.distributions.is_empty() {
10436 len += 1;
10437 }
10438 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
10439 if !self.distributions.is_empty() {
10440 struct_ser.serialize_field("distributions", &self.distributions)?;
10441 }
10442 struct_ser.end()
10443 }
10444}
10445impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
10446 #[allow(deprecated)]
10447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10448 where
10449 D: serde::Deserializer<'de>,
10450 {
10451 const FIELDS: &[&str] = &[
10452 "distributions",
10453 ];
10454
10455 #[allow(clippy::enum_variant_names)]
10456 enum GeneratedField {
10457 Distributions,
10458 }
10459 impl<'de> serde::Deserialize<'de> for GeneratedField {
10460 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10461 where
10462 D: serde::Deserializer<'de>,
10463 {
10464 struct GeneratedVisitor;
10465
10466 impl serde::de::Visitor<'_> for GeneratedVisitor {
10467 type Value = GeneratedField;
10468
10469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10470 write!(formatter, "expected one of: {:?}", &FIELDS)
10471 }
10472
10473 #[allow(unused_variables)]
10474 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10475 where
10476 E: serde::de::Error,
10477 {
10478 match value {
10479 "distributions" => Ok(GeneratedField::Distributions),
10480 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10481 }
10482 }
10483 }
10484 deserializer.deserialize_identifier(GeneratedVisitor)
10485 }
10486 }
10487 struct GeneratedVisitor;
10488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10489 type Value = ListFragmentDistributionResponse;
10490
10491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10492 formatter.write_str("struct meta.ListFragmentDistributionResponse")
10493 }
10494
10495 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
10496 where
10497 V: serde::de::MapAccess<'de>,
10498 {
10499 let mut distributions__ = None;
10500 while let Some(k) = map_.next_key()? {
10501 match k {
10502 GeneratedField::Distributions => {
10503 if distributions__.is_some() {
10504 return Err(serde::de::Error::duplicate_field("distributions"));
10505 }
10506 distributions__ = Some(map_.next_value()?);
10507 }
10508 }
10509 }
10510 Ok(ListFragmentDistributionResponse {
10511 distributions: distributions__.unwrap_or_default(),
10512 })
10513 }
10514 }
10515 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10516 }
10517}
10518impl serde::Serialize for ListIcebergCompactionStatusRequest {
10519 #[allow(deprecated)]
10520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10521 where
10522 S: serde::Serializer,
10523 {
10524 use serde::ser::SerializeStruct;
10525 let len = 0;
10526 let struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusRequest", len)?;
10527 struct_ser.end()
10528 }
10529}
10530impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusRequest {
10531 #[allow(deprecated)]
10532 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10533 where
10534 D: serde::Deserializer<'de>,
10535 {
10536 const FIELDS: &[&str] = &[
10537 ];
10538
10539 #[allow(clippy::enum_variant_names)]
10540 enum GeneratedField {
10541 }
10542 impl<'de> serde::Deserialize<'de> for GeneratedField {
10543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10544 where
10545 D: serde::Deserializer<'de>,
10546 {
10547 struct GeneratedVisitor;
10548
10549 impl serde::de::Visitor<'_> for GeneratedVisitor {
10550 type Value = GeneratedField;
10551
10552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10553 write!(formatter, "expected one of: {:?}", &FIELDS)
10554 }
10555
10556 #[allow(unused_variables)]
10557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10558 where
10559 E: serde::de::Error,
10560 {
10561 Err(serde::de::Error::unknown_field(value, FIELDS))
10562 }
10563 }
10564 deserializer.deserialize_identifier(GeneratedVisitor)
10565 }
10566 }
10567 struct GeneratedVisitor;
10568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10569 type Value = ListIcebergCompactionStatusRequest;
10570
10571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10572 formatter.write_str("struct meta.ListIcebergCompactionStatusRequest")
10573 }
10574
10575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusRequest, V::Error>
10576 where
10577 V: serde::de::MapAccess<'de>,
10578 {
10579 while map_.next_key::<GeneratedField>()?.is_some() {
10580 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10581 }
10582 Ok(ListIcebergCompactionStatusRequest {
10583 })
10584 }
10585 }
10586 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusRequest", FIELDS, GeneratedVisitor)
10587 }
10588}
10589impl serde::Serialize for ListIcebergCompactionStatusResponse {
10590 #[allow(deprecated)]
10591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10592 where
10593 S: serde::Serializer,
10594 {
10595 use serde::ser::SerializeStruct;
10596 let mut len = 0;
10597 if !self.statuses.is_empty() {
10598 len += 1;
10599 }
10600 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse", len)?;
10601 if !self.statuses.is_empty() {
10602 struct_ser.serialize_field("statuses", &self.statuses)?;
10603 }
10604 struct_ser.end()
10605 }
10606}
10607impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusResponse {
10608 #[allow(deprecated)]
10609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10610 where
10611 D: serde::Deserializer<'de>,
10612 {
10613 const FIELDS: &[&str] = &[
10614 "statuses",
10615 ];
10616
10617 #[allow(clippy::enum_variant_names)]
10618 enum GeneratedField {
10619 Statuses,
10620 }
10621 impl<'de> serde::Deserialize<'de> for GeneratedField {
10622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10623 where
10624 D: serde::Deserializer<'de>,
10625 {
10626 struct GeneratedVisitor;
10627
10628 impl serde::de::Visitor<'_> for GeneratedVisitor {
10629 type Value = GeneratedField;
10630
10631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10632 write!(formatter, "expected one of: {:?}", &FIELDS)
10633 }
10634
10635 #[allow(unused_variables)]
10636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10637 where
10638 E: serde::de::Error,
10639 {
10640 match value {
10641 "statuses" => Ok(GeneratedField::Statuses),
10642 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10643 }
10644 }
10645 }
10646 deserializer.deserialize_identifier(GeneratedVisitor)
10647 }
10648 }
10649 struct GeneratedVisitor;
10650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10651 type Value = ListIcebergCompactionStatusResponse;
10652
10653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10654 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse")
10655 }
10656
10657 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusResponse, V::Error>
10658 where
10659 V: serde::de::MapAccess<'de>,
10660 {
10661 let mut statuses__ = None;
10662 while let Some(k) = map_.next_key()? {
10663 match k {
10664 GeneratedField::Statuses => {
10665 if statuses__.is_some() {
10666 return Err(serde::de::Error::duplicate_field("statuses"));
10667 }
10668 statuses__ = Some(map_.next_value()?);
10669 }
10670 }
10671 }
10672 Ok(ListIcebergCompactionStatusResponse {
10673 statuses: statuses__.unwrap_or_default(),
10674 })
10675 }
10676 }
10677 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse", FIELDS, GeneratedVisitor)
10678 }
10679}
10680impl serde::Serialize for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10681 #[allow(deprecated)]
10682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10683 where
10684 S: serde::Serializer,
10685 {
10686 use serde::ser::SerializeStruct;
10687 let mut len = 0;
10688 if self.sink_id != 0 {
10689 len += 1;
10690 }
10691 if !self.task_type.is_empty() {
10692 len += 1;
10693 }
10694 if self.trigger_interval_sec != 0 {
10695 len += 1;
10696 }
10697 if self.trigger_snapshot_count != 0 {
10698 len += 1;
10699 }
10700 if !self.schedule_state.is_empty() {
10701 len += 1;
10702 }
10703 if self.next_compaction_after_sec.is_some() {
10704 len += 1;
10705 }
10706 if self.pending_snapshot_count.is_some() {
10707 len += 1;
10708 }
10709 if self.is_triggerable {
10710 len += 1;
10711 }
10712 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", len)?;
10713 if self.sink_id != 0 {
10714 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10715 }
10716 if !self.task_type.is_empty() {
10717 struct_ser.serialize_field("taskType", &self.task_type)?;
10718 }
10719 if self.trigger_interval_sec != 0 {
10720 #[allow(clippy::needless_borrow)]
10721 #[allow(clippy::needless_borrows_for_generic_args)]
10722 struct_ser.serialize_field("triggerIntervalSec", ToString::to_string(&self.trigger_interval_sec).as_str())?;
10723 }
10724 if self.trigger_snapshot_count != 0 {
10725 #[allow(clippy::needless_borrow)]
10726 #[allow(clippy::needless_borrows_for_generic_args)]
10727 struct_ser.serialize_field("triggerSnapshotCount", ToString::to_string(&self.trigger_snapshot_count).as_str())?;
10728 }
10729 if !self.schedule_state.is_empty() {
10730 struct_ser.serialize_field("scheduleState", &self.schedule_state)?;
10731 }
10732 if let Some(v) = self.next_compaction_after_sec.as_ref() {
10733 #[allow(clippy::needless_borrow)]
10734 #[allow(clippy::needless_borrows_for_generic_args)]
10735 struct_ser.serialize_field("nextCompactionAfterSec", ToString::to_string(&v).as_str())?;
10736 }
10737 if let Some(v) = self.pending_snapshot_count.as_ref() {
10738 #[allow(clippy::needless_borrow)]
10739 #[allow(clippy::needless_borrows_for_generic_args)]
10740 struct_ser.serialize_field("pendingSnapshotCount", ToString::to_string(&v).as_str())?;
10741 }
10742 if self.is_triggerable {
10743 struct_ser.serialize_field("isTriggerable", &self.is_triggerable)?;
10744 }
10745 struct_ser.end()
10746 }
10747}
10748impl<'de> serde::Deserialize<'de> for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10749 #[allow(deprecated)]
10750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10751 where
10752 D: serde::Deserializer<'de>,
10753 {
10754 const FIELDS: &[&str] = &[
10755 "sink_id",
10756 "sinkId",
10757 "task_type",
10758 "taskType",
10759 "trigger_interval_sec",
10760 "triggerIntervalSec",
10761 "trigger_snapshot_count",
10762 "triggerSnapshotCount",
10763 "schedule_state",
10764 "scheduleState",
10765 "next_compaction_after_sec",
10766 "nextCompactionAfterSec",
10767 "pending_snapshot_count",
10768 "pendingSnapshotCount",
10769 "is_triggerable",
10770 "isTriggerable",
10771 ];
10772
10773 #[allow(clippy::enum_variant_names)]
10774 enum GeneratedField {
10775 SinkId,
10776 TaskType,
10777 TriggerIntervalSec,
10778 TriggerSnapshotCount,
10779 ScheduleState,
10780 NextCompactionAfterSec,
10781 PendingSnapshotCount,
10782 IsTriggerable,
10783 }
10784 impl<'de> serde::Deserialize<'de> for GeneratedField {
10785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10786 where
10787 D: serde::Deserializer<'de>,
10788 {
10789 struct GeneratedVisitor;
10790
10791 impl serde::de::Visitor<'_> for GeneratedVisitor {
10792 type Value = GeneratedField;
10793
10794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10795 write!(formatter, "expected one of: {:?}", &FIELDS)
10796 }
10797
10798 #[allow(unused_variables)]
10799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10800 where
10801 E: serde::de::Error,
10802 {
10803 match value {
10804 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10805 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
10806 "triggerIntervalSec" | "trigger_interval_sec" => Ok(GeneratedField::TriggerIntervalSec),
10807 "triggerSnapshotCount" | "trigger_snapshot_count" => Ok(GeneratedField::TriggerSnapshotCount),
10808 "scheduleState" | "schedule_state" => Ok(GeneratedField::ScheduleState),
10809 "nextCompactionAfterSec" | "next_compaction_after_sec" => Ok(GeneratedField::NextCompactionAfterSec),
10810 "pendingSnapshotCount" | "pending_snapshot_count" => Ok(GeneratedField::PendingSnapshotCount),
10811 "isTriggerable" | "is_triggerable" => Ok(GeneratedField::IsTriggerable),
10812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10813 }
10814 }
10815 }
10816 deserializer.deserialize_identifier(GeneratedVisitor)
10817 }
10818 }
10819 struct GeneratedVisitor;
10820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10821 type Value = list_iceberg_compaction_status_response::IcebergCompactionStatus;
10822
10823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10824 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus")
10825 }
10826
10827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_compaction_status_response::IcebergCompactionStatus, V::Error>
10828 where
10829 V: serde::de::MapAccess<'de>,
10830 {
10831 let mut sink_id__ = None;
10832 let mut task_type__ = None;
10833 let mut trigger_interval_sec__ = None;
10834 let mut trigger_snapshot_count__ = None;
10835 let mut schedule_state__ = None;
10836 let mut next_compaction_after_sec__ = None;
10837 let mut pending_snapshot_count__ = None;
10838 let mut is_triggerable__ = None;
10839 while let Some(k) = map_.next_key()? {
10840 match k {
10841 GeneratedField::SinkId => {
10842 if sink_id__.is_some() {
10843 return Err(serde::de::Error::duplicate_field("sinkId"));
10844 }
10845 sink_id__ =
10846 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10847 ;
10848 }
10849 GeneratedField::TaskType => {
10850 if task_type__.is_some() {
10851 return Err(serde::de::Error::duplicate_field("taskType"));
10852 }
10853 task_type__ = Some(map_.next_value()?);
10854 }
10855 GeneratedField::TriggerIntervalSec => {
10856 if trigger_interval_sec__.is_some() {
10857 return Err(serde::de::Error::duplicate_field("triggerIntervalSec"));
10858 }
10859 trigger_interval_sec__ =
10860 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10861 ;
10862 }
10863 GeneratedField::TriggerSnapshotCount => {
10864 if trigger_snapshot_count__.is_some() {
10865 return Err(serde::de::Error::duplicate_field("triggerSnapshotCount"));
10866 }
10867 trigger_snapshot_count__ =
10868 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10869 ;
10870 }
10871 GeneratedField::ScheduleState => {
10872 if schedule_state__.is_some() {
10873 return Err(serde::de::Error::duplicate_field("scheduleState"));
10874 }
10875 schedule_state__ = Some(map_.next_value()?);
10876 }
10877 GeneratedField::NextCompactionAfterSec => {
10878 if next_compaction_after_sec__.is_some() {
10879 return Err(serde::de::Error::duplicate_field("nextCompactionAfterSec"));
10880 }
10881 next_compaction_after_sec__ =
10882 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10883 ;
10884 }
10885 GeneratedField::PendingSnapshotCount => {
10886 if pending_snapshot_count__.is_some() {
10887 return Err(serde::de::Error::duplicate_field("pendingSnapshotCount"));
10888 }
10889 pending_snapshot_count__ =
10890 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10891 ;
10892 }
10893 GeneratedField::IsTriggerable => {
10894 if is_triggerable__.is_some() {
10895 return Err(serde::de::Error::duplicate_field("isTriggerable"));
10896 }
10897 is_triggerable__ = Some(map_.next_value()?);
10898 }
10899 }
10900 }
10901 Ok(list_iceberg_compaction_status_response::IcebergCompactionStatus {
10902 sink_id: sink_id__.unwrap_or_default(),
10903 task_type: task_type__.unwrap_or_default(),
10904 trigger_interval_sec: trigger_interval_sec__.unwrap_or_default(),
10905 trigger_snapshot_count: trigger_snapshot_count__.unwrap_or_default(),
10906 schedule_state: schedule_state__.unwrap_or_default(),
10907 next_compaction_after_sec: next_compaction_after_sec__,
10908 pending_snapshot_count: pending_snapshot_count__,
10909 is_triggerable: is_triggerable__.unwrap_or_default(),
10910 })
10911 }
10912 }
10913 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", FIELDS, GeneratedVisitor)
10914 }
10915}
10916impl serde::Serialize for ListIcebergTablesRequest {
10917 #[allow(deprecated)]
10918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10919 where
10920 S: serde::Serializer,
10921 {
10922 use serde::ser::SerializeStruct;
10923 let len = 0;
10924 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
10925 struct_ser.end()
10926 }
10927}
10928impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
10929 #[allow(deprecated)]
10930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10931 where
10932 D: serde::Deserializer<'de>,
10933 {
10934 const FIELDS: &[&str] = &[
10935 ];
10936
10937 #[allow(clippy::enum_variant_names)]
10938 enum GeneratedField {
10939 }
10940 impl<'de> serde::Deserialize<'de> for GeneratedField {
10941 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10942 where
10943 D: serde::Deserializer<'de>,
10944 {
10945 struct GeneratedVisitor;
10946
10947 impl serde::de::Visitor<'_> for GeneratedVisitor {
10948 type Value = GeneratedField;
10949
10950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10951 write!(formatter, "expected one of: {:?}", &FIELDS)
10952 }
10953
10954 #[allow(unused_variables)]
10955 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10956 where
10957 E: serde::de::Error,
10958 {
10959 Err(serde::de::Error::unknown_field(value, FIELDS))
10960 }
10961 }
10962 deserializer.deserialize_identifier(GeneratedVisitor)
10963 }
10964 }
10965 struct GeneratedVisitor;
10966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10967 type Value = ListIcebergTablesRequest;
10968
10969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10970 formatter.write_str("struct meta.ListIcebergTablesRequest")
10971 }
10972
10973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
10974 where
10975 V: serde::de::MapAccess<'de>,
10976 {
10977 while map_.next_key::<GeneratedField>()?.is_some() {
10978 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10979 }
10980 Ok(ListIcebergTablesRequest {
10981 })
10982 }
10983 }
10984 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
10985 }
10986}
10987impl serde::Serialize for ListIcebergTablesResponse {
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 mut len = 0;
10995 if !self.iceberg_tables.is_empty() {
10996 len += 1;
10997 }
10998 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
10999 if !self.iceberg_tables.is_empty() {
11000 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
11001 }
11002 struct_ser.end()
11003 }
11004}
11005impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
11006 #[allow(deprecated)]
11007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11008 where
11009 D: serde::Deserializer<'de>,
11010 {
11011 const FIELDS: &[&str] = &[
11012 "iceberg_tables",
11013 "icebergTables",
11014 ];
11015
11016 #[allow(clippy::enum_variant_names)]
11017 enum GeneratedField {
11018 IcebergTables,
11019 }
11020 impl<'de> serde::Deserialize<'de> for GeneratedField {
11021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11022 where
11023 D: serde::Deserializer<'de>,
11024 {
11025 struct GeneratedVisitor;
11026
11027 impl serde::de::Visitor<'_> for GeneratedVisitor {
11028 type Value = GeneratedField;
11029
11030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11031 write!(formatter, "expected one of: {:?}", &FIELDS)
11032 }
11033
11034 #[allow(unused_variables)]
11035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11036 where
11037 E: serde::de::Error,
11038 {
11039 match value {
11040 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
11041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11042 }
11043 }
11044 }
11045 deserializer.deserialize_identifier(GeneratedVisitor)
11046 }
11047 }
11048 struct GeneratedVisitor;
11049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11050 type Value = ListIcebergTablesResponse;
11051
11052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11053 formatter.write_str("struct meta.ListIcebergTablesResponse")
11054 }
11055
11056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
11057 where
11058 V: serde::de::MapAccess<'de>,
11059 {
11060 let mut iceberg_tables__ = None;
11061 while let Some(k) = map_.next_key()? {
11062 match k {
11063 GeneratedField::IcebergTables => {
11064 if iceberg_tables__.is_some() {
11065 return Err(serde::de::Error::duplicate_field("icebergTables"));
11066 }
11067 iceberg_tables__ = Some(map_.next_value()?);
11068 }
11069 }
11070 }
11071 Ok(ListIcebergTablesResponse {
11072 iceberg_tables: iceberg_tables__.unwrap_or_default(),
11073 })
11074 }
11075 }
11076 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
11077 }
11078}
11079impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
11080 #[allow(deprecated)]
11081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11082 where
11083 S: serde::Serializer,
11084 {
11085 use serde::ser::SerializeStruct;
11086 let mut len = 0;
11087 if !self.catalog_name.is_empty() {
11088 len += 1;
11089 }
11090 if !self.table_namespace.is_empty() {
11091 len += 1;
11092 }
11093 if !self.table_name.is_empty() {
11094 len += 1;
11095 }
11096 if self.metadata_location.is_some() {
11097 len += 1;
11098 }
11099 if self.previous_metadata_location.is_some() {
11100 len += 1;
11101 }
11102 if self.iceberg_type.is_some() {
11103 len += 1;
11104 }
11105 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
11106 if !self.catalog_name.is_empty() {
11107 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
11108 }
11109 if !self.table_namespace.is_empty() {
11110 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
11111 }
11112 if !self.table_name.is_empty() {
11113 struct_ser.serialize_field("tableName", &self.table_name)?;
11114 }
11115 if let Some(v) = self.metadata_location.as_ref() {
11116 struct_ser.serialize_field("metadataLocation", v)?;
11117 }
11118 if let Some(v) = self.previous_metadata_location.as_ref() {
11119 struct_ser.serialize_field("previousMetadataLocation", v)?;
11120 }
11121 if let Some(v) = self.iceberg_type.as_ref() {
11122 struct_ser.serialize_field("icebergType", v)?;
11123 }
11124 struct_ser.end()
11125 }
11126}
11127impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
11128 #[allow(deprecated)]
11129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11130 where
11131 D: serde::Deserializer<'de>,
11132 {
11133 const FIELDS: &[&str] = &[
11134 "catalog_name",
11135 "catalogName",
11136 "table_namespace",
11137 "tableNamespace",
11138 "table_name",
11139 "tableName",
11140 "metadata_location",
11141 "metadataLocation",
11142 "previous_metadata_location",
11143 "previousMetadataLocation",
11144 "iceberg_type",
11145 "icebergType",
11146 ];
11147
11148 #[allow(clippy::enum_variant_names)]
11149 enum GeneratedField {
11150 CatalogName,
11151 TableNamespace,
11152 TableName,
11153 MetadataLocation,
11154 PreviousMetadataLocation,
11155 IcebergType,
11156 }
11157 impl<'de> serde::Deserialize<'de> for GeneratedField {
11158 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11159 where
11160 D: serde::Deserializer<'de>,
11161 {
11162 struct GeneratedVisitor;
11163
11164 impl serde::de::Visitor<'_> for GeneratedVisitor {
11165 type Value = GeneratedField;
11166
11167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11168 write!(formatter, "expected one of: {:?}", &FIELDS)
11169 }
11170
11171 #[allow(unused_variables)]
11172 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11173 where
11174 E: serde::de::Error,
11175 {
11176 match value {
11177 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
11178 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
11179 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11180 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
11181 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
11182 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
11183 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11184 }
11185 }
11186 }
11187 deserializer.deserialize_identifier(GeneratedVisitor)
11188 }
11189 }
11190 struct GeneratedVisitor;
11191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11192 type Value = list_iceberg_tables_response::IcebergTable;
11193
11194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11195 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
11196 }
11197
11198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
11199 where
11200 V: serde::de::MapAccess<'de>,
11201 {
11202 let mut catalog_name__ = None;
11203 let mut table_namespace__ = None;
11204 let mut table_name__ = None;
11205 let mut metadata_location__ = None;
11206 let mut previous_metadata_location__ = None;
11207 let mut iceberg_type__ = None;
11208 while let Some(k) = map_.next_key()? {
11209 match k {
11210 GeneratedField::CatalogName => {
11211 if catalog_name__.is_some() {
11212 return Err(serde::de::Error::duplicate_field("catalogName"));
11213 }
11214 catalog_name__ = Some(map_.next_value()?);
11215 }
11216 GeneratedField::TableNamespace => {
11217 if table_namespace__.is_some() {
11218 return Err(serde::de::Error::duplicate_field("tableNamespace"));
11219 }
11220 table_namespace__ = Some(map_.next_value()?);
11221 }
11222 GeneratedField::TableName => {
11223 if table_name__.is_some() {
11224 return Err(serde::de::Error::duplicate_field("tableName"));
11225 }
11226 table_name__ = Some(map_.next_value()?);
11227 }
11228 GeneratedField::MetadataLocation => {
11229 if metadata_location__.is_some() {
11230 return Err(serde::de::Error::duplicate_field("metadataLocation"));
11231 }
11232 metadata_location__ = map_.next_value()?;
11233 }
11234 GeneratedField::PreviousMetadataLocation => {
11235 if previous_metadata_location__.is_some() {
11236 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
11237 }
11238 previous_metadata_location__ = map_.next_value()?;
11239 }
11240 GeneratedField::IcebergType => {
11241 if iceberg_type__.is_some() {
11242 return Err(serde::de::Error::duplicate_field("icebergType"));
11243 }
11244 iceberg_type__ = map_.next_value()?;
11245 }
11246 }
11247 }
11248 Ok(list_iceberg_tables_response::IcebergTable {
11249 catalog_name: catalog_name__.unwrap_or_default(),
11250 table_namespace: table_namespace__.unwrap_or_default(),
11251 table_name: table_name__.unwrap_or_default(),
11252 metadata_location: metadata_location__,
11253 previous_metadata_location: previous_metadata_location__,
11254 iceberg_type: iceberg_type__,
11255 })
11256 }
11257 }
11258 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
11259 }
11260}
11261impl serde::Serialize for ListRateLimitsRequest {
11262 #[allow(deprecated)]
11263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11264 where
11265 S: serde::Serializer,
11266 {
11267 use serde::ser::SerializeStruct;
11268 let len = 0;
11269 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
11270 struct_ser.end()
11271 }
11272}
11273impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
11274 #[allow(deprecated)]
11275 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11276 where
11277 D: serde::Deserializer<'de>,
11278 {
11279 const FIELDS: &[&str] = &[
11280 ];
11281
11282 #[allow(clippy::enum_variant_names)]
11283 enum GeneratedField {
11284 }
11285 impl<'de> serde::Deserialize<'de> for GeneratedField {
11286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11287 where
11288 D: serde::Deserializer<'de>,
11289 {
11290 struct GeneratedVisitor;
11291
11292 impl serde::de::Visitor<'_> for GeneratedVisitor {
11293 type Value = GeneratedField;
11294
11295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11296 write!(formatter, "expected one of: {:?}", &FIELDS)
11297 }
11298
11299 #[allow(unused_variables)]
11300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11301 where
11302 E: serde::de::Error,
11303 {
11304 Err(serde::de::Error::unknown_field(value, FIELDS))
11305 }
11306 }
11307 deserializer.deserialize_identifier(GeneratedVisitor)
11308 }
11309 }
11310 struct GeneratedVisitor;
11311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11312 type Value = ListRateLimitsRequest;
11313
11314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11315 formatter.write_str("struct meta.ListRateLimitsRequest")
11316 }
11317
11318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
11319 where
11320 V: serde::de::MapAccess<'de>,
11321 {
11322 while map_.next_key::<GeneratedField>()?.is_some() {
11323 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11324 }
11325 Ok(ListRateLimitsRequest {
11326 })
11327 }
11328 }
11329 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
11330 }
11331}
11332impl serde::Serialize for ListRateLimitsResponse {
11333 #[allow(deprecated)]
11334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11335 where
11336 S: serde::Serializer,
11337 {
11338 use serde::ser::SerializeStruct;
11339 let mut len = 0;
11340 if !self.rate_limits.is_empty() {
11341 len += 1;
11342 }
11343 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
11344 if !self.rate_limits.is_empty() {
11345 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
11346 }
11347 struct_ser.end()
11348 }
11349}
11350impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
11351 #[allow(deprecated)]
11352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11353 where
11354 D: serde::Deserializer<'de>,
11355 {
11356 const FIELDS: &[&str] = &[
11357 "rate_limits",
11358 "rateLimits",
11359 ];
11360
11361 #[allow(clippy::enum_variant_names)]
11362 enum GeneratedField {
11363 RateLimits,
11364 }
11365 impl<'de> serde::Deserialize<'de> for GeneratedField {
11366 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11367 where
11368 D: serde::Deserializer<'de>,
11369 {
11370 struct GeneratedVisitor;
11371
11372 impl serde::de::Visitor<'_> for GeneratedVisitor {
11373 type Value = GeneratedField;
11374
11375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11376 write!(formatter, "expected one of: {:?}", &FIELDS)
11377 }
11378
11379 #[allow(unused_variables)]
11380 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11381 where
11382 E: serde::de::Error,
11383 {
11384 match value {
11385 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
11386 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11387 }
11388 }
11389 }
11390 deserializer.deserialize_identifier(GeneratedVisitor)
11391 }
11392 }
11393 struct GeneratedVisitor;
11394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11395 type Value = ListRateLimitsResponse;
11396
11397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11398 formatter.write_str("struct meta.ListRateLimitsResponse")
11399 }
11400
11401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
11402 where
11403 V: serde::de::MapAccess<'de>,
11404 {
11405 let mut rate_limits__ = None;
11406 while let Some(k) = map_.next_key()? {
11407 match k {
11408 GeneratedField::RateLimits => {
11409 if rate_limits__.is_some() {
11410 return Err(serde::de::Error::duplicate_field("rateLimits"));
11411 }
11412 rate_limits__ = Some(map_.next_value()?);
11413 }
11414 }
11415 }
11416 Ok(ListRateLimitsResponse {
11417 rate_limits: rate_limits__.unwrap_or_default(),
11418 })
11419 }
11420 }
11421 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
11422 }
11423}
11424impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
11425 #[allow(deprecated)]
11426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11427 where
11428 S: serde::Serializer,
11429 {
11430 use serde::ser::SerializeStruct;
11431 let mut len = 0;
11432 if self.fragment_id != 0 {
11433 len += 1;
11434 }
11435 if self.job_id != 0 {
11436 len += 1;
11437 }
11438 if self.fragment_type_mask != 0 {
11439 len += 1;
11440 }
11441 if self.rate_limit != 0 {
11442 len += 1;
11443 }
11444 if !self.node_name.is_empty() {
11445 len += 1;
11446 }
11447 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
11448 if self.fragment_id != 0 {
11449 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11450 }
11451 if self.job_id != 0 {
11452 struct_ser.serialize_field("jobId", &self.job_id)?;
11453 }
11454 if self.fragment_type_mask != 0 {
11455 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11456 }
11457 if self.rate_limit != 0 {
11458 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
11459 }
11460 if !self.node_name.is_empty() {
11461 struct_ser.serialize_field("nodeName", &self.node_name)?;
11462 }
11463 struct_ser.end()
11464 }
11465}
11466impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
11467 #[allow(deprecated)]
11468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11469 where
11470 D: serde::Deserializer<'de>,
11471 {
11472 const FIELDS: &[&str] = &[
11473 "fragment_id",
11474 "fragmentId",
11475 "job_id",
11476 "jobId",
11477 "fragment_type_mask",
11478 "fragmentTypeMask",
11479 "rate_limit",
11480 "rateLimit",
11481 "node_name",
11482 "nodeName",
11483 ];
11484
11485 #[allow(clippy::enum_variant_names)]
11486 enum GeneratedField {
11487 FragmentId,
11488 JobId,
11489 FragmentTypeMask,
11490 RateLimit,
11491 NodeName,
11492 }
11493 impl<'de> serde::Deserialize<'de> for GeneratedField {
11494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11495 where
11496 D: serde::Deserializer<'de>,
11497 {
11498 struct GeneratedVisitor;
11499
11500 impl serde::de::Visitor<'_> for GeneratedVisitor {
11501 type Value = GeneratedField;
11502
11503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11504 write!(formatter, "expected one of: {:?}", &FIELDS)
11505 }
11506
11507 #[allow(unused_variables)]
11508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11509 where
11510 E: serde::de::Error,
11511 {
11512 match value {
11513 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11514 "jobId" | "job_id" => Ok(GeneratedField::JobId),
11515 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11516 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11517 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
11518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11519 }
11520 }
11521 }
11522 deserializer.deserialize_identifier(GeneratedVisitor)
11523 }
11524 }
11525 struct GeneratedVisitor;
11526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11527 type Value = list_rate_limits_response::RateLimitInfo;
11528
11529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11530 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
11531 }
11532
11533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
11534 where
11535 V: serde::de::MapAccess<'de>,
11536 {
11537 let mut fragment_id__ = None;
11538 let mut job_id__ = None;
11539 let mut fragment_type_mask__ = None;
11540 let mut rate_limit__ = None;
11541 let mut node_name__ = None;
11542 while let Some(k) = map_.next_key()? {
11543 match k {
11544 GeneratedField::FragmentId => {
11545 if fragment_id__.is_some() {
11546 return Err(serde::de::Error::duplicate_field("fragmentId"));
11547 }
11548 fragment_id__ =
11549 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11550 ;
11551 }
11552 GeneratedField::JobId => {
11553 if job_id__.is_some() {
11554 return Err(serde::de::Error::duplicate_field("jobId"));
11555 }
11556 job_id__ =
11557 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11558 ;
11559 }
11560 GeneratedField::FragmentTypeMask => {
11561 if fragment_type_mask__.is_some() {
11562 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11563 }
11564 fragment_type_mask__ =
11565 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11566 ;
11567 }
11568 GeneratedField::RateLimit => {
11569 if rate_limit__.is_some() {
11570 return Err(serde::de::Error::duplicate_field("rateLimit"));
11571 }
11572 rate_limit__ =
11573 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11574 ;
11575 }
11576 GeneratedField::NodeName => {
11577 if node_name__.is_some() {
11578 return Err(serde::de::Error::duplicate_field("nodeName"));
11579 }
11580 node_name__ = Some(map_.next_value()?);
11581 }
11582 }
11583 }
11584 Ok(list_rate_limits_response::RateLimitInfo {
11585 fragment_id: fragment_id__.unwrap_or_default(),
11586 job_id: job_id__.unwrap_or_default(),
11587 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11588 rate_limit: rate_limit__.unwrap_or_default(),
11589 node_name: node_name__.unwrap_or_default(),
11590 })
11591 }
11592 }
11593 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
11594 }
11595}
11596impl serde::Serialize for ListRefreshTableStatesRequest {
11597 #[allow(deprecated)]
11598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11599 where
11600 S: serde::Serializer,
11601 {
11602 use serde::ser::SerializeStruct;
11603 let len = 0;
11604 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
11605 struct_ser.end()
11606 }
11607}
11608impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11609 #[allow(deprecated)]
11610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11611 where
11612 D: serde::Deserializer<'de>,
11613 {
11614 const FIELDS: &[&str] = &[
11615 ];
11616
11617 #[allow(clippy::enum_variant_names)]
11618 enum GeneratedField {
11619 }
11620 impl<'de> serde::Deserialize<'de> for GeneratedField {
11621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11622 where
11623 D: serde::Deserializer<'de>,
11624 {
11625 struct GeneratedVisitor;
11626
11627 impl serde::de::Visitor<'_> for GeneratedVisitor {
11628 type Value = GeneratedField;
11629
11630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11631 write!(formatter, "expected one of: {:?}", &FIELDS)
11632 }
11633
11634 #[allow(unused_variables)]
11635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11636 where
11637 E: serde::de::Error,
11638 {
11639 Err(serde::de::Error::unknown_field(value, FIELDS))
11640 }
11641 }
11642 deserializer.deserialize_identifier(GeneratedVisitor)
11643 }
11644 }
11645 struct GeneratedVisitor;
11646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11647 type Value = ListRefreshTableStatesRequest;
11648
11649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11650 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11651 }
11652
11653 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11654 where
11655 V: serde::de::MapAccess<'de>,
11656 {
11657 while map_.next_key::<GeneratedField>()?.is_some() {
11658 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11659 }
11660 Ok(ListRefreshTableStatesRequest {
11661 })
11662 }
11663 }
11664 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11665 }
11666}
11667impl serde::Serialize for ListRefreshTableStatesResponse {
11668 #[allow(deprecated)]
11669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11670 where
11671 S: serde::Serializer,
11672 {
11673 use serde::ser::SerializeStruct;
11674 let mut len = 0;
11675 if !self.states.is_empty() {
11676 len += 1;
11677 }
11678 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11679 if !self.states.is_empty() {
11680 struct_ser.serialize_field("states", &self.states)?;
11681 }
11682 struct_ser.end()
11683 }
11684}
11685impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11686 #[allow(deprecated)]
11687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11688 where
11689 D: serde::Deserializer<'de>,
11690 {
11691 const FIELDS: &[&str] = &[
11692 "states",
11693 ];
11694
11695 #[allow(clippy::enum_variant_names)]
11696 enum GeneratedField {
11697 States,
11698 }
11699 impl<'de> serde::Deserialize<'de> for GeneratedField {
11700 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11701 where
11702 D: serde::Deserializer<'de>,
11703 {
11704 struct GeneratedVisitor;
11705
11706 impl serde::de::Visitor<'_> for GeneratedVisitor {
11707 type Value = GeneratedField;
11708
11709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11710 write!(formatter, "expected one of: {:?}", &FIELDS)
11711 }
11712
11713 #[allow(unused_variables)]
11714 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11715 where
11716 E: serde::de::Error,
11717 {
11718 match value {
11719 "states" => Ok(GeneratedField::States),
11720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11721 }
11722 }
11723 }
11724 deserializer.deserialize_identifier(GeneratedVisitor)
11725 }
11726 }
11727 struct GeneratedVisitor;
11728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11729 type Value = ListRefreshTableStatesResponse;
11730
11731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11732 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11733 }
11734
11735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11736 where
11737 V: serde::de::MapAccess<'de>,
11738 {
11739 let mut states__ = None;
11740 while let Some(k) = map_.next_key()? {
11741 match k {
11742 GeneratedField::States => {
11743 if states__.is_some() {
11744 return Err(serde::de::Error::duplicate_field("states"));
11745 }
11746 states__ = Some(map_.next_value()?);
11747 }
11748 }
11749 }
11750 Ok(ListRefreshTableStatesResponse {
11751 states: states__.unwrap_or_default(),
11752 })
11753 }
11754 }
11755 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11756 }
11757}
11758impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11759 #[allow(deprecated)]
11760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11761 where
11762 S: serde::Serializer,
11763 {
11764 use serde::ser::SerializeStruct;
11765 let mut len = 0;
11766 if self.table_id != 0 {
11767 len += 1;
11768 }
11769 if !self.current_status.is_empty() {
11770 len += 1;
11771 }
11772 if self.last_trigger_time.is_some() {
11773 len += 1;
11774 }
11775 if self.trigger_interval_secs.is_some() {
11776 len += 1;
11777 }
11778 if self.last_success_time.is_some() {
11779 len += 1;
11780 }
11781 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11782 if self.table_id != 0 {
11783 struct_ser.serialize_field("tableId", &self.table_id)?;
11784 }
11785 if !self.current_status.is_empty() {
11786 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11787 }
11788 if let Some(v) = self.last_trigger_time.as_ref() {
11789 struct_ser.serialize_field("lastTriggerTime", v)?;
11790 }
11791 if let Some(v) = self.trigger_interval_secs.as_ref() {
11792 #[allow(clippy::needless_borrow)]
11793 #[allow(clippy::needless_borrows_for_generic_args)]
11794 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11795 }
11796 if let Some(v) = self.last_success_time.as_ref() {
11797 struct_ser.serialize_field("lastSuccessTime", v)?;
11798 }
11799 struct_ser.end()
11800 }
11801}
11802impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11803 #[allow(deprecated)]
11804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11805 where
11806 D: serde::Deserializer<'de>,
11807 {
11808 const FIELDS: &[&str] = &[
11809 "table_id",
11810 "tableId",
11811 "current_status",
11812 "currentStatus",
11813 "last_trigger_time",
11814 "lastTriggerTime",
11815 "trigger_interval_secs",
11816 "triggerIntervalSecs",
11817 "last_success_time",
11818 "lastSuccessTime",
11819 ];
11820
11821 #[allow(clippy::enum_variant_names)]
11822 enum GeneratedField {
11823 TableId,
11824 CurrentStatus,
11825 LastTriggerTime,
11826 TriggerIntervalSecs,
11827 LastSuccessTime,
11828 }
11829 impl<'de> serde::Deserialize<'de> for GeneratedField {
11830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11831 where
11832 D: serde::Deserializer<'de>,
11833 {
11834 struct GeneratedVisitor;
11835
11836 impl serde::de::Visitor<'_> for GeneratedVisitor {
11837 type Value = GeneratedField;
11838
11839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11840 write!(formatter, "expected one of: {:?}", &FIELDS)
11841 }
11842
11843 #[allow(unused_variables)]
11844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11845 where
11846 E: serde::de::Error,
11847 {
11848 match value {
11849 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11850 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11851 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11852 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11853 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11855 }
11856 }
11857 }
11858 deserializer.deserialize_identifier(GeneratedVisitor)
11859 }
11860 }
11861 struct GeneratedVisitor;
11862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11863 type Value = list_refresh_table_states_response::RefreshTableState;
11864
11865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11866 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11867 }
11868
11869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11870 where
11871 V: serde::de::MapAccess<'de>,
11872 {
11873 let mut table_id__ = None;
11874 let mut current_status__ = None;
11875 let mut last_trigger_time__ = None;
11876 let mut trigger_interval_secs__ = None;
11877 let mut last_success_time__ = None;
11878 while let Some(k) = map_.next_key()? {
11879 match k {
11880 GeneratedField::TableId => {
11881 if table_id__.is_some() {
11882 return Err(serde::de::Error::duplicate_field("tableId"));
11883 }
11884 table_id__ =
11885 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11886 ;
11887 }
11888 GeneratedField::CurrentStatus => {
11889 if current_status__.is_some() {
11890 return Err(serde::de::Error::duplicate_field("currentStatus"));
11891 }
11892 current_status__ = Some(map_.next_value()?);
11893 }
11894 GeneratedField::LastTriggerTime => {
11895 if last_trigger_time__.is_some() {
11896 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11897 }
11898 last_trigger_time__ = map_.next_value()?;
11899 }
11900 GeneratedField::TriggerIntervalSecs => {
11901 if trigger_interval_secs__.is_some() {
11902 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11903 }
11904 trigger_interval_secs__ =
11905 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11906 ;
11907 }
11908 GeneratedField::LastSuccessTime => {
11909 if last_success_time__.is_some() {
11910 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11911 }
11912 last_success_time__ = map_.next_value()?;
11913 }
11914 }
11915 }
11916 Ok(list_refresh_table_states_response::RefreshTableState {
11917 table_id: table_id__.unwrap_or_default(),
11918 current_status: current_status__.unwrap_or_default(),
11919 last_trigger_time: last_trigger_time__,
11920 trigger_interval_secs: trigger_interval_secs__,
11921 last_success_time: last_success_time__,
11922 })
11923 }
11924 }
11925 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11926 }
11927}
11928impl serde::Serialize for ListSinkLogStoreTablesRequest {
11929 #[allow(deprecated)]
11930 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11931 where
11932 S: serde::Serializer,
11933 {
11934 use serde::ser::SerializeStruct;
11935 let len = 0;
11936 let struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesRequest", len)?;
11937 struct_ser.end()
11938 }
11939}
11940impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesRequest {
11941 #[allow(deprecated)]
11942 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11943 where
11944 D: serde::Deserializer<'de>,
11945 {
11946 const FIELDS: &[&str] = &[
11947 ];
11948
11949 #[allow(clippy::enum_variant_names)]
11950 enum GeneratedField {
11951 }
11952 impl<'de> serde::Deserialize<'de> for GeneratedField {
11953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11954 where
11955 D: serde::Deserializer<'de>,
11956 {
11957 struct GeneratedVisitor;
11958
11959 impl serde::de::Visitor<'_> for GeneratedVisitor {
11960 type Value = GeneratedField;
11961
11962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11963 write!(formatter, "expected one of: {:?}", &FIELDS)
11964 }
11965
11966 #[allow(unused_variables)]
11967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11968 where
11969 E: serde::de::Error,
11970 {
11971 Err(serde::de::Error::unknown_field(value, FIELDS))
11972 }
11973 }
11974 deserializer.deserialize_identifier(GeneratedVisitor)
11975 }
11976 }
11977 struct GeneratedVisitor;
11978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11979 type Value = ListSinkLogStoreTablesRequest;
11980
11981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11982 formatter.write_str("struct meta.ListSinkLogStoreTablesRequest")
11983 }
11984
11985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesRequest, V::Error>
11986 where
11987 V: serde::de::MapAccess<'de>,
11988 {
11989 while map_.next_key::<GeneratedField>()?.is_some() {
11990 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11991 }
11992 Ok(ListSinkLogStoreTablesRequest {
11993 })
11994 }
11995 }
11996 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesRequest", FIELDS, GeneratedVisitor)
11997 }
11998}
11999impl serde::Serialize for ListSinkLogStoreTablesResponse {
12000 #[allow(deprecated)]
12001 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12002 where
12003 S: serde::Serializer,
12004 {
12005 use serde::ser::SerializeStruct;
12006 let mut len = 0;
12007 if !self.tables.is_empty() {
12008 len += 1;
12009 }
12010 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse", len)?;
12011 if !self.tables.is_empty() {
12012 struct_ser.serialize_field("tables", &self.tables)?;
12013 }
12014 struct_ser.end()
12015 }
12016}
12017impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesResponse {
12018 #[allow(deprecated)]
12019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12020 where
12021 D: serde::Deserializer<'de>,
12022 {
12023 const FIELDS: &[&str] = &[
12024 "tables",
12025 ];
12026
12027 #[allow(clippy::enum_variant_names)]
12028 enum GeneratedField {
12029 Tables,
12030 }
12031 impl<'de> serde::Deserialize<'de> for GeneratedField {
12032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12033 where
12034 D: serde::Deserializer<'de>,
12035 {
12036 struct GeneratedVisitor;
12037
12038 impl serde::de::Visitor<'_> for GeneratedVisitor {
12039 type Value = GeneratedField;
12040
12041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12042 write!(formatter, "expected one of: {:?}", &FIELDS)
12043 }
12044
12045 #[allow(unused_variables)]
12046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12047 where
12048 E: serde::de::Error,
12049 {
12050 match value {
12051 "tables" => Ok(GeneratedField::Tables),
12052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12053 }
12054 }
12055 }
12056 deserializer.deserialize_identifier(GeneratedVisitor)
12057 }
12058 }
12059 struct GeneratedVisitor;
12060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12061 type Value = ListSinkLogStoreTablesResponse;
12062
12063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12064 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse")
12065 }
12066
12067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesResponse, V::Error>
12068 where
12069 V: serde::de::MapAccess<'de>,
12070 {
12071 let mut tables__ = None;
12072 while let Some(k) = map_.next_key()? {
12073 match k {
12074 GeneratedField::Tables => {
12075 if tables__.is_some() {
12076 return Err(serde::de::Error::duplicate_field("tables"));
12077 }
12078 tables__ = Some(map_.next_value()?);
12079 }
12080 }
12081 }
12082 Ok(ListSinkLogStoreTablesResponse {
12083 tables: tables__.unwrap_or_default(),
12084 })
12085 }
12086 }
12087 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse", FIELDS, GeneratedVisitor)
12088 }
12089}
12090impl serde::Serialize for list_sink_log_store_tables_response::SinkLogStoreTable {
12091 #[allow(deprecated)]
12092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12093 where
12094 S: serde::Serializer,
12095 {
12096 use serde::ser::SerializeStruct;
12097 let mut len = 0;
12098 if self.sink_id != 0 {
12099 len += 1;
12100 }
12101 if self.internal_table_id != 0 {
12102 len += 1;
12103 }
12104 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", len)?;
12105 if self.sink_id != 0 {
12106 struct_ser.serialize_field("sinkId", &self.sink_id)?;
12107 }
12108 if self.internal_table_id != 0 {
12109 struct_ser.serialize_field("internalTableId", &self.internal_table_id)?;
12110 }
12111 struct_ser.end()
12112 }
12113}
12114impl<'de> serde::Deserialize<'de> for list_sink_log_store_tables_response::SinkLogStoreTable {
12115 #[allow(deprecated)]
12116 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12117 where
12118 D: serde::Deserializer<'de>,
12119 {
12120 const FIELDS: &[&str] = &[
12121 "sink_id",
12122 "sinkId",
12123 "internal_table_id",
12124 "internalTableId",
12125 ];
12126
12127 #[allow(clippy::enum_variant_names)]
12128 enum GeneratedField {
12129 SinkId,
12130 InternalTableId,
12131 }
12132 impl<'de> serde::Deserialize<'de> for GeneratedField {
12133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12134 where
12135 D: serde::Deserializer<'de>,
12136 {
12137 struct GeneratedVisitor;
12138
12139 impl serde::de::Visitor<'_> for GeneratedVisitor {
12140 type Value = GeneratedField;
12141
12142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12143 write!(formatter, "expected one of: {:?}", &FIELDS)
12144 }
12145
12146 #[allow(unused_variables)]
12147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12148 where
12149 E: serde::de::Error,
12150 {
12151 match value {
12152 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
12153 "internalTableId" | "internal_table_id" => Ok(GeneratedField::InternalTableId),
12154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12155 }
12156 }
12157 }
12158 deserializer.deserialize_identifier(GeneratedVisitor)
12159 }
12160 }
12161 struct GeneratedVisitor;
12162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12163 type Value = list_sink_log_store_tables_response::SinkLogStoreTable;
12164
12165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12166 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable")
12167 }
12168
12169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_sink_log_store_tables_response::SinkLogStoreTable, V::Error>
12170 where
12171 V: serde::de::MapAccess<'de>,
12172 {
12173 let mut sink_id__ = None;
12174 let mut internal_table_id__ = None;
12175 while let Some(k) = map_.next_key()? {
12176 match k {
12177 GeneratedField::SinkId => {
12178 if sink_id__.is_some() {
12179 return Err(serde::de::Error::duplicate_field("sinkId"));
12180 }
12181 sink_id__ =
12182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12183 ;
12184 }
12185 GeneratedField::InternalTableId => {
12186 if internal_table_id__.is_some() {
12187 return Err(serde::de::Error::duplicate_field("internalTableId"));
12188 }
12189 internal_table_id__ =
12190 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12191 ;
12192 }
12193 }
12194 }
12195 Ok(list_sink_log_store_tables_response::SinkLogStoreTable {
12196 sink_id: sink_id__.unwrap_or_default(),
12197 internal_table_id: internal_table_id__.unwrap_or_default(),
12198 })
12199 }
12200 }
12201 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", FIELDS, GeneratedVisitor)
12202 }
12203}
12204impl serde::Serialize for ListStreamingJobStatesRequest {
12205 #[allow(deprecated)]
12206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12207 where
12208 S: serde::Serializer,
12209 {
12210 use serde::ser::SerializeStruct;
12211 let len = 0;
12212 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
12213 struct_ser.end()
12214 }
12215}
12216impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
12217 #[allow(deprecated)]
12218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12219 where
12220 D: serde::Deserializer<'de>,
12221 {
12222 const FIELDS: &[&str] = &[
12223 ];
12224
12225 #[allow(clippy::enum_variant_names)]
12226 enum GeneratedField {
12227 }
12228 impl<'de> serde::Deserialize<'de> for GeneratedField {
12229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12230 where
12231 D: serde::Deserializer<'de>,
12232 {
12233 struct GeneratedVisitor;
12234
12235 impl serde::de::Visitor<'_> for GeneratedVisitor {
12236 type Value = GeneratedField;
12237
12238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12239 write!(formatter, "expected one of: {:?}", &FIELDS)
12240 }
12241
12242 #[allow(unused_variables)]
12243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12244 where
12245 E: serde::de::Error,
12246 {
12247 Err(serde::de::Error::unknown_field(value, FIELDS))
12248 }
12249 }
12250 deserializer.deserialize_identifier(GeneratedVisitor)
12251 }
12252 }
12253 struct GeneratedVisitor;
12254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12255 type Value = ListStreamingJobStatesRequest;
12256
12257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12258 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
12259 }
12260
12261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
12262 where
12263 V: serde::de::MapAccess<'de>,
12264 {
12265 while map_.next_key::<GeneratedField>()?.is_some() {
12266 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12267 }
12268 Ok(ListStreamingJobStatesRequest {
12269 })
12270 }
12271 }
12272 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
12273 }
12274}
12275impl serde::Serialize for ListStreamingJobStatesResponse {
12276 #[allow(deprecated)]
12277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12278 where
12279 S: serde::Serializer,
12280 {
12281 use serde::ser::SerializeStruct;
12282 let mut len = 0;
12283 if !self.states.is_empty() {
12284 len += 1;
12285 }
12286 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
12287 if !self.states.is_empty() {
12288 struct_ser.serialize_field("states", &self.states)?;
12289 }
12290 struct_ser.end()
12291 }
12292}
12293impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
12294 #[allow(deprecated)]
12295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12296 where
12297 D: serde::Deserializer<'de>,
12298 {
12299 const FIELDS: &[&str] = &[
12300 "states",
12301 ];
12302
12303 #[allow(clippy::enum_variant_names)]
12304 enum GeneratedField {
12305 States,
12306 }
12307 impl<'de> serde::Deserialize<'de> for GeneratedField {
12308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12309 where
12310 D: serde::Deserializer<'de>,
12311 {
12312 struct GeneratedVisitor;
12313
12314 impl serde::de::Visitor<'_> for GeneratedVisitor {
12315 type Value = GeneratedField;
12316
12317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12318 write!(formatter, "expected one of: {:?}", &FIELDS)
12319 }
12320
12321 #[allow(unused_variables)]
12322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12323 where
12324 E: serde::de::Error,
12325 {
12326 match value {
12327 "states" => Ok(GeneratedField::States),
12328 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12329 }
12330 }
12331 }
12332 deserializer.deserialize_identifier(GeneratedVisitor)
12333 }
12334 }
12335 struct GeneratedVisitor;
12336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12337 type Value = ListStreamingJobStatesResponse;
12338
12339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12340 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
12341 }
12342
12343 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
12344 where
12345 V: serde::de::MapAccess<'de>,
12346 {
12347 let mut states__ = None;
12348 while let Some(k) = map_.next_key()? {
12349 match k {
12350 GeneratedField::States => {
12351 if states__.is_some() {
12352 return Err(serde::de::Error::duplicate_field("states"));
12353 }
12354 states__ = Some(map_.next_value()?);
12355 }
12356 }
12357 }
12358 Ok(ListStreamingJobStatesResponse {
12359 states: states__.unwrap_or_default(),
12360 })
12361 }
12362 }
12363 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
12364 }
12365}
12366impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
12367 #[allow(deprecated)]
12368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12369 where
12370 S: serde::Serializer,
12371 {
12372 use serde::ser::SerializeStruct;
12373 let mut len = 0;
12374 if self.table_id != 0 {
12375 len += 1;
12376 }
12377 if self.state != 0 {
12378 len += 1;
12379 }
12380 if self.parallelism.is_some() {
12381 len += 1;
12382 }
12383 if self.max_parallelism != 0 {
12384 len += 1;
12385 }
12386 if !self.name.is_empty() {
12387 len += 1;
12388 }
12389 if !self.resource_group.is_empty() {
12390 len += 1;
12391 }
12392 if !self.config_override.is_empty() {
12393 len += 1;
12394 }
12395 if self.database_id != 0 {
12396 len += 1;
12397 }
12398 if self.schema_id != 0 {
12399 len += 1;
12400 }
12401 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12402 if self.table_id != 0 {
12403 struct_ser.serialize_field("tableId", &self.table_id)?;
12404 }
12405 if self.state != 0 {
12406 let v = table_fragments::State::try_from(self.state)
12407 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12408 struct_ser.serialize_field("state", &v)?;
12409 }
12410 if let Some(v) = self.parallelism.as_ref() {
12411 struct_ser.serialize_field("parallelism", v)?;
12412 }
12413 if self.max_parallelism != 0 {
12414 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12415 }
12416 if !self.name.is_empty() {
12417 struct_ser.serialize_field("name", &self.name)?;
12418 }
12419 if !self.resource_group.is_empty() {
12420 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12421 }
12422 if !self.config_override.is_empty() {
12423 struct_ser.serialize_field("configOverride", &self.config_override)?;
12424 }
12425 if self.database_id != 0 {
12426 struct_ser.serialize_field("databaseId", &self.database_id)?;
12427 }
12428 if self.schema_id != 0 {
12429 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12430 }
12431 struct_ser.end()
12432 }
12433}
12434impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12435 #[allow(deprecated)]
12436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12437 where
12438 D: serde::Deserializer<'de>,
12439 {
12440 const FIELDS: &[&str] = &[
12441 "table_id",
12442 "tableId",
12443 "state",
12444 "parallelism",
12445 "max_parallelism",
12446 "maxParallelism",
12447 "name",
12448 "resource_group",
12449 "resourceGroup",
12450 "config_override",
12451 "configOverride",
12452 "database_id",
12453 "databaseId",
12454 "schema_id",
12455 "schemaId",
12456 ];
12457
12458 #[allow(clippy::enum_variant_names)]
12459 enum GeneratedField {
12460 TableId,
12461 State,
12462 Parallelism,
12463 MaxParallelism,
12464 Name,
12465 ResourceGroup,
12466 ConfigOverride,
12467 DatabaseId,
12468 SchemaId,
12469 }
12470 impl<'de> serde::Deserialize<'de> for GeneratedField {
12471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12472 where
12473 D: serde::Deserializer<'de>,
12474 {
12475 struct GeneratedVisitor;
12476
12477 impl serde::de::Visitor<'_> for GeneratedVisitor {
12478 type Value = GeneratedField;
12479
12480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12481 write!(formatter, "expected one of: {:?}", &FIELDS)
12482 }
12483
12484 #[allow(unused_variables)]
12485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12486 where
12487 E: serde::de::Error,
12488 {
12489 match value {
12490 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12491 "state" => Ok(GeneratedField::State),
12492 "parallelism" => Ok(GeneratedField::Parallelism),
12493 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12494 "name" => Ok(GeneratedField::Name),
12495 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12496 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12497 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12498 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12499 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12500 }
12501 }
12502 }
12503 deserializer.deserialize_identifier(GeneratedVisitor)
12504 }
12505 }
12506 struct GeneratedVisitor;
12507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12508 type Value = list_streaming_job_states_response::StreamingJobState;
12509
12510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12511 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12512 }
12513
12514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12515 where
12516 V: serde::de::MapAccess<'de>,
12517 {
12518 let mut table_id__ = None;
12519 let mut state__ = None;
12520 let mut parallelism__ = None;
12521 let mut max_parallelism__ = None;
12522 let mut name__ = None;
12523 let mut resource_group__ = None;
12524 let mut config_override__ = None;
12525 let mut database_id__ = None;
12526 let mut schema_id__ = None;
12527 while let Some(k) = map_.next_key()? {
12528 match k {
12529 GeneratedField::TableId => {
12530 if table_id__.is_some() {
12531 return Err(serde::de::Error::duplicate_field("tableId"));
12532 }
12533 table_id__ =
12534 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12535 ;
12536 }
12537 GeneratedField::State => {
12538 if state__.is_some() {
12539 return Err(serde::de::Error::duplicate_field("state"));
12540 }
12541 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12542 }
12543 GeneratedField::Parallelism => {
12544 if parallelism__.is_some() {
12545 return Err(serde::de::Error::duplicate_field("parallelism"));
12546 }
12547 parallelism__ = map_.next_value()?;
12548 }
12549 GeneratedField::MaxParallelism => {
12550 if max_parallelism__.is_some() {
12551 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12552 }
12553 max_parallelism__ =
12554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12555 ;
12556 }
12557 GeneratedField::Name => {
12558 if name__.is_some() {
12559 return Err(serde::de::Error::duplicate_field("name"));
12560 }
12561 name__ = Some(map_.next_value()?);
12562 }
12563 GeneratedField::ResourceGroup => {
12564 if resource_group__.is_some() {
12565 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12566 }
12567 resource_group__ = Some(map_.next_value()?);
12568 }
12569 GeneratedField::ConfigOverride => {
12570 if config_override__.is_some() {
12571 return Err(serde::de::Error::duplicate_field("configOverride"));
12572 }
12573 config_override__ = Some(map_.next_value()?);
12574 }
12575 GeneratedField::DatabaseId => {
12576 if database_id__.is_some() {
12577 return Err(serde::de::Error::duplicate_field("databaseId"));
12578 }
12579 database_id__ =
12580 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12581 ;
12582 }
12583 GeneratedField::SchemaId => {
12584 if schema_id__.is_some() {
12585 return Err(serde::de::Error::duplicate_field("schemaId"));
12586 }
12587 schema_id__ =
12588 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12589 ;
12590 }
12591 }
12592 }
12593 Ok(list_streaming_job_states_response::StreamingJobState {
12594 table_id: table_id__.unwrap_or_default(),
12595 state: state__.unwrap_or_default(),
12596 parallelism: parallelism__,
12597 max_parallelism: max_parallelism__.unwrap_or_default(),
12598 name: name__.unwrap_or_default(),
12599 resource_group: resource_group__.unwrap_or_default(),
12600 config_override: config_override__.unwrap_or_default(),
12601 database_id: database_id__.unwrap_or_default(),
12602 schema_id: schema_id__.unwrap_or_default(),
12603 })
12604 }
12605 }
12606 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12607 }
12608}
12609impl serde::Serialize for ListTableFragmentsRequest {
12610 #[allow(deprecated)]
12611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12612 where
12613 S: serde::Serializer,
12614 {
12615 use serde::ser::SerializeStruct;
12616 let mut len = 0;
12617 if !self.table_ids.is_empty() {
12618 len += 1;
12619 }
12620 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12621 if !self.table_ids.is_empty() {
12622 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12623 }
12624 struct_ser.end()
12625 }
12626}
12627impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12628 #[allow(deprecated)]
12629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12630 where
12631 D: serde::Deserializer<'de>,
12632 {
12633 const FIELDS: &[&str] = &[
12634 "table_ids",
12635 "tableIds",
12636 ];
12637
12638 #[allow(clippy::enum_variant_names)]
12639 enum GeneratedField {
12640 TableIds,
12641 }
12642 impl<'de> serde::Deserialize<'de> for GeneratedField {
12643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12644 where
12645 D: serde::Deserializer<'de>,
12646 {
12647 struct GeneratedVisitor;
12648
12649 impl serde::de::Visitor<'_> for GeneratedVisitor {
12650 type Value = GeneratedField;
12651
12652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12653 write!(formatter, "expected one of: {:?}", &FIELDS)
12654 }
12655
12656 #[allow(unused_variables)]
12657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12658 where
12659 E: serde::de::Error,
12660 {
12661 match value {
12662 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12664 }
12665 }
12666 }
12667 deserializer.deserialize_identifier(GeneratedVisitor)
12668 }
12669 }
12670 struct GeneratedVisitor;
12671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12672 type Value = ListTableFragmentsRequest;
12673
12674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12675 formatter.write_str("struct meta.ListTableFragmentsRequest")
12676 }
12677
12678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12679 where
12680 V: serde::de::MapAccess<'de>,
12681 {
12682 let mut table_ids__ = None;
12683 while let Some(k) = map_.next_key()? {
12684 match k {
12685 GeneratedField::TableIds => {
12686 if table_ids__.is_some() {
12687 return Err(serde::de::Error::duplicate_field("tableIds"));
12688 }
12689 table_ids__ =
12690 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12691 .into_iter().map(|x| x.0).collect())
12692 ;
12693 }
12694 }
12695 }
12696 Ok(ListTableFragmentsRequest {
12697 table_ids: table_ids__.unwrap_or_default(),
12698 })
12699 }
12700 }
12701 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12702 }
12703}
12704impl serde::Serialize for ListTableFragmentsResponse {
12705 #[allow(deprecated)]
12706 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12707 where
12708 S: serde::Serializer,
12709 {
12710 use serde::ser::SerializeStruct;
12711 let mut len = 0;
12712 if !self.table_fragments.is_empty() {
12713 len += 1;
12714 }
12715 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12716 if !self.table_fragments.is_empty() {
12717 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12718 }
12719 struct_ser.end()
12720 }
12721}
12722impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12723 #[allow(deprecated)]
12724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12725 where
12726 D: serde::Deserializer<'de>,
12727 {
12728 const FIELDS: &[&str] = &[
12729 "table_fragments",
12730 "tableFragments",
12731 ];
12732
12733 #[allow(clippy::enum_variant_names)]
12734 enum GeneratedField {
12735 TableFragments,
12736 }
12737 impl<'de> serde::Deserialize<'de> for GeneratedField {
12738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12739 where
12740 D: serde::Deserializer<'de>,
12741 {
12742 struct GeneratedVisitor;
12743
12744 impl serde::de::Visitor<'_> for GeneratedVisitor {
12745 type Value = GeneratedField;
12746
12747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12748 write!(formatter, "expected one of: {:?}", &FIELDS)
12749 }
12750
12751 #[allow(unused_variables)]
12752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12753 where
12754 E: serde::de::Error,
12755 {
12756 match value {
12757 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
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 = ListTableFragmentsResponse;
12768
12769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12770 formatter.write_str("struct meta.ListTableFragmentsResponse")
12771 }
12772
12773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12774 where
12775 V: serde::de::MapAccess<'de>,
12776 {
12777 let mut table_fragments__ = None;
12778 while let Some(k) = map_.next_key()? {
12779 match k {
12780 GeneratedField::TableFragments => {
12781 if table_fragments__.is_some() {
12782 return Err(serde::de::Error::duplicate_field("tableFragments"));
12783 }
12784 table_fragments__ = Some(
12785 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12786 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12787 );
12788 }
12789 }
12790 }
12791 Ok(ListTableFragmentsResponse {
12792 table_fragments: table_fragments__.unwrap_or_default(),
12793 })
12794 }
12795 }
12796 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
12797 }
12798}
12799impl serde::Serialize for list_table_fragments_response::ActorInfo {
12800 #[allow(deprecated)]
12801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12802 where
12803 S: serde::Serializer,
12804 {
12805 use serde::ser::SerializeStruct;
12806 let mut len = 0;
12807 if self.id != 0 {
12808 len += 1;
12809 }
12810 if self.node.is_some() {
12811 len += 1;
12812 }
12813 if !self.dispatcher.is_empty() {
12814 len += 1;
12815 }
12816 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
12817 if self.id != 0 {
12818 struct_ser.serialize_field("id", &self.id)?;
12819 }
12820 if let Some(v) = self.node.as_ref() {
12821 struct_ser.serialize_field("node", v)?;
12822 }
12823 if !self.dispatcher.is_empty() {
12824 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12825 }
12826 struct_ser.end()
12827 }
12828}
12829impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
12830 #[allow(deprecated)]
12831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12832 where
12833 D: serde::Deserializer<'de>,
12834 {
12835 const FIELDS: &[&str] = &[
12836 "id",
12837 "node",
12838 "dispatcher",
12839 ];
12840
12841 #[allow(clippy::enum_variant_names)]
12842 enum GeneratedField {
12843 Id,
12844 Node,
12845 Dispatcher,
12846 }
12847 impl<'de> serde::Deserialize<'de> for GeneratedField {
12848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12849 where
12850 D: serde::Deserializer<'de>,
12851 {
12852 struct GeneratedVisitor;
12853
12854 impl serde::de::Visitor<'_> for GeneratedVisitor {
12855 type Value = GeneratedField;
12856
12857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12858 write!(formatter, "expected one of: {:?}", &FIELDS)
12859 }
12860
12861 #[allow(unused_variables)]
12862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12863 where
12864 E: serde::de::Error,
12865 {
12866 match value {
12867 "id" => Ok(GeneratedField::Id),
12868 "node" => Ok(GeneratedField::Node),
12869 "dispatcher" => Ok(GeneratedField::Dispatcher),
12870 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12871 }
12872 }
12873 }
12874 deserializer.deserialize_identifier(GeneratedVisitor)
12875 }
12876 }
12877 struct GeneratedVisitor;
12878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12879 type Value = list_table_fragments_response::ActorInfo;
12880
12881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12882 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
12883 }
12884
12885 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12886 where
12887 V: serde::de::MapAccess<'de>,
12888 {
12889 let mut id__ = None;
12890 let mut node__ = None;
12891 let mut dispatcher__ = None;
12892 while let Some(k) = map_.next_key()? {
12893 match k {
12894 GeneratedField::Id => {
12895 if id__.is_some() {
12896 return Err(serde::de::Error::duplicate_field("id"));
12897 }
12898 id__ =
12899 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12900 ;
12901 }
12902 GeneratedField::Node => {
12903 if node__.is_some() {
12904 return Err(serde::de::Error::duplicate_field("node"));
12905 }
12906 node__ = map_.next_value()?;
12907 }
12908 GeneratedField::Dispatcher => {
12909 if dispatcher__.is_some() {
12910 return Err(serde::de::Error::duplicate_field("dispatcher"));
12911 }
12912 dispatcher__ = Some(map_.next_value()?);
12913 }
12914 }
12915 }
12916 Ok(list_table_fragments_response::ActorInfo {
12917 id: id__.unwrap_or_default(),
12918 node: node__,
12919 dispatcher: dispatcher__.unwrap_or_default(),
12920 })
12921 }
12922 }
12923 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12924 }
12925}
12926impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12927 #[allow(deprecated)]
12928 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12929 where
12930 S: serde::Serializer,
12931 {
12932 use serde::ser::SerializeStruct;
12933 let mut len = 0;
12934 if self.id != 0 {
12935 len += 1;
12936 }
12937 if !self.actors.is_empty() {
12938 len += 1;
12939 }
12940 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12941 if self.id != 0 {
12942 struct_ser.serialize_field("id", &self.id)?;
12943 }
12944 if !self.actors.is_empty() {
12945 struct_ser.serialize_field("actors", &self.actors)?;
12946 }
12947 struct_ser.end()
12948 }
12949}
12950impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12951 #[allow(deprecated)]
12952 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12953 where
12954 D: serde::Deserializer<'de>,
12955 {
12956 const FIELDS: &[&str] = &[
12957 "id",
12958 "actors",
12959 ];
12960
12961 #[allow(clippy::enum_variant_names)]
12962 enum GeneratedField {
12963 Id,
12964 Actors,
12965 }
12966 impl<'de> serde::Deserialize<'de> for GeneratedField {
12967 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12968 where
12969 D: serde::Deserializer<'de>,
12970 {
12971 struct GeneratedVisitor;
12972
12973 impl serde::de::Visitor<'_> for GeneratedVisitor {
12974 type Value = GeneratedField;
12975
12976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12977 write!(formatter, "expected one of: {:?}", &FIELDS)
12978 }
12979
12980 #[allow(unused_variables)]
12981 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12982 where
12983 E: serde::de::Error,
12984 {
12985 match value {
12986 "id" => Ok(GeneratedField::Id),
12987 "actors" => Ok(GeneratedField::Actors),
12988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12989 }
12990 }
12991 }
12992 deserializer.deserialize_identifier(GeneratedVisitor)
12993 }
12994 }
12995 struct GeneratedVisitor;
12996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12997 type Value = list_table_fragments_response::FragmentInfo;
12998
12999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13000 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
13001 }
13002
13003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
13004 where
13005 V: serde::de::MapAccess<'de>,
13006 {
13007 let mut id__ = None;
13008 let mut actors__ = None;
13009 while let Some(k) = map_.next_key()? {
13010 match k {
13011 GeneratedField::Id => {
13012 if id__.is_some() {
13013 return Err(serde::de::Error::duplicate_field("id"));
13014 }
13015 id__ =
13016 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13017 ;
13018 }
13019 GeneratedField::Actors => {
13020 if actors__.is_some() {
13021 return Err(serde::de::Error::duplicate_field("actors"));
13022 }
13023 actors__ = Some(map_.next_value()?);
13024 }
13025 }
13026 }
13027 Ok(list_table_fragments_response::FragmentInfo {
13028 id: id__.unwrap_or_default(),
13029 actors: actors__.unwrap_or_default(),
13030 })
13031 }
13032 }
13033 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
13034 }
13035}
13036impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
13037 #[allow(deprecated)]
13038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13039 where
13040 S: serde::Serializer,
13041 {
13042 use serde::ser::SerializeStruct;
13043 let mut len = 0;
13044 if !self.fragments.is_empty() {
13045 len += 1;
13046 }
13047 if self.ctx.is_some() {
13048 len += 1;
13049 }
13050 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
13051 if !self.fragments.is_empty() {
13052 struct_ser.serialize_field("fragments", &self.fragments)?;
13053 }
13054 if let Some(v) = self.ctx.as_ref() {
13055 struct_ser.serialize_field("ctx", v)?;
13056 }
13057 struct_ser.end()
13058 }
13059}
13060impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
13061 #[allow(deprecated)]
13062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13063 where
13064 D: serde::Deserializer<'de>,
13065 {
13066 const FIELDS: &[&str] = &[
13067 "fragments",
13068 "ctx",
13069 ];
13070
13071 #[allow(clippy::enum_variant_names)]
13072 enum GeneratedField {
13073 Fragments,
13074 Ctx,
13075 }
13076 impl<'de> serde::Deserialize<'de> for GeneratedField {
13077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13078 where
13079 D: serde::Deserializer<'de>,
13080 {
13081 struct GeneratedVisitor;
13082
13083 impl serde::de::Visitor<'_> for GeneratedVisitor {
13084 type Value = GeneratedField;
13085
13086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13087 write!(formatter, "expected one of: {:?}", &FIELDS)
13088 }
13089
13090 #[allow(unused_variables)]
13091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13092 where
13093 E: serde::de::Error,
13094 {
13095 match value {
13096 "fragments" => Ok(GeneratedField::Fragments),
13097 "ctx" => Ok(GeneratedField::Ctx),
13098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13099 }
13100 }
13101 }
13102 deserializer.deserialize_identifier(GeneratedVisitor)
13103 }
13104 }
13105 struct GeneratedVisitor;
13106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13107 type Value = list_table_fragments_response::TableFragmentInfo;
13108
13109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13110 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
13111 }
13112
13113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
13114 where
13115 V: serde::de::MapAccess<'de>,
13116 {
13117 let mut fragments__ = None;
13118 let mut ctx__ = None;
13119 while let Some(k) = map_.next_key()? {
13120 match k {
13121 GeneratedField::Fragments => {
13122 if fragments__.is_some() {
13123 return Err(serde::de::Error::duplicate_field("fragments"));
13124 }
13125 fragments__ = Some(map_.next_value()?);
13126 }
13127 GeneratedField::Ctx => {
13128 if ctx__.is_some() {
13129 return Err(serde::de::Error::duplicate_field("ctx"));
13130 }
13131 ctx__ = map_.next_value()?;
13132 }
13133 }
13134 }
13135 Ok(list_table_fragments_response::TableFragmentInfo {
13136 fragments: fragments__.unwrap_or_default(),
13137 ctx: ctx__,
13138 })
13139 }
13140 }
13141 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
13142 }
13143}
13144impl serde::Serialize for ListUnmigratedTablesRequest {
13145 #[allow(deprecated)]
13146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13147 where
13148 S: serde::Serializer,
13149 {
13150 use serde::ser::SerializeStruct;
13151 let len = 0;
13152 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
13153 struct_ser.end()
13154 }
13155}
13156impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
13157 #[allow(deprecated)]
13158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13159 where
13160 D: serde::Deserializer<'de>,
13161 {
13162 const FIELDS: &[&str] = &[
13163 ];
13164
13165 #[allow(clippy::enum_variant_names)]
13166 enum GeneratedField {
13167 }
13168 impl<'de> serde::Deserialize<'de> for GeneratedField {
13169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13170 where
13171 D: serde::Deserializer<'de>,
13172 {
13173 struct GeneratedVisitor;
13174
13175 impl serde::de::Visitor<'_> for GeneratedVisitor {
13176 type Value = GeneratedField;
13177
13178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13179 write!(formatter, "expected one of: {:?}", &FIELDS)
13180 }
13181
13182 #[allow(unused_variables)]
13183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13184 where
13185 E: serde::de::Error,
13186 {
13187 Err(serde::de::Error::unknown_field(value, FIELDS))
13188 }
13189 }
13190 deserializer.deserialize_identifier(GeneratedVisitor)
13191 }
13192 }
13193 struct GeneratedVisitor;
13194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13195 type Value = ListUnmigratedTablesRequest;
13196
13197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13198 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
13199 }
13200
13201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
13202 where
13203 V: serde::de::MapAccess<'de>,
13204 {
13205 while map_.next_key::<GeneratedField>()?.is_some() {
13206 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13207 }
13208 Ok(ListUnmigratedTablesRequest {
13209 })
13210 }
13211 }
13212 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
13213 }
13214}
13215impl serde::Serialize for ListUnmigratedTablesResponse {
13216 #[allow(deprecated)]
13217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13218 where
13219 S: serde::Serializer,
13220 {
13221 use serde::ser::SerializeStruct;
13222 let mut len = 0;
13223 if !self.tables.is_empty() {
13224 len += 1;
13225 }
13226 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
13227 if !self.tables.is_empty() {
13228 struct_ser.serialize_field("tables", &self.tables)?;
13229 }
13230 struct_ser.end()
13231 }
13232}
13233impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
13234 #[allow(deprecated)]
13235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13236 where
13237 D: serde::Deserializer<'de>,
13238 {
13239 const FIELDS: &[&str] = &[
13240 "tables",
13241 ];
13242
13243 #[allow(clippy::enum_variant_names)]
13244 enum GeneratedField {
13245 Tables,
13246 }
13247 impl<'de> serde::Deserialize<'de> for GeneratedField {
13248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13249 where
13250 D: serde::Deserializer<'de>,
13251 {
13252 struct GeneratedVisitor;
13253
13254 impl serde::de::Visitor<'_> for GeneratedVisitor {
13255 type Value = GeneratedField;
13256
13257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13258 write!(formatter, "expected one of: {:?}", &FIELDS)
13259 }
13260
13261 #[allow(unused_variables)]
13262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13263 where
13264 E: serde::de::Error,
13265 {
13266 match value {
13267 "tables" => Ok(GeneratedField::Tables),
13268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13269 }
13270 }
13271 }
13272 deserializer.deserialize_identifier(GeneratedVisitor)
13273 }
13274 }
13275 struct GeneratedVisitor;
13276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13277 type Value = ListUnmigratedTablesResponse;
13278
13279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13280 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
13281 }
13282
13283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
13284 where
13285 V: serde::de::MapAccess<'de>,
13286 {
13287 let mut tables__ = None;
13288 while let Some(k) = map_.next_key()? {
13289 match k {
13290 GeneratedField::Tables => {
13291 if tables__.is_some() {
13292 return Err(serde::de::Error::duplicate_field("tables"));
13293 }
13294 tables__ = Some(map_.next_value()?);
13295 }
13296 }
13297 }
13298 Ok(ListUnmigratedTablesResponse {
13299 tables: tables__.unwrap_or_default(),
13300 })
13301 }
13302 }
13303 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
13304 }
13305}
13306impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
13307 #[allow(deprecated)]
13308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13309 where
13310 S: serde::Serializer,
13311 {
13312 use serde::ser::SerializeStruct;
13313 let mut len = 0;
13314 if self.table_id != 0 {
13315 len += 1;
13316 }
13317 if !self.table_name.is_empty() {
13318 len += 1;
13319 }
13320 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
13321 if self.table_id != 0 {
13322 struct_ser.serialize_field("tableId", &self.table_id)?;
13323 }
13324 if !self.table_name.is_empty() {
13325 struct_ser.serialize_field("tableName", &self.table_name)?;
13326 }
13327 struct_ser.end()
13328 }
13329}
13330impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
13331 #[allow(deprecated)]
13332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13333 where
13334 D: serde::Deserializer<'de>,
13335 {
13336 const FIELDS: &[&str] = &[
13337 "table_id",
13338 "tableId",
13339 "table_name",
13340 "tableName",
13341 ];
13342
13343 #[allow(clippy::enum_variant_names)]
13344 enum GeneratedField {
13345 TableId,
13346 TableName,
13347 }
13348 impl<'de> serde::Deserialize<'de> for GeneratedField {
13349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13350 where
13351 D: serde::Deserializer<'de>,
13352 {
13353 struct GeneratedVisitor;
13354
13355 impl serde::de::Visitor<'_> for GeneratedVisitor {
13356 type Value = GeneratedField;
13357
13358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13359 write!(formatter, "expected one of: {:?}", &FIELDS)
13360 }
13361
13362 #[allow(unused_variables)]
13363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13364 where
13365 E: serde::de::Error,
13366 {
13367 match value {
13368 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13369 "tableName" | "table_name" => Ok(GeneratedField::TableName),
13370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13371 }
13372 }
13373 }
13374 deserializer.deserialize_identifier(GeneratedVisitor)
13375 }
13376 }
13377 struct GeneratedVisitor;
13378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13379 type Value = list_unmigrated_tables_response::UnmigratedTable;
13380
13381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13382 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
13383 }
13384
13385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
13386 where
13387 V: serde::de::MapAccess<'de>,
13388 {
13389 let mut table_id__ = None;
13390 let mut table_name__ = None;
13391 while let Some(k) = map_.next_key()? {
13392 match k {
13393 GeneratedField::TableId => {
13394 if table_id__.is_some() {
13395 return Err(serde::de::Error::duplicate_field("tableId"));
13396 }
13397 table_id__ =
13398 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13399 ;
13400 }
13401 GeneratedField::TableName => {
13402 if table_name__.is_some() {
13403 return Err(serde::de::Error::duplicate_field("tableName"));
13404 }
13405 table_name__ = Some(map_.next_value()?);
13406 }
13407 }
13408 }
13409 Ok(list_unmigrated_tables_response::UnmigratedTable {
13410 table_id: table_id__.unwrap_or_default(),
13411 table_name: table_name__.unwrap_or_default(),
13412 })
13413 }
13414 }
13415 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13416 }
13417}
13418impl serde::Serialize for MembersRequest {
13419 #[allow(deprecated)]
13420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13421 where
13422 S: serde::Serializer,
13423 {
13424 use serde::ser::SerializeStruct;
13425 let len = 0;
13426 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13427 struct_ser.end()
13428 }
13429}
13430impl<'de> serde::Deserialize<'de> for MembersRequest {
13431 #[allow(deprecated)]
13432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13433 where
13434 D: serde::Deserializer<'de>,
13435 {
13436 const FIELDS: &[&str] = &[
13437 ];
13438
13439 #[allow(clippy::enum_variant_names)]
13440 enum GeneratedField {
13441 }
13442 impl<'de> serde::Deserialize<'de> for GeneratedField {
13443 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13444 where
13445 D: serde::Deserializer<'de>,
13446 {
13447 struct GeneratedVisitor;
13448
13449 impl serde::de::Visitor<'_> for GeneratedVisitor {
13450 type Value = GeneratedField;
13451
13452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13453 write!(formatter, "expected one of: {:?}", &FIELDS)
13454 }
13455
13456 #[allow(unused_variables)]
13457 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13458 where
13459 E: serde::de::Error,
13460 {
13461 Err(serde::de::Error::unknown_field(value, FIELDS))
13462 }
13463 }
13464 deserializer.deserialize_identifier(GeneratedVisitor)
13465 }
13466 }
13467 struct GeneratedVisitor;
13468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13469 type Value = MembersRequest;
13470
13471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13472 formatter.write_str("struct meta.MembersRequest")
13473 }
13474
13475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13476 where
13477 V: serde::de::MapAccess<'de>,
13478 {
13479 while map_.next_key::<GeneratedField>()?.is_some() {
13480 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13481 }
13482 Ok(MembersRequest {
13483 })
13484 }
13485 }
13486 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13487 }
13488}
13489impl serde::Serialize for MembersResponse {
13490 #[allow(deprecated)]
13491 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13492 where
13493 S: serde::Serializer,
13494 {
13495 use serde::ser::SerializeStruct;
13496 let mut len = 0;
13497 if !self.members.is_empty() {
13498 len += 1;
13499 }
13500 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13501 if !self.members.is_empty() {
13502 struct_ser.serialize_field("members", &self.members)?;
13503 }
13504 struct_ser.end()
13505 }
13506}
13507impl<'de> serde::Deserialize<'de> for MembersResponse {
13508 #[allow(deprecated)]
13509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13510 where
13511 D: serde::Deserializer<'de>,
13512 {
13513 const FIELDS: &[&str] = &[
13514 "members",
13515 ];
13516
13517 #[allow(clippy::enum_variant_names)]
13518 enum GeneratedField {
13519 Members,
13520 }
13521 impl<'de> serde::Deserialize<'de> for GeneratedField {
13522 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13523 where
13524 D: serde::Deserializer<'de>,
13525 {
13526 struct GeneratedVisitor;
13527
13528 impl serde::de::Visitor<'_> for GeneratedVisitor {
13529 type Value = GeneratedField;
13530
13531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13532 write!(formatter, "expected one of: {:?}", &FIELDS)
13533 }
13534
13535 #[allow(unused_variables)]
13536 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13537 where
13538 E: serde::de::Error,
13539 {
13540 match value {
13541 "members" => Ok(GeneratedField::Members),
13542 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13543 }
13544 }
13545 }
13546 deserializer.deserialize_identifier(GeneratedVisitor)
13547 }
13548 }
13549 struct GeneratedVisitor;
13550 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13551 type Value = MembersResponse;
13552
13553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13554 formatter.write_str("struct meta.MembersResponse")
13555 }
13556
13557 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13558 where
13559 V: serde::de::MapAccess<'de>,
13560 {
13561 let mut members__ = None;
13562 while let Some(k) = map_.next_key()? {
13563 match k {
13564 GeneratedField::Members => {
13565 if members__.is_some() {
13566 return Err(serde::de::Error::duplicate_field("members"));
13567 }
13568 members__ = Some(map_.next_value()?);
13569 }
13570 }
13571 }
13572 Ok(MembersResponse {
13573 members: members__.unwrap_or_default(),
13574 })
13575 }
13576 }
13577 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13578 }
13579}
13580impl serde::Serialize for MetaMember {
13581 #[allow(deprecated)]
13582 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13583 where
13584 S: serde::Serializer,
13585 {
13586 use serde::ser::SerializeStruct;
13587 let mut len = 0;
13588 if self.address.is_some() {
13589 len += 1;
13590 }
13591 if self.is_leader {
13592 len += 1;
13593 }
13594 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13595 if let Some(v) = self.address.as_ref() {
13596 struct_ser.serialize_field("address", v)?;
13597 }
13598 if self.is_leader {
13599 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13600 }
13601 struct_ser.end()
13602 }
13603}
13604impl<'de> serde::Deserialize<'de> for MetaMember {
13605 #[allow(deprecated)]
13606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13607 where
13608 D: serde::Deserializer<'de>,
13609 {
13610 const FIELDS: &[&str] = &[
13611 "address",
13612 "is_leader",
13613 "isLeader",
13614 ];
13615
13616 #[allow(clippy::enum_variant_names)]
13617 enum GeneratedField {
13618 Address,
13619 IsLeader,
13620 }
13621 impl<'de> serde::Deserialize<'de> for GeneratedField {
13622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13623 where
13624 D: serde::Deserializer<'de>,
13625 {
13626 struct GeneratedVisitor;
13627
13628 impl serde::de::Visitor<'_> for GeneratedVisitor {
13629 type Value = GeneratedField;
13630
13631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13632 write!(formatter, "expected one of: {:?}", &FIELDS)
13633 }
13634
13635 #[allow(unused_variables)]
13636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13637 where
13638 E: serde::de::Error,
13639 {
13640 match value {
13641 "address" => Ok(GeneratedField::Address),
13642 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13643 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13644 }
13645 }
13646 }
13647 deserializer.deserialize_identifier(GeneratedVisitor)
13648 }
13649 }
13650 struct GeneratedVisitor;
13651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13652 type Value = MetaMember;
13653
13654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13655 formatter.write_str("struct meta.MetaMember")
13656 }
13657
13658 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13659 where
13660 V: serde::de::MapAccess<'de>,
13661 {
13662 let mut address__ = None;
13663 let mut is_leader__ = None;
13664 while let Some(k) = map_.next_key()? {
13665 match k {
13666 GeneratedField::Address => {
13667 if address__.is_some() {
13668 return Err(serde::de::Error::duplicate_field("address"));
13669 }
13670 address__ = map_.next_value()?;
13671 }
13672 GeneratedField::IsLeader => {
13673 if is_leader__.is_some() {
13674 return Err(serde::de::Error::duplicate_field("isLeader"));
13675 }
13676 is_leader__ = Some(map_.next_value()?);
13677 }
13678 }
13679 }
13680 Ok(MetaMember {
13681 address: address__,
13682 is_leader: is_leader__.unwrap_or_default(),
13683 })
13684 }
13685 }
13686 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13687 }
13688}
13689impl serde::Serialize for MetaSnapshot {
13690 #[allow(deprecated)]
13691 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13692 where
13693 S: serde::Serializer,
13694 {
13695 use serde::ser::SerializeStruct;
13696 let mut len = 0;
13697 if !self.databases.is_empty() {
13698 len += 1;
13699 }
13700 if !self.schemas.is_empty() {
13701 len += 1;
13702 }
13703 if !self.sources.is_empty() {
13704 len += 1;
13705 }
13706 if !self.sinks.is_empty() {
13707 len += 1;
13708 }
13709 if !self.tables.is_empty() {
13710 len += 1;
13711 }
13712 if !self.indexes.is_empty() {
13713 len += 1;
13714 }
13715 if !self.views.is_empty() {
13716 len += 1;
13717 }
13718 if !self.functions.is_empty() {
13719 len += 1;
13720 }
13721 if !self.connections.is_empty() {
13722 len += 1;
13723 }
13724 if !self.subscriptions.is_empty() {
13725 len += 1;
13726 }
13727 if !self.users.is_empty() {
13728 len += 1;
13729 }
13730 if self.session_params.is_some() {
13731 len += 1;
13732 }
13733 if !self.secrets.is_empty() {
13734 len += 1;
13735 }
13736 if self.cluster_resource.is_some() {
13737 len += 1;
13738 }
13739 if !self.nodes.is_empty() {
13740 len += 1;
13741 }
13742 if self.hummock_version.is_some() {
13743 len += 1;
13744 }
13745 if self.meta_backup_manifest_id.is_some() {
13746 len += 1;
13747 }
13748 if self.hummock_write_limits.is_some() {
13749 len += 1;
13750 }
13751 if !self.streaming_worker_slot_mappings.is_empty() {
13752 len += 1;
13753 }
13754 if !self.serving_worker_slot_mappings.is_empty() {
13755 len += 1;
13756 }
13757 if !self.object_dependencies.is_empty() {
13758 len += 1;
13759 }
13760 if self.version.is_some() {
13761 len += 1;
13762 }
13763 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13764 if !self.databases.is_empty() {
13765 struct_ser.serialize_field("databases", &self.databases)?;
13766 }
13767 if !self.schemas.is_empty() {
13768 struct_ser.serialize_field("schemas", &self.schemas)?;
13769 }
13770 if !self.sources.is_empty() {
13771 struct_ser.serialize_field("sources", &self.sources)?;
13772 }
13773 if !self.sinks.is_empty() {
13774 struct_ser.serialize_field("sinks", &self.sinks)?;
13775 }
13776 if !self.tables.is_empty() {
13777 struct_ser.serialize_field("tables", &self.tables)?;
13778 }
13779 if !self.indexes.is_empty() {
13780 struct_ser.serialize_field("indexes", &self.indexes)?;
13781 }
13782 if !self.views.is_empty() {
13783 struct_ser.serialize_field("views", &self.views)?;
13784 }
13785 if !self.functions.is_empty() {
13786 struct_ser.serialize_field("functions", &self.functions)?;
13787 }
13788 if !self.connections.is_empty() {
13789 struct_ser.serialize_field("connections", &self.connections)?;
13790 }
13791 if !self.subscriptions.is_empty() {
13792 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13793 }
13794 if !self.users.is_empty() {
13795 struct_ser.serialize_field("users", &self.users)?;
13796 }
13797 if let Some(v) = self.session_params.as_ref() {
13798 struct_ser.serialize_field("sessionParams", v)?;
13799 }
13800 if !self.secrets.is_empty() {
13801 struct_ser.serialize_field("secrets", &self.secrets)?;
13802 }
13803 if let Some(v) = self.cluster_resource.as_ref() {
13804 struct_ser.serialize_field("clusterResource", v)?;
13805 }
13806 if !self.nodes.is_empty() {
13807 struct_ser.serialize_field("nodes", &self.nodes)?;
13808 }
13809 if let Some(v) = self.hummock_version.as_ref() {
13810 struct_ser.serialize_field("hummockVersion", v)?;
13811 }
13812 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
13813 struct_ser.serialize_field("metaBackupManifestId", v)?;
13814 }
13815 if let Some(v) = self.hummock_write_limits.as_ref() {
13816 struct_ser.serialize_field("hummockWriteLimits", v)?;
13817 }
13818 if !self.streaming_worker_slot_mappings.is_empty() {
13819 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
13820 }
13821 if !self.serving_worker_slot_mappings.is_empty() {
13822 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
13823 }
13824 if !self.object_dependencies.is_empty() {
13825 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
13826 }
13827 if let Some(v) = self.version.as_ref() {
13828 struct_ser.serialize_field("version", v)?;
13829 }
13830 struct_ser.end()
13831 }
13832}
13833impl<'de> serde::Deserialize<'de> for MetaSnapshot {
13834 #[allow(deprecated)]
13835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13836 where
13837 D: serde::Deserializer<'de>,
13838 {
13839 const FIELDS: &[&str] = &[
13840 "databases",
13841 "schemas",
13842 "sources",
13843 "sinks",
13844 "tables",
13845 "indexes",
13846 "views",
13847 "functions",
13848 "connections",
13849 "subscriptions",
13850 "users",
13851 "session_params",
13852 "sessionParams",
13853 "secrets",
13854 "cluster_resource",
13855 "clusterResource",
13856 "nodes",
13857 "hummock_version",
13858 "hummockVersion",
13859 "meta_backup_manifest_id",
13860 "metaBackupManifestId",
13861 "hummock_write_limits",
13862 "hummockWriteLimits",
13863 "streaming_worker_slot_mappings",
13864 "streamingWorkerSlotMappings",
13865 "serving_worker_slot_mappings",
13866 "servingWorkerSlotMappings",
13867 "object_dependencies",
13868 "objectDependencies",
13869 "version",
13870 ];
13871
13872 #[allow(clippy::enum_variant_names)]
13873 enum GeneratedField {
13874 Databases,
13875 Schemas,
13876 Sources,
13877 Sinks,
13878 Tables,
13879 Indexes,
13880 Views,
13881 Functions,
13882 Connections,
13883 Subscriptions,
13884 Users,
13885 SessionParams,
13886 Secrets,
13887 ClusterResource,
13888 Nodes,
13889 HummockVersion,
13890 MetaBackupManifestId,
13891 HummockWriteLimits,
13892 StreamingWorkerSlotMappings,
13893 ServingWorkerSlotMappings,
13894 ObjectDependencies,
13895 Version,
13896 }
13897 impl<'de> serde::Deserialize<'de> for GeneratedField {
13898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13899 where
13900 D: serde::Deserializer<'de>,
13901 {
13902 struct GeneratedVisitor;
13903
13904 impl serde::de::Visitor<'_> for GeneratedVisitor {
13905 type Value = GeneratedField;
13906
13907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13908 write!(formatter, "expected one of: {:?}", &FIELDS)
13909 }
13910
13911 #[allow(unused_variables)]
13912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13913 where
13914 E: serde::de::Error,
13915 {
13916 match value {
13917 "databases" => Ok(GeneratedField::Databases),
13918 "schemas" => Ok(GeneratedField::Schemas),
13919 "sources" => Ok(GeneratedField::Sources),
13920 "sinks" => Ok(GeneratedField::Sinks),
13921 "tables" => Ok(GeneratedField::Tables),
13922 "indexes" => Ok(GeneratedField::Indexes),
13923 "views" => Ok(GeneratedField::Views),
13924 "functions" => Ok(GeneratedField::Functions),
13925 "connections" => Ok(GeneratedField::Connections),
13926 "subscriptions" => Ok(GeneratedField::Subscriptions),
13927 "users" => Ok(GeneratedField::Users),
13928 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13929 "secrets" => Ok(GeneratedField::Secrets),
13930 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13931 "nodes" => Ok(GeneratedField::Nodes),
13932 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13933 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13934 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13935 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13936 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13937 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
13938 "version" => Ok(GeneratedField::Version),
13939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13940 }
13941 }
13942 }
13943 deserializer.deserialize_identifier(GeneratedVisitor)
13944 }
13945 }
13946 struct GeneratedVisitor;
13947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13948 type Value = MetaSnapshot;
13949
13950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13951 formatter.write_str("struct meta.MetaSnapshot")
13952 }
13953
13954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13955 where
13956 V: serde::de::MapAccess<'de>,
13957 {
13958 let mut databases__ = None;
13959 let mut schemas__ = None;
13960 let mut sources__ = None;
13961 let mut sinks__ = None;
13962 let mut tables__ = None;
13963 let mut indexes__ = None;
13964 let mut views__ = None;
13965 let mut functions__ = None;
13966 let mut connections__ = None;
13967 let mut subscriptions__ = None;
13968 let mut users__ = None;
13969 let mut session_params__ = None;
13970 let mut secrets__ = None;
13971 let mut cluster_resource__ = None;
13972 let mut nodes__ = None;
13973 let mut hummock_version__ = None;
13974 let mut meta_backup_manifest_id__ = None;
13975 let mut hummock_write_limits__ = None;
13976 let mut streaming_worker_slot_mappings__ = None;
13977 let mut serving_worker_slot_mappings__ = None;
13978 let mut object_dependencies__ = None;
13979 let mut version__ = None;
13980 while let Some(k) = map_.next_key()? {
13981 match k {
13982 GeneratedField::Databases => {
13983 if databases__.is_some() {
13984 return Err(serde::de::Error::duplicate_field("databases"));
13985 }
13986 databases__ = Some(map_.next_value()?);
13987 }
13988 GeneratedField::Schemas => {
13989 if schemas__.is_some() {
13990 return Err(serde::de::Error::duplicate_field("schemas"));
13991 }
13992 schemas__ = Some(map_.next_value()?);
13993 }
13994 GeneratedField::Sources => {
13995 if sources__.is_some() {
13996 return Err(serde::de::Error::duplicate_field("sources"));
13997 }
13998 sources__ = Some(map_.next_value()?);
13999 }
14000 GeneratedField::Sinks => {
14001 if sinks__.is_some() {
14002 return Err(serde::de::Error::duplicate_field("sinks"));
14003 }
14004 sinks__ = Some(map_.next_value()?);
14005 }
14006 GeneratedField::Tables => {
14007 if tables__.is_some() {
14008 return Err(serde::de::Error::duplicate_field("tables"));
14009 }
14010 tables__ = Some(map_.next_value()?);
14011 }
14012 GeneratedField::Indexes => {
14013 if indexes__.is_some() {
14014 return Err(serde::de::Error::duplicate_field("indexes"));
14015 }
14016 indexes__ = Some(map_.next_value()?);
14017 }
14018 GeneratedField::Views => {
14019 if views__.is_some() {
14020 return Err(serde::de::Error::duplicate_field("views"));
14021 }
14022 views__ = Some(map_.next_value()?);
14023 }
14024 GeneratedField::Functions => {
14025 if functions__.is_some() {
14026 return Err(serde::de::Error::duplicate_field("functions"));
14027 }
14028 functions__ = Some(map_.next_value()?);
14029 }
14030 GeneratedField::Connections => {
14031 if connections__.is_some() {
14032 return Err(serde::de::Error::duplicate_field("connections"));
14033 }
14034 connections__ = Some(map_.next_value()?);
14035 }
14036 GeneratedField::Subscriptions => {
14037 if subscriptions__.is_some() {
14038 return Err(serde::de::Error::duplicate_field("subscriptions"));
14039 }
14040 subscriptions__ = Some(map_.next_value()?);
14041 }
14042 GeneratedField::Users => {
14043 if users__.is_some() {
14044 return Err(serde::de::Error::duplicate_field("users"));
14045 }
14046 users__ = Some(map_.next_value()?);
14047 }
14048 GeneratedField::SessionParams => {
14049 if session_params__.is_some() {
14050 return Err(serde::de::Error::duplicate_field("sessionParams"));
14051 }
14052 session_params__ = map_.next_value()?;
14053 }
14054 GeneratedField::Secrets => {
14055 if secrets__.is_some() {
14056 return Err(serde::de::Error::duplicate_field("secrets"));
14057 }
14058 secrets__ = Some(map_.next_value()?);
14059 }
14060 GeneratedField::ClusterResource => {
14061 if cluster_resource__.is_some() {
14062 return Err(serde::de::Error::duplicate_field("clusterResource"));
14063 }
14064 cluster_resource__ = map_.next_value()?;
14065 }
14066 GeneratedField::Nodes => {
14067 if nodes__.is_some() {
14068 return Err(serde::de::Error::duplicate_field("nodes"));
14069 }
14070 nodes__ = Some(map_.next_value()?);
14071 }
14072 GeneratedField::HummockVersion => {
14073 if hummock_version__.is_some() {
14074 return Err(serde::de::Error::duplicate_field("hummockVersion"));
14075 }
14076 hummock_version__ = map_.next_value()?;
14077 }
14078 GeneratedField::MetaBackupManifestId => {
14079 if meta_backup_manifest_id__.is_some() {
14080 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14081 }
14082 meta_backup_manifest_id__ = map_.next_value()?;
14083 }
14084 GeneratedField::HummockWriteLimits => {
14085 if hummock_write_limits__.is_some() {
14086 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14087 }
14088 hummock_write_limits__ = map_.next_value()?;
14089 }
14090 GeneratedField::StreamingWorkerSlotMappings => {
14091 if streaming_worker_slot_mappings__.is_some() {
14092 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
14093 }
14094 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
14095 }
14096 GeneratedField::ServingWorkerSlotMappings => {
14097 if serving_worker_slot_mappings__.is_some() {
14098 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14099 }
14100 serving_worker_slot_mappings__ = Some(map_.next_value()?);
14101 }
14102 GeneratedField::ObjectDependencies => {
14103 if object_dependencies__.is_some() {
14104 return Err(serde::de::Error::duplicate_field("objectDependencies"));
14105 }
14106 object_dependencies__ = Some(map_.next_value()?);
14107 }
14108 GeneratedField::Version => {
14109 if version__.is_some() {
14110 return Err(serde::de::Error::duplicate_field("version"));
14111 }
14112 version__ = map_.next_value()?;
14113 }
14114 }
14115 }
14116 Ok(MetaSnapshot {
14117 databases: databases__.unwrap_or_default(),
14118 schemas: schemas__.unwrap_or_default(),
14119 sources: sources__.unwrap_or_default(),
14120 sinks: sinks__.unwrap_or_default(),
14121 tables: tables__.unwrap_or_default(),
14122 indexes: indexes__.unwrap_or_default(),
14123 views: views__.unwrap_or_default(),
14124 functions: functions__.unwrap_or_default(),
14125 connections: connections__.unwrap_or_default(),
14126 subscriptions: subscriptions__.unwrap_or_default(),
14127 users: users__.unwrap_or_default(),
14128 session_params: session_params__,
14129 secrets: secrets__.unwrap_or_default(),
14130 cluster_resource: cluster_resource__,
14131 nodes: nodes__.unwrap_or_default(),
14132 hummock_version: hummock_version__,
14133 meta_backup_manifest_id: meta_backup_manifest_id__,
14134 hummock_write_limits: hummock_write_limits__,
14135 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
14136 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
14137 object_dependencies: object_dependencies__.unwrap_or_default(),
14138 version: version__,
14139 })
14140 }
14141 }
14142 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
14143 }
14144}
14145impl serde::Serialize for meta_snapshot::SnapshotVersion {
14146 #[allow(deprecated)]
14147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14148 where
14149 S: serde::Serializer,
14150 {
14151 use serde::ser::SerializeStruct;
14152 let mut len = 0;
14153 if self.catalog_version != 0 {
14154 len += 1;
14155 }
14156 if self.worker_node_version != 0 {
14157 len += 1;
14158 }
14159 if self.streaming_worker_slot_mapping_version != 0 {
14160 len += 1;
14161 }
14162 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
14163 if self.catalog_version != 0 {
14164 #[allow(clippy::needless_borrow)]
14165 #[allow(clippy::needless_borrows_for_generic_args)]
14166 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
14167 }
14168 if self.worker_node_version != 0 {
14169 #[allow(clippy::needless_borrow)]
14170 #[allow(clippy::needless_borrows_for_generic_args)]
14171 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
14172 }
14173 if self.streaming_worker_slot_mapping_version != 0 {
14174 #[allow(clippy::needless_borrow)]
14175 #[allow(clippy::needless_borrows_for_generic_args)]
14176 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
14177 }
14178 struct_ser.end()
14179 }
14180}
14181impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
14182 #[allow(deprecated)]
14183 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14184 where
14185 D: serde::Deserializer<'de>,
14186 {
14187 const FIELDS: &[&str] = &[
14188 "catalog_version",
14189 "catalogVersion",
14190 "worker_node_version",
14191 "workerNodeVersion",
14192 "streaming_worker_slot_mapping_version",
14193 "streamingWorkerSlotMappingVersion",
14194 ];
14195
14196 #[allow(clippy::enum_variant_names)]
14197 enum GeneratedField {
14198 CatalogVersion,
14199 WorkerNodeVersion,
14200 StreamingWorkerSlotMappingVersion,
14201 }
14202 impl<'de> serde::Deserialize<'de> for GeneratedField {
14203 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14204 where
14205 D: serde::Deserializer<'de>,
14206 {
14207 struct GeneratedVisitor;
14208
14209 impl serde::de::Visitor<'_> for GeneratedVisitor {
14210 type Value = GeneratedField;
14211
14212 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14213 write!(formatter, "expected one of: {:?}", &FIELDS)
14214 }
14215
14216 #[allow(unused_variables)]
14217 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14218 where
14219 E: serde::de::Error,
14220 {
14221 match value {
14222 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
14223 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
14224 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
14225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14226 }
14227 }
14228 }
14229 deserializer.deserialize_identifier(GeneratedVisitor)
14230 }
14231 }
14232 struct GeneratedVisitor;
14233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14234 type Value = meta_snapshot::SnapshotVersion;
14235
14236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14237 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
14238 }
14239
14240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
14241 where
14242 V: serde::de::MapAccess<'de>,
14243 {
14244 let mut catalog_version__ = None;
14245 let mut worker_node_version__ = None;
14246 let mut streaming_worker_slot_mapping_version__ = None;
14247 while let Some(k) = map_.next_key()? {
14248 match k {
14249 GeneratedField::CatalogVersion => {
14250 if catalog_version__.is_some() {
14251 return Err(serde::de::Error::duplicate_field("catalogVersion"));
14252 }
14253 catalog_version__ =
14254 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14255 ;
14256 }
14257 GeneratedField::WorkerNodeVersion => {
14258 if worker_node_version__.is_some() {
14259 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
14260 }
14261 worker_node_version__ =
14262 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14263 ;
14264 }
14265 GeneratedField::StreamingWorkerSlotMappingVersion => {
14266 if streaming_worker_slot_mapping_version__.is_some() {
14267 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
14268 }
14269 streaming_worker_slot_mapping_version__ =
14270 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14271 ;
14272 }
14273 }
14274 }
14275 Ok(meta_snapshot::SnapshotVersion {
14276 catalog_version: catalog_version__.unwrap_or_default(),
14277 worker_node_version: worker_node_version__.unwrap_or_default(),
14278 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
14279 })
14280 }
14281 }
14282 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
14283 }
14284}
14285impl serde::Serialize for MigrationPlan {
14286 #[allow(deprecated)]
14287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14288 where
14289 S: serde::Serializer,
14290 {
14291 use serde::ser::SerializeStruct;
14292 let mut len = 0;
14293 if !self.worker_slot_migration_plan.is_empty() {
14294 len += 1;
14295 }
14296 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
14297 if !self.worker_slot_migration_plan.is_empty() {
14298 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
14299 .map(|(k, v)| (k, v.to_string())).collect();
14300 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
14301 }
14302 struct_ser.end()
14303 }
14304}
14305impl<'de> serde::Deserialize<'de> for MigrationPlan {
14306 #[allow(deprecated)]
14307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14308 where
14309 D: serde::Deserializer<'de>,
14310 {
14311 const FIELDS: &[&str] = &[
14312 "worker_slot_migration_plan",
14313 "workerSlotMigrationPlan",
14314 ];
14315
14316 #[allow(clippy::enum_variant_names)]
14317 enum GeneratedField {
14318 WorkerSlotMigrationPlan,
14319 }
14320 impl<'de> serde::Deserialize<'de> for GeneratedField {
14321 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14322 where
14323 D: serde::Deserializer<'de>,
14324 {
14325 struct GeneratedVisitor;
14326
14327 impl serde::de::Visitor<'_> for GeneratedVisitor {
14328 type Value = GeneratedField;
14329
14330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14331 write!(formatter, "expected one of: {:?}", &FIELDS)
14332 }
14333
14334 #[allow(unused_variables)]
14335 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14336 where
14337 E: serde::de::Error,
14338 {
14339 match value {
14340 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
14341 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14342 }
14343 }
14344 }
14345 deserializer.deserialize_identifier(GeneratedVisitor)
14346 }
14347 }
14348 struct GeneratedVisitor;
14349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14350 type Value = MigrationPlan;
14351
14352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14353 formatter.write_str("struct meta.MigrationPlan")
14354 }
14355
14356 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
14357 where
14358 V: serde::de::MapAccess<'de>,
14359 {
14360 let mut worker_slot_migration_plan__ = None;
14361 while let Some(k) = map_.next_key()? {
14362 match k {
14363 GeneratedField::WorkerSlotMigrationPlan => {
14364 if worker_slot_migration_plan__.is_some() {
14365 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
14366 }
14367 worker_slot_migration_plan__ = Some(
14368 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14369 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
14370 );
14371 }
14372 }
14373 }
14374 Ok(MigrationPlan {
14375 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
14376 })
14377 }
14378 }
14379 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
14380 }
14381}
14382impl serde::Serialize for Object {
14383 #[allow(deprecated)]
14384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14385 where
14386 S: serde::Serializer,
14387 {
14388 use serde::ser::SerializeStruct;
14389 let mut len = 0;
14390 if self.object_info.is_some() {
14391 len += 1;
14392 }
14393 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
14394 if let Some(v) = self.object_info.as_ref() {
14395 match v {
14396 object::ObjectInfo::Database(v) => {
14397 struct_ser.serialize_field("database", v)?;
14398 }
14399 object::ObjectInfo::Schema(v) => {
14400 struct_ser.serialize_field("schema", v)?;
14401 }
14402 object::ObjectInfo::Table(v) => {
14403 struct_ser.serialize_field("table", v)?;
14404 }
14405 object::ObjectInfo::Index(v) => {
14406 struct_ser.serialize_field("index", v)?;
14407 }
14408 object::ObjectInfo::Source(v) => {
14409 struct_ser.serialize_field("source", v)?;
14410 }
14411 object::ObjectInfo::Sink(v) => {
14412 struct_ser.serialize_field("sink", v)?;
14413 }
14414 object::ObjectInfo::View(v) => {
14415 struct_ser.serialize_field("view", v)?;
14416 }
14417 object::ObjectInfo::Function(v) => {
14418 struct_ser.serialize_field("function", v)?;
14419 }
14420 object::ObjectInfo::Connection(v) => {
14421 struct_ser.serialize_field("connection", v)?;
14422 }
14423 object::ObjectInfo::Subscription(v) => {
14424 struct_ser.serialize_field("subscription", v)?;
14425 }
14426 object::ObjectInfo::Secret(v) => {
14427 struct_ser.serialize_field("secret", v)?;
14428 }
14429 }
14430 }
14431 struct_ser.end()
14432 }
14433}
14434impl<'de> serde::Deserialize<'de> for Object {
14435 #[allow(deprecated)]
14436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14437 where
14438 D: serde::Deserializer<'de>,
14439 {
14440 const FIELDS: &[&str] = &[
14441 "database",
14442 "schema",
14443 "table",
14444 "index",
14445 "source",
14446 "sink",
14447 "view",
14448 "function",
14449 "connection",
14450 "subscription",
14451 "secret",
14452 ];
14453
14454 #[allow(clippy::enum_variant_names)]
14455 enum GeneratedField {
14456 Database,
14457 Schema,
14458 Table,
14459 Index,
14460 Source,
14461 Sink,
14462 View,
14463 Function,
14464 Connection,
14465 Subscription,
14466 Secret,
14467 }
14468 impl<'de> serde::Deserialize<'de> for GeneratedField {
14469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14470 where
14471 D: serde::Deserializer<'de>,
14472 {
14473 struct GeneratedVisitor;
14474
14475 impl serde::de::Visitor<'_> for GeneratedVisitor {
14476 type Value = GeneratedField;
14477
14478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14479 write!(formatter, "expected one of: {:?}", &FIELDS)
14480 }
14481
14482 #[allow(unused_variables)]
14483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14484 where
14485 E: serde::de::Error,
14486 {
14487 match value {
14488 "database" => Ok(GeneratedField::Database),
14489 "schema" => Ok(GeneratedField::Schema),
14490 "table" => Ok(GeneratedField::Table),
14491 "index" => Ok(GeneratedField::Index),
14492 "source" => Ok(GeneratedField::Source),
14493 "sink" => Ok(GeneratedField::Sink),
14494 "view" => Ok(GeneratedField::View),
14495 "function" => Ok(GeneratedField::Function),
14496 "connection" => Ok(GeneratedField::Connection),
14497 "subscription" => Ok(GeneratedField::Subscription),
14498 "secret" => Ok(GeneratedField::Secret),
14499 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14500 }
14501 }
14502 }
14503 deserializer.deserialize_identifier(GeneratedVisitor)
14504 }
14505 }
14506 struct GeneratedVisitor;
14507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14508 type Value = Object;
14509
14510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14511 formatter.write_str("struct meta.Object")
14512 }
14513
14514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14515 where
14516 V: serde::de::MapAccess<'de>,
14517 {
14518 let mut object_info__ = None;
14519 while let Some(k) = map_.next_key()? {
14520 match k {
14521 GeneratedField::Database => {
14522 if object_info__.is_some() {
14523 return Err(serde::de::Error::duplicate_field("database"));
14524 }
14525 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14526;
14527 }
14528 GeneratedField::Schema => {
14529 if object_info__.is_some() {
14530 return Err(serde::de::Error::duplicate_field("schema"));
14531 }
14532 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14533;
14534 }
14535 GeneratedField::Table => {
14536 if object_info__.is_some() {
14537 return Err(serde::de::Error::duplicate_field("table"));
14538 }
14539 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14540;
14541 }
14542 GeneratedField::Index => {
14543 if object_info__.is_some() {
14544 return Err(serde::de::Error::duplicate_field("index"));
14545 }
14546 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14547;
14548 }
14549 GeneratedField::Source => {
14550 if object_info__.is_some() {
14551 return Err(serde::de::Error::duplicate_field("source"));
14552 }
14553 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14554;
14555 }
14556 GeneratedField::Sink => {
14557 if object_info__.is_some() {
14558 return Err(serde::de::Error::duplicate_field("sink"));
14559 }
14560 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14561;
14562 }
14563 GeneratedField::View => {
14564 if object_info__.is_some() {
14565 return Err(serde::de::Error::duplicate_field("view"));
14566 }
14567 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14568;
14569 }
14570 GeneratedField::Function => {
14571 if object_info__.is_some() {
14572 return Err(serde::de::Error::duplicate_field("function"));
14573 }
14574 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14575;
14576 }
14577 GeneratedField::Connection => {
14578 if object_info__.is_some() {
14579 return Err(serde::de::Error::duplicate_field("connection"));
14580 }
14581 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14582;
14583 }
14584 GeneratedField::Subscription => {
14585 if object_info__.is_some() {
14586 return Err(serde::de::Error::duplicate_field("subscription"));
14587 }
14588 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14589;
14590 }
14591 GeneratedField::Secret => {
14592 if object_info__.is_some() {
14593 return Err(serde::de::Error::duplicate_field("secret"));
14594 }
14595 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14596;
14597 }
14598 }
14599 }
14600 Ok(Object {
14601 object_info: object_info__,
14602 })
14603 }
14604 }
14605 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14606 }
14607}
14608impl serde::Serialize for ObjectDependency {
14609 #[allow(deprecated)]
14610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14611 where
14612 S: serde::Serializer,
14613 {
14614 use serde::ser::SerializeStruct;
14615 let mut len = 0;
14616 if self.object_id != 0 {
14617 len += 1;
14618 }
14619 if self.referenced_object_id != 0 {
14620 len += 1;
14621 }
14622 if self.referenced_object_type != 0 {
14623 len += 1;
14624 }
14625 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14626 if self.object_id != 0 {
14627 struct_ser.serialize_field("objectId", &self.object_id)?;
14628 }
14629 if self.referenced_object_id != 0 {
14630 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14631 }
14632 if self.referenced_object_type != 0 {
14633 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14634 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14635 struct_ser.serialize_field("referencedObjectType", &v)?;
14636 }
14637 struct_ser.end()
14638 }
14639}
14640impl<'de> serde::Deserialize<'de> for ObjectDependency {
14641 #[allow(deprecated)]
14642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14643 where
14644 D: serde::Deserializer<'de>,
14645 {
14646 const FIELDS: &[&str] = &[
14647 "object_id",
14648 "objectId",
14649 "referenced_object_id",
14650 "referencedObjectId",
14651 "referenced_object_type",
14652 "referencedObjectType",
14653 ];
14654
14655 #[allow(clippy::enum_variant_names)]
14656 enum GeneratedField {
14657 ObjectId,
14658 ReferencedObjectId,
14659 ReferencedObjectType,
14660 }
14661 impl<'de> serde::Deserialize<'de> for GeneratedField {
14662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14663 where
14664 D: serde::Deserializer<'de>,
14665 {
14666 struct GeneratedVisitor;
14667
14668 impl serde::de::Visitor<'_> for GeneratedVisitor {
14669 type Value = GeneratedField;
14670
14671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14672 write!(formatter, "expected one of: {:?}", &FIELDS)
14673 }
14674
14675 #[allow(unused_variables)]
14676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14677 where
14678 E: serde::de::Error,
14679 {
14680 match value {
14681 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14682 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14683 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14685 }
14686 }
14687 }
14688 deserializer.deserialize_identifier(GeneratedVisitor)
14689 }
14690 }
14691 struct GeneratedVisitor;
14692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14693 type Value = ObjectDependency;
14694
14695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14696 formatter.write_str("struct meta.ObjectDependency")
14697 }
14698
14699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14700 where
14701 V: serde::de::MapAccess<'de>,
14702 {
14703 let mut object_id__ = None;
14704 let mut referenced_object_id__ = None;
14705 let mut referenced_object_type__ = None;
14706 while let Some(k) = map_.next_key()? {
14707 match k {
14708 GeneratedField::ObjectId => {
14709 if object_id__.is_some() {
14710 return Err(serde::de::Error::duplicate_field("objectId"));
14711 }
14712 object_id__ =
14713 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14714 ;
14715 }
14716 GeneratedField::ReferencedObjectId => {
14717 if referenced_object_id__.is_some() {
14718 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14719 }
14720 referenced_object_id__ =
14721 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14722 ;
14723 }
14724 GeneratedField::ReferencedObjectType => {
14725 if referenced_object_type__.is_some() {
14726 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14727 }
14728 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14729 }
14730 }
14731 }
14732 Ok(ObjectDependency {
14733 object_id: object_id__.unwrap_or_default(),
14734 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14735 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14736 })
14737 }
14738 }
14739 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14740 }
14741}
14742impl serde::Serialize for ObjectGroup {
14743 #[allow(deprecated)]
14744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14745 where
14746 S: serde::Serializer,
14747 {
14748 use serde::ser::SerializeStruct;
14749 let mut len = 0;
14750 if !self.objects.is_empty() {
14751 len += 1;
14752 }
14753 if !self.dependencies.is_empty() {
14754 len += 1;
14755 }
14756 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14757 if !self.objects.is_empty() {
14758 struct_ser.serialize_field("objects", &self.objects)?;
14759 }
14760 if !self.dependencies.is_empty() {
14761 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14762 }
14763 struct_ser.end()
14764 }
14765}
14766impl<'de> serde::Deserialize<'de> for ObjectGroup {
14767 #[allow(deprecated)]
14768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14769 where
14770 D: serde::Deserializer<'de>,
14771 {
14772 const FIELDS: &[&str] = &[
14773 "objects",
14774 "dependencies",
14775 ];
14776
14777 #[allow(clippy::enum_variant_names)]
14778 enum GeneratedField {
14779 Objects,
14780 Dependencies,
14781 }
14782 impl<'de> serde::Deserialize<'de> for GeneratedField {
14783 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14784 where
14785 D: serde::Deserializer<'de>,
14786 {
14787 struct GeneratedVisitor;
14788
14789 impl serde::de::Visitor<'_> for GeneratedVisitor {
14790 type Value = GeneratedField;
14791
14792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14793 write!(formatter, "expected one of: {:?}", &FIELDS)
14794 }
14795
14796 #[allow(unused_variables)]
14797 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14798 where
14799 E: serde::de::Error,
14800 {
14801 match value {
14802 "objects" => Ok(GeneratedField::Objects),
14803 "dependencies" => Ok(GeneratedField::Dependencies),
14804 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14805 }
14806 }
14807 }
14808 deserializer.deserialize_identifier(GeneratedVisitor)
14809 }
14810 }
14811 struct GeneratedVisitor;
14812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14813 type Value = ObjectGroup;
14814
14815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14816 formatter.write_str("struct meta.ObjectGroup")
14817 }
14818
14819 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
14820 where
14821 V: serde::de::MapAccess<'de>,
14822 {
14823 let mut objects__ = None;
14824 let mut dependencies__ = None;
14825 while let Some(k) = map_.next_key()? {
14826 match k {
14827 GeneratedField::Objects => {
14828 if objects__.is_some() {
14829 return Err(serde::de::Error::duplicate_field("objects"));
14830 }
14831 objects__ = Some(map_.next_value()?);
14832 }
14833 GeneratedField::Dependencies => {
14834 if dependencies__.is_some() {
14835 return Err(serde::de::Error::duplicate_field("dependencies"));
14836 }
14837 dependencies__ = Some(map_.next_value()?);
14838 }
14839 }
14840 }
14841 Ok(ObjectGroup {
14842 objects: objects__.unwrap_or_default(),
14843 dependencies: dependencies__.unwrap_or_default(),
14844 })
14845 }
14846 }
14847 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
14848 }
14849}
14850impl serde::Serialize for PauseRequest {
14851 #[allow(deprecated)]
14852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14853 where
14854 S: serde::Serializer,
14855 {
14856 use serde::ser::SerializeStruct;
14857 let len = 0;
14858 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
14859 struct_ser.end()
14860 }
14861}
14862impl<'de> serde::Deserialize<'de> for PauseRequest {
14863 #[allow(deprecated)]
14864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14865 where
14866 D: serde::Deserializer<'de>,
14867 {
14868 const FIELDS: &[&str] = &[
14869 ];
14870
14871 #[allow(clippy::enum_variant_names)]
14872 enum GeneratedField {
14873 }
14874 impl<'de> serde::Deserialize<'de> for GeneratedField {
14875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14876 where
14877 D: serde::Deserializer<'de>,
14878 {
14879 struct GeneratedVisitor;
14880
14881 impl serde::de::Visitor<'_> for GeneratedVisitor {
14882 type Value = GeneratedField;
14883
14884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14885 write!(formatter, "expected one of: {:?}", &FIELDS)
14886 }
14887
14888 #[allow(unused_variables)]
14889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14890 where
14891 E: serde::de::Error,
14892 {
14893 Err(serde::de::Error::unknown_field(value, FIELDS))
14894 }
14895 }
14896 deserializer.deserialize_identifier(GeneratedVisitor)
14897 }
14898 }
14899 struct GeneratedVisitor;
14900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14901 type Value = PauseRequest;
14902
14903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14904 formatter.write_str("struct meta.PauseRequest")
14905 }
14906
14907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
14908 where
14909 V: serde::de::MapAccess<'de>,
14910 {
14911 while map_.next_key::<GeneratedField>()?.is_some() {
14912 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14913 }
14914 Ok(PauseRequest {
14915 })
14916 }
14917 }
14918 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
14919 }
14920}
14921impl serde::Serialize for PauseResponse {
14922 #[allow(deprecated)]
14923 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14924 where
14925 S: serde::Serializer,
14926 {
14927 use serde::ser::SerializeStruct;
14928 let len = 0;
14929 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
14930 struct_ser.end()
14931 }
14932}
14933impl<'de> serde::Deserialize<'de> for PauseResponse {
14934 #[allow(deprecated)]
14935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14936 where
14937 D: serde::Deserializer<'de>,
14938 {
14939 const FIELDS: &[&str] = &[
14940 ];
14941
14942 #[allow(clippy::enum_variant_names)]
14943 enum GeneratedField {
14944 }
14945 impl<'de> serde::Deserialize<'de> for GeneratedField {
14946 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14947 where
14948 D: serde::Deserializer<'de>,
14949 {
14950 struct GeneratedVisitor;
14951
14952 impl serde::de::Visitor<'_> for GeneratedVisitor {
14953 type Value = GeneratedField;
14954
14955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14956 write!(formatter, "expected one of: {:?}", &FIELDS)
14957 }
14958
14959 #[allow(unused_variables)]
14960 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14961 where
14962 E: serde::de::Error,
14963 {
14964 Err(serde::de::Error::unknown_field(value, FIELDS))
14965 }
14966 }
14967 deserializer.deserialize_identifier(GeneratedVisitor)
14968 }
14969 }
14970 struct GeneratedVisitor;
14971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14972 type Value = PauseResponse;
14973
14974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14975 formatter.write_str("struct meta.PauseResponse")
14976 }
14977
14978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
14979 where
14980 V: serde::de::MapAccess<'de>,
14981 {
14982 while map_.next_key::<GeneratedField>()?.is_some() {
14983 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14984 }
14985 Ok(PauseResponse {
14986 })
14987 }
14988 }
14989 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
14990 }
14991}
14992impl serde::Serialize for PropertyUpdateOptions {
14993 #[allow(deprecated)]
14994 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14995 where
14996 S: serde::Serializer,
14997 {
14998 use serde::ser::SerializeStruct;
14999 let mut len = 0;
15000 if self.reset_splits {
15001 len += 1;
15002 }
15003 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
15004 if self.reset_splits {
15005 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
15006 }
15007 struct_ser.end()
15008 }
15009}
15010impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
15011 #[allow(deprecated)]
15012 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15013 where
15014 D: serde::Deserializer<'de>,
15015 {
15016 const FIELDS: &[&str] = &[
15017 "reset_splits",
15018 "resetSplits",
15019 ];
15020
15021 #[allow(clippy::enum_variant_names)]
15022 enum GeneratedField {
15023 ResetSplits,
15024 }
15025 impl<'de> serde::Deserialize<'de> for GeneratedField {
15026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15027 where
15028 D: serde::Deserializer<'de>,
15029 {
15030 struct GeneratedVisitor;
15031
15032 impl serde::de::Visitor<'_> for GeneratedVisitor {
15033 type Value = GeneratedField;
15034
15035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15036 write!(formatter, "expected one of: {:?}", &FIELDS)
15037 }
15038
15039 #[allow(unused_variables)]
15040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15041 where
15042 E: serde::de::Error,
15043 {
15044 match value {
15045 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
15046 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15047 }
15048 }
15049 }
15050 deserializer.deserialize_identifier(GeneratedVisitor)
15051 }
15052 }
15053 struct GeneratedVisitor;
15054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15055 type Value = PropertyUpdateOptions;
15056
15057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15058 formatter.write_str("struct meta.PropertyUpdateOptions")
15059 }
15060
15061 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
15062 where
15063 V: serde::de::MapAccess<'de>,
15064 {
15065 let mut reset_splits__ = None;
15066 while let Some(k) = map_.next_key()? {
15067 match k {
15068 GeneratedField::ResetSplits => {
15069 if reset_splits__.is_some() {
15070 return Err(serde::de::Error::duplicate_field("resetSplits"));
15071 }
15072 reset_splits__ = Some(map_.next_value()?);
15073 }
15074 }
15075 }
15076 Ok(PropertyUpdateOptions {
15077 reset_splits: reset_splits__.unwrap_or_default(),
15078 })
15079 }
15080 }
15081 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
15082 }
15083}
15084impl serde::Serialize for RecoverRequest {
15085 #[allow(deprecated)]
15086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15087 where
15088 S: serde::Serializer,
15089 {
15090 use serde::ser::SerializeStruct;
15091 let len = 0;
15092 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
15093 struct_ser.end()
15094 }
15095}
15096impl<'de> serde::Deserialize<'de> for RecoverRequest {
15097 #[allow(deprecated)]
15098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15099 where
15100 D: serde::Deserializer<'de>,
15101 {
15102 const FIELDS: &[&str] = &[
15103 ];
15104
15105 #[allow(clippy::enum_variant_names)]
15106 enum GeneratedField {
15107 }
15108 impl<'de> serde::Deserialize<'de> for GeneratedField {
15109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15110 where
15111 D: serde::Deserializer<'de>,
15112 {
15113 struct GeneratedVisitor;
15114
15115 impl serde::de::Visitor<'_> for GeneratedVisitor {
15116 type Value = GeneratedField;
15117
15118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15119 write!(formatter, "expected one of: {:?}", &FIELDS)
15120 }
15121
15122 #[allow(unused_variables)]
15123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15124 where
15125 E: serde::de::Error,
15126 {
15127 Err(serde::de::Error::unknown_field(value, FIELDS))
15128 }
15129 }
15130 deserializer.deserialize_identifier(GeneratedVisitor)
15131 }
15132 }
15133 struct GeneratedVisitor;
15134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15135 type Value = RecoverRequest;
15136
15137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15138 formatter.write_str("struct meta.RecoverRequest")
15139 }
15140
15141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
15142 where
15143 V: serde::de::MapAccess<'de>,
15144 {
15145 while map_.next_key::<GeneratedField>()?.is_some() {
15146 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15147 }
15148 Ok(RecoverRequest {
15149 })
15150 }
15151 }
15152 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
15153 }
15154}
15155impl serde::Serialize for RecoverResponse {
15156 #[allow(deprecated)]
15157 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15158 where
15159 S: serde::Serializer,
15160 {
15161 use serde::ser::SerializeStruct;
15162 let len = 0;
15163 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
15164 struct_ser.end()
15165 }
15166}
15167impl<'de> serde::Deserialize<'de> for RecoverResponse {
15168 #[allow(deprecated)]
15169 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15170 where
15171 D: serde::Deserializer<'de>,
15172 {
15173 const FIELDS: &[&str] = &[
15174 ];
15175
15176 #[allow(clippy::enum_variant_names)]
15177 enum GeneratedField {
15178 }
15179 impl<'de> serde::Deserialize<'de> for GeneratedField {
15180 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15181 where
15182 D: serde::Deserializer<'de>,
15183 {
15184 struct GeneratedVisitor;
15185
15186 impl serde::de::Visitor<'_> for GeneratedVisitor {
15187 type Value = GeneratedField;
15188
15189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15190 write!(formatter, "expected one of: {:?}", &FIELDS)
15191 }
15192
15193 #[allow(unused_variables)]
15194 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15195 where
15196 E: serde::de::Error,
15197 {
15198 Err(serde::de::Error::unknown_field(value, FIELDS))
15199 }
15200 }
15201 deserializer.deserialize_identifier(GeneratedVisitor)
15202 }
15203 }
15204 struct GeneratedVisitor;
15205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15206 type Value = RecoverResponse;
15207
15208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15209 formatter.write_str("struct meta.RecoverResponse")
15210 }
15211
15212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
15213 where
15214 V: serde::de::MapAccess<'de>,
15215 {
15216 while map_.next_key::<GeneratedField>()?.is_some() {
15217 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15218 }
15219 Ok(RecoverResponse {
15220 })
15221 }
15222 }
15223 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
15224 }
15225}
15226impl serde::Serialize for Recovery {
15227 #[allow(deprecated)]
15228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15229 where
15230 S: serde::Serializer,
15231 {
15232 use serde::ser::SerializeStruct;
15233 let len = 0;
15234 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
15235 struct_ser.end()
15236 }
15237}
15238impl<'de> serde::Deserialize<'de> for Recovery {
15239 #[allow(deprecated)]
15240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15241 where
15242 D: serde::Deserializer<'de>,
15243 {
15244 const FIELDS: &[&str] = &[
15245 ];
15246
15247 #[allow(clippy::enum_variant_names)]
15248 enum GeneratedField {
15249 }
15250 impl<'de> serde::Deserialize<'de> for GeneratedField {
15251 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15252 where
15253 D: serde::Deserializer<'de>,
15254 {
15255 struct GeneratedVisitor;
15256
15257 impl serde::de::Visitor<'_> for GeneratedVisitor {
15258 type Value = GeneratedField;
15259
15260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15261 write!(formatter, "expected one of: {:?}", &FIELDS)
15262 }
15263
15264 #[allow(unused_variables)]
15265 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15266 where
15267 E: serde::de::Error,
15268 {
15269 Err(serde::de::Error::unknown_field(value, FIELDS))
15270 }
15271 }
15272 deserializer.deserialize_identifier(GeneratedVisitor)
15273 }
15274 }
15275 struct GeneratedVisitor;
15276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15277 type Value = Recovery;
15278
15279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15280 formatter.write_str("struct meta.Recovery")
15281 }
15282
15283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
15284 where
15285 V: serde::de::MapAccess<'de>,
15286 {
15287 while map_.next_key::<GeneratedField>()?.is_some() {
15288 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15289 }
15290 Ok(Recovery {
15291 })
15292 }
15293 }
15294 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
15295 }
15296}
15297impl serde::Serialize for RecoveryStatus {
15298 #[allow(deprecated)]
15299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15300 where
15301 S: serde::Serializer,
15302 {
15303 let variant = match self {
15304 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
15305 Self::StatusStarting => "STATUS_STARTING",
15306 Self::StatusRecovering => "STATUS_RECOVERING",
15307 Self::StatusRunning => "STATUS_RUNNING",
15308 };
15309 serializer.serialize_str(variant)
15310 }
15311}
15312impl<'de> serde::Deserialize<'de> for RecoveryStatus {
15313 #[allow(deprecated)]
15314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15315 where
15316 D: serde::Deserializer<'de>,
15317 {
15318 const FIELDS: &[&str] = &[
15319 "STATUS_UNSPECIFIED",
15320 "STATUS_STARTING",
15321 "STATUS_RECOVERING",
15322 "STATUS_RUNNING",
15323 ];
15324
15325 struct GeneratedVisitor;
15326
15327 impl serde::de::Visitor<'_> for GeneratedVisitor {
15328 type Value = RecoveryStatus;
15329
15330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15331 write!(formatter, "expected one of: {:?}", &FIELDS)
15332 }
15333
15334 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15335 where
15336 E: serde::de::Error,
15337 {
15338 i32::try_from(v)
15339 .ok()
15340 .and_then(|x| x.try_into().ok())
15341 .ok_or_else(|| {
15342 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15343 })
15344 }
15345
15346 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15347 where
15348 E: serde::de::Error,
15349 {
15350 i32::try_from(v)
15351 .ok()
15352 .and_then(|x| x.try_into().ok())
15353 .ok_or_else(|| {
15354 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15355 })
15356 }
15357
15358 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15359 where
15360 E: serde::de::Error,
15361 {
15362 match value {
15363 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
15364 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
15365 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
15366 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
15367 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15368 }
15369 }
15370 }
15371 deserializer.deserialize_any(GeneratedVisitor)
15372 }
15373}
15374impl serde::Serialize for RefreshRequest {
15375 #[allow(deprecated)]
15376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15377 where
15378 S: serde::Serializer,
15379 {
15380 use serde::ser::SerializeStruct;
15381 let mut len = 0;
15382 if self.table_id != 0 {
15383 len += 1;
15384 }
15385 if self.associated_source_id != 0 {
15386 len += 1;
15387 }
15388 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
15389 if self.table_id != 0 {
15390 struct_ser.serialize_field("tableId", &self.table_id)?;
15391 }
15392 if self.associated_source_id != 0 {
15393 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
15394 }
15395 struct_ser.end()
15396 }
15397}
15398impl<'de> serde::Deserialize<'de> for RefreshRequest {
15399 #[allow(deprecated)]
15400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15401 where
15402 D: serde::Deserializer<'de>,
15403 {
15404 const FIELDS: &[&str] = &[
15405 "table_id",
15406 "tableId",
15407 "associated_source_id",
15408 "associatedSourceId",
15409 ];
15410
15411 #[allow(clippy::enum_variant_names)]
15412 enum GeneratedField {
15413 TableId,
15414 AssociatedSourceId,
15415 }
15416 impl<'de> serde::Deserialize<'de> for GeneratedField {
15417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15418 where
15419 D: serde::Deserializer<'de>,
15420 {
15421 struct GeneratedVisitor;
15422
15423 impl serde::de::Visitor<'_> for GeneratedVisitor {
15424 type Value = GeneratedField;
15425
15426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15427 write!(formatter, "expected one of: {:?}", &FIELDS)
15428 }
15429
15430 #[allow(unused_variables)]
15431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15432 where
15433 E: serde::de::Error,
15434 {
15435 match value {
15436 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15437 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15439 }
15440 }
15441 }
15442 deserializer.deserialize_identifier(GeneratedVisitor)
15443 }
15444 }
15445 struct GeneratedVisitor;
15446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15447 type Value = RefreshRequest;
15448
15449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15450 formatter.write_str("struct meta.RefreshRequest")
15451 }
15452
15453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15454 where
15455 V: serde::de::MapAccess<'de>,
15456 {
15457 let mut table_id__ = None;
15458 let mut associated_source_id__ = None;
15459 while let Some(k) = map_.next_key()? {
15460 match k {
15461 GeneratedField::TableId => {
15462 if table_id__.is_some() {
15463 return Err(serde::de::Error::duplicate_field("tableId"));
15464 }
15465 table_id__ =
15466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15467 ;
15468 }
15469 GeneratedField::AssociatedSourceId => {
15470 if associated_source_id__.is_some() {
15471 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15472 }
15473 associated_source_id__ =
15474 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15475 ;
15476 }
15477 }
15478 }
15479 Ok(RefreshRequest {
15480 table_id: table_id__.unwrap_or_default(),
15481 associated_source_id: associated_source_id__.unwrap_or_default(),
15482 })
15483 }
15484 }
15485 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15486 }
15487}
15488impl serde::Serialize for RefreshResponse {
15489 #[allow(deprecated)]
15490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15491 where
15492 S: serde::Serializer,
15493 {
15494 use serde::ser::SerializeStruct;
15495 let mut len = 0;
15496 if self.status.is_some() {
15497 len += 1;
15498 }
15499 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15500 if let Some(v) = self.status.as_ref() {
15501 struct_ser.serialize_field("status", v)?;
15502 }
15503 struct_ser.end()
15504 }
15505}
15506impl<'de> serde::Deserialize<'de> for RefreshResponse {
15507 #[allow(deprecated)]
15508 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15509 where
15510 D: serde::Deserializer<'de>,
15511 {
15512 const FIELDS: &[&str] = &[
15513 "status",
15514 ];
15515
15516 #[allow(clippy::enum_variant_names)]
15517 enum GeneratedField {
15518 Status,
15519 }
15520 impl<'de> serde::Deserialize<'de> for GeneratedField {
15521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15522 where
15523 D: serde::Deserializer<'de>,
15524 {
15525 struct GeneratedVisitor;
15526
15527 impl serde::de::Visitor<'_> for GeneratedVisitor {
15528 type Value = GeneratedField;
15529
15530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15531 write!(formatter, "expected one of: {:?}", &FIELDS)
15532 }
15533
15534 #[allow(unused_variables)]
15535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15536 where
15537 E: serde::de::Error,
15538 {
15539 match value {
15540 "status" => Ok(GeneratedField::Status),
15541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15542 }
15543 }
15544 }
15545 deserializer.deserialize_identifier(GeneratedVisitor)
15546 }
15547 }
15548 struct GeneratedVisitor;
15549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15550 type Value = RefreshResponse;
15551
15552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15553 formatter.write_str("struct meta.RefreshResponse")
15554 }
15555
15556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15557 where
15558 V: serde::de::MapAccess<'de>,
15559 {
15560 let mut status__ = None;
15561 while let Some(k) = map_.next_key()? {
15562 match k {
15563 GeneratedField::Status => {
15564 if status__.is_some() {
15565 return Err(serde::de::Error::duplicate_field("status"));
15566 }
15567 status__ = map_.next_value()?;
15568 }
15569 }
15570 }
15571 Ok(RefreshResponse {
15572 status: status__,
15573 })
15574 }
15575 }
15576 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15577 }
15578}
15579impl serde::Serialize for RelationIdInfos {
15580 #[allow(deprecated)]
15581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15582 where
15583 S: serde::Serializer,
15584 {
15585 use serde::ser::SerializeStruct;
15586 let mut len = 0;
15587 if !self.map.is_empty() {
15588 len += 1;
15589 }
15590 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15591 if !self.map.is_empty() {
15592 struct_ser.serialize_field("map", &self.map)?;
15593 }
15594 struct_ser.end()
15595 }
15596}
15597impl<'de> serde::Deserialize<'de> for RelationIdInfos {
15598 #[allow(deprecated)]
15599 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15600 where
15601 D: serde::Deserializer<'de>,
15602 {
15603 const FIELDS: &[&str] = &[
15604 "map",
15605 ];
15606
15607 #[allow(clippy::enum_variant_names)]
15608 enum GeneratedField {
15609 Map,
15610 }
15611 impl<'de> serde::Deserialize<'de> for GeneratedField {
15612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15613 where
15614 D: serde::Deserializer<'de>,
15615 {
15616 struct GeneratedVisitor;
15617
15618 impl serde::de::Visitor<'_> for GeneratedVisitor {
15619 type Value = GeneratedField;
15620
15621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15622 write!(formatter, "expected one of: {:?}", &FIELDS)
15623 }
15624
15625 #[allow(unused_variables)]
15626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15627 where
15628 E: serde::de::Error,
15629 {
15630 match value {
15631 "map" => Ok(GeneratedField::Map),
15632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15633 }
15634 }
15635 }
15636 deserializer.deserialize_identifier(GeneratedVisitor)
15637 }
15638 }
15639 struct GeneratedVisitor;
15640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15641 type Value = RelationIdInfos;
15642
15643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15644 formatter.write_str("struct meta.RelationIdInfos")
15645 }
15646
15647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15648 where
15649 V: serde::de::MapAccess<'de>,
15650 {
15651 let mut map__ = None;
15652 while let Some(k) = map_.next_key()? {
15653 match k {
15654 GeneratedField::Map => {
15655 if map__.is_some() {
15656 return Err(serde::de::Error::duplicate_field("map"));
15657 }
15658 map__ = Some(
15659 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15660 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15661 );
15662 }
15663 }
15664 }
15665 Ok(RelationIdInfos {
15666 map: map__.unwrap_or_default(),
15667 })
15668 }
15669 }
15670 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15671 }
15672}
15673impl serde::Serialize for RescheduleRequest {
15674 #[allow(deprecated)]
15675 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15676 where
15677 S: serde::Serializer,
15678 {
15679 use serde::ser::SerializeStruct;
15680 let mut len = 0;
15681 if self.revision != 0 {
15682 len += 1;
15683 }
15684 if self.resolve_no_shuffle_upstream {
15685 len += 1;
15686 }
15687 if !self.worker_reschedules.is_empty() {
15688 len += 1;
15689 }
15690 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15691 if self.revision != 0 {
15692 #[allow(clippy::needless_borrow)]
15693 #[allow(clippy::needless_borrows_for_generic_args)]
15694 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15695 }
15696 if self.resolve_no_shuffle_upstream {
15697 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15698 }
15699 if !self.worker_reschedules.is_empty() {
15700 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15701 }
15702 struct_ser.end()
15703 }
15704}
15705impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15706 #[allow(deprecated)]
15707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15708 where
15709 D: serde::Deserializer<'de>,
15710 {
15711 const FIELDS: &[&str] = &[
15712 "revision",
15713 "resolve_no_shuffle_upstream",
15714 "resolveNoShuffleUpstream",
15715 "worker_reschedules",
15716 "workerReschedules",
15717 ];
15718
15719 #[allow(clippy::enum_variant_names)]
15720 enum GeneratedField {
15721 Revision,
15722 ResolveNoShuffleUpstream,
15723 WorkerReschedules,
15724 }
15725 impl<'de> serde::Deserialize<'de> for GeneratedField {
15726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15727 where
15728 D: serde::Deserializer<'de>,
15729 {
15730 struct GeneratedVisitor;
15731
15732 impl serde::de::Visitor<'_> for GeneratedVisitor {
15733 type Value = GeneratedField;
15734
15735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15736 write!(formatter, "expected one of: {:?}", &FIELDS)
15737 }
15738
15739 #[allow(unused_variables)]
15740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15741 where
15742 E: serde::de::Error,
15743 {
15744 match value {
15745 "revision" => Ok(GeneratedField::Revision),
15746 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15747 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15748 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15749 }
15750 }
15751 }
15752 deserializer.deserialize_identifier(GeneratedVisitor)
15753 }
15754 }
15755 struct GeneratedVisitor;
15756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15757 type Value = RescheduleRequest;
15758
15759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15760 formatter.write_str("struct meta.RescheduleRequest")
15761 }
15762
15763 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15764 where
15765 V: serde::de::MapAccess<'de>,
15766 {
15767 let mut revision__ = None;
15768 let mut resolve_no_shuffle_upstream__ = None;
15769 let mut worker_reschedules__ = None;
15770 while let Some(k) = map_.next_key()? {
15771 match k {
15772 GeneratedField::Revision => {
15773 if revision__.is_some() {
15774 return Err(serde::de::Error::duplicate_field("revision"));
15775 }
15776 revision__ =
15777 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15778 ;
15779 }
15780 GeneratedField::ResolveNoShuffleUpstream => {
15781 if resolve_no_shuffle_upstream__.is_some() {
15782 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
15783 }
15784 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
15785 }
15786 GeneratedField::WorkerReschedules => {
15787 if worker_reschedules__.is_some() {
15788 return Err(serde::de::Error::duplicate_field("workerReschedules"));
15789 }
15790 worker_reschedules__ = Some(
15791 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15792 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15793 );
15794 }
15795 }
15796 }
15797 Ok(RescheduleRequest {
15798 revision: revision__.unwrap_or_default(),
15799 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
15800 worker_reschedules: worker_reschedules__.unwrap_or_default(),
15801 })
15802 }
15803 }
15804 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
15805 }
15806}
15807impl serde::Serialize for RescheduleResponse {
15808 #[allow(deprecated)]
15809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15810 where
15811 S: serde::Serializer,
15812 {
15813 use serde::ser::SerializeStruct;
15814 let mut len = 0;
15815 if self.success {
15816 len += 1;
15817 }
15818 if self.revision != 0 {
15819 len += 1;
15820 }
15821 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
15822 if self.success {
15823 struct_ser.serialize_field("success", &self.success)?;
15824 }
15825 if self.revision != 0 {
15826 #[allow(clippy::needless_borrow)]
15827 #[allow(clippy::needless_borrows_for_generic_args)]
15828 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15829 }
15830 struct_ser.end()
15831 }
15832}
15833impl<'de> serde::Deserialize<'de> for RescheduleResponse {
15834 #[allow(deprecated)]
15835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15836 where
15837 D: serde::Deserializer<'de>,
15838 {
15839 const FIELDS: &[&str] = &[
15840 "success",
15841 "revision",
15842 ];
15843
15844 #[allow(clippy::enum_variant_names)]
15845 enum GeneratedField {
15846 Success,
15847 Revision,
15848 }
15849 impl<'de> serde::Deserialize<'de> for GeneratedField {
15850 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15851 where
15852 D: serde::Deserializer<'de>,
15853 {
15854 struct GeneratedVisitor;
15855
15856 impl serde::de::Visitor<'_> for GeneratedVisitor {
15857 type Value = GeneratedField;
15858
15859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15860 write!(formatter, "expected one of: {:?}", &FIELDS)
15861 }
15862
15863 #[allow(unused_variables)]
15864 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15865 where
15866 E: serde::de::Error,
15867 {
15868 match value {
15869 "success" => Ok(GeneratedField::Success),
15870 "revision" => Ok(GeneratedField::Revision),
15871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15872 }
15873 }
15874 }
15875 deserializer.deserialize_identifier(GeneratedVisitor)
15876 }
15877 }
15878 struct GeneratedVisitor;
15879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15880 type Value = RescheduleResponse;
15881
15882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15883 formatter.write_str("struct meta.RescheduleResponse")
15884 }
15885
15886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
15887 where
15888 V: serde::de::MapAccess<'de>,
15889 {
15890 let mut success__ = None;
15891 let mut revision__ = None;
15892 while let Some(k) = map_.next_key()? {
15893 match k {
15894 GeneratedField::Success => {
15895 if success__.is_some() {
15896 return Err(serde::de::Error::duplicate_field("success"));
15897 }
15898 success__ = Some(map_.next_value()?);
15899 }
15900 GeneratedField::Revision => {
15901 if revision__.is_some() {
15902 return Err(serde::de::Error::duplicate_field("revision"));
15903 }
15904 revision__ =
15905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15906 ;
15907 }
15908 }
15909 }
15910 Ok(RescheduleResponse {
15911 success: success__.unwrap_or_default(),
15912 revision: revision__.unwrap_or_default(),
15913 })
15914 }
15915 }
15916 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
15917 }
15918}
15919impl serde::Serialize for ResetSourceSplitsRequest {
15920 #[allow(deprecated)]
15921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15922 where
15923 S: serde::Serializer,
15924 {
15925 use serde::ser::SerializeStruct;
15926 let mut len = 0;
15927 if self.source_id != 0 {
15928 len += 1;
15929 }
15930 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
15931 if self.source_id != 0 {
15932 struct_ser.serialize_field("sourceId", &self.source_id)?;
15933 }
15934 struct_ser.end()
15935 }
15936}
15937impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
15938 #[allow(deprecated)]
15939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15940 where
15941 D: serde::Deserializer<'de>,
15942 {
15943 const FIELDS: &[&str] = &[
15944 "source_id",
15945 "sourceId",
15946 ];
15947
15948 #[allow(clippy::enum_variant_names)]
15949 enum GeneratedField {
15950 SourceId,
15951 }
15952 impl<'de> serde::Deserialize<'de> for GeneratedField {
15953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15954 where
15955 D: serde::Deserializer<'de>,
15956 {
15957 struct GeneratedVisitor;
15958
15959 impl serde::de::Visitor<'_> for GeneratedVisitor {
15960 type Value = GeneratedField;
15961
15962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15963 write!(formatter, "expected one of: {:?}", &FIELDS)
15964 }
15965
15966 #[allow(unused_variables)]
15967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15968 where
15969 E: serde::de::Error,
15970 {
15971 match value {
15972 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15974 }
15975 }
15976 }
15977 deserializer.deserialize_identifier(GeneratedVisitor)
15978 }
15979 }
15980 struct GeneratedVisitor;
15981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15982 type Value = ResetSourceSplitsRequest;
15983
15984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15985 formatter.write_str("struct meta.ResetSourceSplitsRequest")
15986 }
15987
15988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
15989 where
15990 V: serde::de::MapAccess<'de>,
15991 {
15992 let mut source_id__ = None;
15993 while let Some(k) = map_.next_key()? {
15994 match k {
15995 GeneratedField::SourceId => {
15996 if source_id__.is_some() {
15997 return Err(serde::de::Error::duplicate_field("sourceId"));
15998 }
15999 source_id__ =
16000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16001 ;
16002 }
16003 }
16004 }
16005 Ok(ResetSourceSplitsRequest {
16006 source_id: source_id__.unwrap_or_default(),
16007 })
16008 }
16009 }
16010 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
16011 }
16012}
16013impl serde::Serialize for ResetSourceSplitsResponse {
16014 #[allow(deprecated)]
16015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16016 where
16017 S: serde::Serializer,
16018 {
16019 use serde::ser::SerializeStruct;
16020 let len = 0;
16021 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
16022 struct_ser.end()
16023 }
16024}
16025impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
16026 #[allow(deprecated)]
16027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16028 where
16029 D: serde::Deserializer<'de>,
16030 {
16031 const FIELDS: &[&str] = &[
16032 ];
16033
16034 #[allow(clippy::enum_variant_names)]
16035 enum GeneratedField {
16036 }
16037 impl<'de> serde::Deserialize<'de> for GeneratedField {
16038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16039 where
16040 D: serde::Deserializer<'de>,
16041 {
16042 struct GeneratedVisitor;
16043
16044 impl serde::de::Visitor<'_> for GeneratedVisitor {
16045 type Value = GeneratedField;
16046
16047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16048 write!(formatter, "expected one of: {:?}", &FIELDS)
16049 }
16050
16051 #[allow(unused_variables)]
16052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16053 where
16054 E: serde::de::Error,
16055 {
16056 Err(serde::de::Error::unknown_field(value, FIELDS))
16057 }
16058 }
16059 deserializer.deserialize_identifier(GeneratedVisitor)
16060 }
16061 }
16062 struct GeneratedVisitor;
16063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16064 type Value = ResetSourceSplitsResponse;
16065
16066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16067 formatter.write_str("struct meta.ResetSourceSplitsResponse")
16068 }
16069
16070 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
16071 where
16072 V: serde::de::MapAccess<'de>,
16073 {
16074 while map_.next_key::<GeneratedField>()?.is_some() {
16075 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16076 }
16077 Ok(ResetSourceSplitsResponse {
16078 })
16079 }
16080 }
16081 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
16082 }
16083}
16084impl serde::Serialize for ResumeRequest {
16085 #[allow(deprecated)]
16086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16087 where
16088 S: serde::Serializer,
16089 {
16090 use serde::ser::SerializeStruct;
16091 let len = 0;
16092 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
16093 struct_ser.end()
16094 }
16095}
16096impl<'de> serde::Deserialize<'de> for ResumeRequest {
16097 #[allow(deprecated)]
16098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16099 where
16100 D: serde::Deserializer<'de>,
16101 {
16102 const FIELDS: &[&str] = &[
16103 ];
16104
16105 #[allow(clippy::enum_variant_names)]
16106 enum GeneratedField {
16107 }
16108 impl<'de> serde::Deserialize<'de> for GeneratedField {
16109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16110 where
16111 D: serde::Deserializer<'de>,
16112 {
16113 struct GeneratedVisitor;
16114
16115 impl serde::de::Visitor<'_> for GeneratedVisitor {
16116 type Value = GeneratedField;
16117
16118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16119 write!(formatter, "expected one of: {:?}", &FIELDS)
16120 }
16121
16122 #[allow(unused_variables)]
16123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16124 where
16125 E: serde::de::Error,
16126 {
16127 Err(serde::de::Error::unknown_field(value, FIELDS))
16128 }
16129 }
16130 deserializer.deserialize_identifier(GeneratedVisitor)
16131 }
16132 }
16133 struct GeneratedVisitor;
16134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16135 type Value = ResumeRequest;
16136
16137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16138 formatter.write_str("struct meta.ResumeRequest")
16139 }
16140
16141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
16142 where
16143 V: serde::de::MapAccess<'de>,
16144 {
16145 while map_.next_key::<GeneratedField>()?.is_some() {
16146 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16147 }
16148 Ok(ResumeRequest {
16149 })
16150 }
16151 }
16152 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
16153 }
16154}
16155impl serde::Serialize for ResumeResponse {
16156 #[allow(deprecated)]
16157 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16158 where
16159 S: serde::Serializer,
16160 {
16161 use serde::ser::SerializeStruct;
16162 let len = 0;
16163 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
16164 struct_ser.end()
16165 }
16166}
16167impl<'de> serde::Deserialize<'de> for ResumeResponse {
16168 #[allow(deprecated)]
16169 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16170 where
16171 D: serde::Deserializer<'de>,
16172 {
16173 const FIELDS: &[&str] = &[
16174 ];
16175
16176 #[allow(clippy::enum_variant_names)]
16177 enum GeneratedField {
16178 }
16179 impl<'de> serde::Deserialize<'de> for GeneratedField {
16180 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16181 where
16182 D: serde::Deserializer<'de>,
16183 {
16184 struct GeneratedVisitor;
16185
16186 impl serde::de::Visitor<'_> for GeneratedVisitor {
16187 type Value = GeneratedField;
16188
16189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16190 write!(formatter, "expected one of: {:?}", &FIELDS)
16191 }
16192
16193 #[allow(unused_variables)]
16194 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16195 where
16196 E: serde::de::Error,
16197 {
16198 Err(serde::de::Error::unknown_field(value, FIELDS))
16199 }
16200 }
16201 deserializer.deserialize_identifier(GeneratedVisitor)
16202 }
16203 }
16204 struct GeneratedVisitor;
16205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16206 type Value = ResumeResponse;
16207
16208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16209 formatter.write_str("struct meta.ResumeResponse")
16210 }
16211
16212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
16213 where
16214 V: serde::de::MapAccess<'de>,
16215 {
16216 while map_.next_key::<GeneratedField>()?.is_some() {
16217 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16218 }
16219 Ok(ResumeResponse {
16220 })
16221 }
16222 }
16223 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
16224 }
16225}
16226impl serde::Serialize for SetSessionParamRequest {
16227 #[allow(deprecated)]
16228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16229 where
16230 S: serde::Serializer,
16231 {
16232 use serde::ser::SerializeStruct;
16233 let mut len = 0;
16234 if !self.param.is_empty() {
16235 len += 1;
16236 }
16237 if self.value.is_some() {
16238 len += 1;
16239 }
16240 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
16241 if !self.param.is_empty() {
16242 struct_ser.serialize_field("param", &self.param)?;
16243 }
16244 if let Some(v) = self.value.as_ref() {
16245 struct_ser.serialize_field("value", v)?;
16246 }
16247 struct_ser.end()
16248 }
16249}
16250impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
16251 #[allow(deprecated)]
16252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16253 where
16254 D: serde::Deserializer<'de>,
16255 {
16256 const FIELDS: &[&str] = &[
16257 "param",
16258 "value",
16259 ];
16260
16261 #[allow(clippy::enum_variant_names)]
16262 enum GeneratedField {
16263 Param,
16264 Value,
16265 }
16266 impl<'de> serde::Deserialize<'de> for GeneratedField {
16267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16268 where
16269 D: serde::Deserializer<'de>,
16270 {
16271 struct GeneratedVisitor;
16272
16273 impl serde::de::Visitor<'_> for GeneratedVisitor {
16274 type Value = GeneratedField;
16275
16276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16277 write!(formatter, "expected one of: {:?}", &FIELDS)
16278 }
16279
16280 #[allow(unused_variables)]
16281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16282 where
16283 E: serde::de::Error,
16284 {
16285 match value {
16286 "param" => Ok(GeneratedField::Param),
16287 "value" => Ok(GeneratedField::Value),
16288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16289 }
16290 }
16291 }
16292 deserializer.deserialize_identifier(GeneratedVisitor)
16293 }
16294 }
16295 struct GeneratedVisitor;
16296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16297 type Value = SetSessionParamRequest;
16298
16299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16300 formatter.write_str("struct meta.SetSessionParamRequest")
16301 }
16302
16303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
16304 where
16305 V: serde::de::MapAccess<'de>,
16306 {
16307 let mut param__ = None;
16308 let mut value__ = None;
16309 while let Some(k) = map_.next_key()? {
16310 match k {
16311 GeneratedField::Param => {
16312 if param__.is_some() {
16313 return Err(serde::de::Error::duplicate_field("param"));
16314 }
16315 param__ = Some(map_.next_value()?);
16316 }
16317 GeneratedField::Value => {
16318 if value__.is_some() {
16319 return Err(serde::de::Error::duplicate_field("value"));
16320 }
16321 value__ = map_.next_value()?;
16322 }
16323 }
16324 }
16325 Ok(SetSessionParamRequest {
16326 param: param__.unwrap_or_default(),
16327 value: value__,
16328 })
16329 }
16330 }
16331 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
16332 }
16333}
16334impl serde::Serialize for SetSessionParamResponse {
16335 #[allow(deprecated)]
16336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16337 where
16338 S: serde::Serializer,
16339 {
16340 use serde::ser::SerializeStruct;
16341 let mut len = 0;
16342 if !self.param.is_empty() {
16343 len += 1;
16344 }
16345 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
16346 if !self.param.is_empty() {
16347 struct_ser.serialize_field("param", &self.param)?;
16348 }
16349 struct_ser.end()
16350 }
16351}
16352impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
16353 #[allow(deprecated)]
16354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16355 where
16356 D: serde::Deserializer<'de>,
16357 {
16358 const FIELDS: &[&str] = &[
16359 "param",
16360 ];
16361
16362 #[allow(clippy::enum_variant_names)]
16363 enum GeneratedField {
16364 Param,
16365 }
16366 impl<'de> serde::Deserialize<'de> for GeneratedField {
16367 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16368 where
16369 D: serde::Deserializer<'de>,
16370 {
16371 struct GeneratedVisitor;
16372
16373 impl serde::de::Visitor<'_> for GeneratedVisitor {
16374 type Value = GeneratedField;
16375
16376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16377 write!(formatter, "expected one of: {:?}", &FIELDS)
16378 }
16379
16380 #[allow(unused_variables)]
16381 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16382 where
16383 E: serde::de::Error,
16384 {
16385 match value {
16386 "param" => Ok(GeneratedField::Param),
16387 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16388 }
16389 }
16390 }
16391 deserializer.deserialize_identifier(GeneratedVisitor)
16392 }
16393 }
16394 struct GeneratedVisitor;
16395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16396 type Value = SetSessionParamResponse;
16397
16398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16399 formatter.write_str("struct meta.SetSessionParamResponse")
16400 }
16401
16402 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16403 where
16404 V: serde::de::MapAccess<'de>,
16405 {
16406 let mut param__ = None;
16407 while let Some(k) = map_.next_key()? {
16408 match k {
16409 GeneratedField::Param => {
16410 if param__.is_some() {
16411 return Err(serde::de::Error::duplicate_field("param"));
16412 }
16413 param__ = Some(map_.next_value()?);
16414 }
16415 }
16416 }
16417 Ok(SetSessionParamResponse {
16418 param: param__.unwrap_or_default(),
16419 })
16420 }
16421 }
16422 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16423 }
16424}
16425impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16426 #[allow(deprecated)]
16427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16428 where
16429 S: serde::Serializer,
16430 {
16431 use serde::ser::SerializeStruct;
16432 let mut len = 0;
16433 if self.job_id != 0 {
16434 len += 1;
16435 }
16436 if self.aligned {
16437 len += 1;
16438 }
16439 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16440 if self.job_id != 0 {
16441 struct_ser.serialize_field("jobId", &self.job_id)?;
16442 }
16443 if self.aligned {
16444 struct_ser.serialize_field("aligned", &self.aligned)?;
16445 }
16446 struct_ser.end()
16447 }
16448}
16449impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16450 #[allow(deprecated)]
16451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16452 where
16453 D: serde::Deserializer<'de>,
16454 {
16455 const FIELDS: &[&str] = &[
16456 "job_id",
16457 "jobId",
16458 "aligned",
16459 ];
16460
16461 #[allow(clippy::enum_variant_names)]
16462 enum GeneratedField {
16463 JobId,
16464 Aligned,
16465 }
16466 impl<'de> serde::Deserialize<'de> for GeneratedField {
16467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16468 where
16469 D: serde::Deserializer<'de>,
16470 {
16471 struct GeneratedVisitor;
16472
16473 impl serde::de::Visitor<'_> for GeneratedVisitor {
16474 type Value = GeneratedField;
16475
16476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16477 write!(formatter, "expected one of: {:?}", &FIELDS)
16478 }
16479
16480 #[allow(unused_variables)]
16481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16482 where
16483 E: serde::de::Error,
16484 {
16485 match value {
16486 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16487 "aligned" => Ok(GeneratedField::Aligned),
16488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16489 }
16490 }
16491 }
16492 deserializer.deserialize_identifier(GeneratedVisitor)
16493 }
16494 }
16495 struct GeneratedVisitor;
16496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16497 type Value = SetSyncLogStoreAlignedRequest;
16498
16499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16500 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16501 }
16502
16503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16504 where
16505 V: serde::de::MapAccess<'de>,
16506 {
16507 let mut job_id__ = None;
16508 let mut aligned__ = None;
16509 while let Some(k) = map_.next_key()? {
16510 match k {
16511 GeneratedField::JobId => {
16512 if job_id__.is_some() {
16513 return Err(serde::de::Error::duplicate_field("jobId"));
16514 }
16515 job_id__ =
16516 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16517 ;
16518 }
16519 GeneratedField::Aligned => {
16520 if aligned__.is_some() {
16521 return Err(serde::de::Error::duplicate_field("aligned"));
16522 }
16523 aligned__ = Some(map_.next_value()?);
16524 }
16525 }
16526 }
16527 Ok(SetSyncLogStoreAlignedRequest {
16528 job_id: job_id__.unwrap_or_default(),
16529 aligned: aligned__.unwrap_or_default(),
16530 })
16531 }
16532 }
16533 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16534 }
16535}
16536impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16537 #[allow(deprecated)]
16538 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16539 where
16540 S: serde::Serializer,
16541 {
16542 use serde::ser::SerializeStruct;
16543 let len = 0;
16544 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16545 struct_ser.end()
16546 }
16547}
16548impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16549 #[allow(deprecated)]
16550 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16551 where
16552 D: serde::Deserializer<'de>,
16553 {
16554 const FIELDS: &[&str] = &[
16555 ];
16556
16557 #[allow(clippy::enum_variant_names)]
16558 enum GeneratedField {
16559 }
16560 impl<'de> serde::Deserialize<'de> for GeneratedField {
16561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16562 where
16563 D: serde::Deserializer<'de>,
16564 {
16565 struct GeneratedVisitor;
16566
16567 impl serde::de::Visitor<'_> for GeneratedVisitor {
16568 type Value = GeneratedField;
16569
16570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16571 write!(formatter, "expected one of: {:?}", &FIELDS)
16572 }
16573
16574 #[allow(unused_variables)]
16575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16576 where
16577 E: serde::de::Error,
16578 {
16579 Err(serde::de::Error::unknown_field(value, FIELDS))
16580 }
16581 }
16582 deserializer.deserialize_identifier(GeneratedVisitor)
16583 }
16584 }
16585 struct GeneratedVisitor;
16586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16587 type Value = SetSyncLogStoreAlignedResponse;
16588
16589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16590 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
16591 }
16592
16593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
16594 where
16595 V: serde::de::MapAccess<'de>,
16596 {
16597 while map_.next_key::<GeneratedField>()?.is_some() {
16598 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16599 }
16600 Ok(SetSyncLogStoreAlignedResponse {
16601 })
16602 }
16603 }
16604 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
16605 }
16606}
16607impl serde::Serialize for SetSystemParamRequest {
16608 #[allow(deprecated)]
16609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16610 where
16611 S: serde::Serializer,
16612 {
16613 use serde::ser::SerializeStruct;
16614 let mut len = 0;
16615 if !self.param.is_empty() {
16616 len += 1;
16617 }
16618 if self.value.is_some() {
16619 len += 1;
16620 }
16621 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
16622 if !self.param.is_empty() {
16623 struct_ser.serialize_field("param", &self.param)?;
16624 }
16625 if let Some(v) = self.value.as_ref() {
16626 struct_ser.serialize_field("value", v)?;
16627 }
16628 struct_ser.end()
16629 }
16630}
16631impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
16632 #[allow(deprecated)]
16633 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16634 where
16635 D: serde::Deserializer<'de>,
16636 {
16637 const FIELDS: &[&str] = &[
16638 "param",
16639 "value",
16640 ];
16641
16642 #[allow(clippy::enum_variant_names)]
16643 enum GeneratedField {
16644 Param,
16645 Value,
16646 }
16647 impl<'de> serde::Deserialize<'de> for GeneratedField {
16648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16649 where
16650 D: serde::Deserializer<'de>,
16651 {
16652 struct GeneratedVisitor;
16653
16654 impl serde::de::Visitor<'_> for GeneratedVisitor {
16655 type Value = GeneratedField;
16656
16657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16658 write!(formatter, "expected one of: {:?}", &FIELDS)
16659 }
16660
16661 #[allow(unused_variables)]
16662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16663 where
16664 E: serde::de::Error,
16665 {
16666 match value {
16667 "param" => Ok(GeneratedField::Param),
16668 "value" => Ok(GeneratedField::Value),
16669 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16670 }
16671 }
16672 }
16673 deserializer.deserialize_identifier(GeneratedVisitor)
16674 }
16675 }
16676 struct GeneratedVisitor;
16677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16678 type Value = SetSystemParamRequest;
16679
16680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16681 formatter.write_str("struct meta.SetSystemParamRequest")
16682 }
16683
16684 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
16685 where
16686 V: serde::de::MapAccess<'de>,
16687 {
16688 let mut param__ = None;
16689 let mut value__ = None;
16690 while let Some(k) = map_.next_key()? {
16691 match k {
16692 GeneratedField::Param => {
16693 if param__.is_some() {
16694 return Err(serde::de::Error::duplicate_field("param"));
16695 }
16696 param__ = Some(map_.next_value()?);
16697 }
16698 GeneratedField::Value => {
16699 if value__.is_some() {
16700 return Err(serde::de::Error::duplicate_field("value"));
16701 }
16702 value__ = map_.next_value()?;
16703 }
16704 }
16705 }
16706 Ok(SetSystemParamRequest {
16707 param: param__.unwrap_or_default(),
16708 value: value__,
16709 })
16710 }
16711 }
16712 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
16713 }
16714}
16715impl serde::Serialize for SetSystemParamResponse {
16716 #[allow(deprecated)]
16717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16718 where
16719 S: serde::Serializer,
16720 {
16721 use serde::ser::SerializeStruct;
16722 let mut len = 0;
16723 if self.params.is_some() {
16724 len += 1;
16725 }
16726 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
16727 if let Some(v) = self.params.as_ref() {
16728 struct_ser.serialize_field("params", v)?;
16729 }
16730 struct_ser.end()
16731 }
16732}
16733impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
16734 #[allow(deprecated)]
16735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16736 where
16737 D: serde::Deserializer<'de>,
16738 {
16739 const FIELDS: &[&str] = &[
16740 "params",
16741 ];
16742
16743 #[allow(clippy::enum_variant_names)]
16744 enum GeneratedField {
16745 Params,
16746 }
16747 impl<'de> serde::Deserialize<'de> for GeneratedField {
16748 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16749 where
16750 D: serde::Deserializer<'de>,
16751 {
16752 struct GeneratedVisitor;
16753
16754 impl serde::de::Visitor<'_> for GeneratedVisitor {
16755 type Value = GeneratedField;
16756
16757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16758 write!(formatter, "expected one of: {:?}", &FIELDS)
16759 }
16760
16761 #[allow(unused_variables)]
16762 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16763 where
16764 E: serde::de::Error,
16765 {
16766 match value {
16767 "params" => Ok(GeneratedField::Params),
16768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16769 }
16770 }
16771 }
16772 deserializer.deserialize_identifier(GeneratedVisitor)
16773 }
16774 }
16775 struct GeneratedVisitor;
16776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16777 type Value = SetSystemParamResponse;
16778
16779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16780 formatter.write_str("struct meta.SetSystemParamResponse")
16781 }
16782
16783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
16784 where
16785 V: serde::de::MapAccess<'de>,
16786 {
16787 let mut params__ = None;
16788 while let Some(k) = map_.next_key()? {
16789 match k {
16790 GeneratedField::Params => {
16791 if params__.is_some() {
16792 return Err(serde::de::Error::duplicate_field("params"));
16793 }
16794 params__ = map_.next_value()?;
16795 }
16796 }
16797 }
16798 Ok(SetSystemParamResponse {
16799 params: params__,
16800 })
16801 }
16802 }
16803 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
16804 }
16805}
16806impl serde::Serialize for SubscribeRequest {
16807 #[allow(deprecated)]
16808 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16809 where
16810 S: serde::Serializer,
16811 {
16812 use serde::ser::SerializeStruct;
16813 let mut len = 0;
16814 if self.subscribe_type != 0 {
16815 len += 1;
16816 }
16817 if self.host.is_some() {
16818 len += 1;
16819 }
16820 if self.worker_id != 0 {
16821 len += 1;
16822 }
16823 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
16824 if self.subscribe_type != 0 {
16825 let v = SubscribeType::try_from(self.subscribe_type)
16826 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
16827 struct_ser.serialize_field("subscribeType", &v)?;
16828 }
16829 if let Some(v) = self.host.as_ref() {
16830 struct_ser.serialize_field("host", v)?;
16831 }
16832 if self.worker_id != 0 {
16833 struct_ser.serialize_field("workerId", &self.worker_id)?;
16834 }
16835 struct_ser.end()
16836 }
16837}
16838impl<'de> serde::Deserialize<'de> for SubscribeRequest {
16839 #[allow(deprecated)]
16840 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16841 where
16842 D: serde::Deserializer<'de>,
16843 {
16844 const FIELDS: &[&str] = &[
16845 "subscribe_type",
16846 "subscribeType",
16847 "host",
16848 "worker_id",
16849 "workerId",
16850 ];
16851
16852 #[allow(clippy::enum_variant_names)]
16853 enum GeneratedField {
16854 SubscribeType,
16855 Host,
16856 WorkerId,
16857 }
16858 impl<'de> serde::Deserialize<'de> for GeneratedField {
16859 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16860 where
16861 D: serde::Deserializer<'de>,
16862 {
16863 struct GeneratedVisitor;
16864
16865 impl serde::de::Visitor<'_> for GeneratedVisitor {
16866 type Value = GeneratedField;
16867
16868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16869 write!(formatter, "expected one of: {:?}", &FIELDS)
16870 }
16871
16872 #[allow(unused_variables)]
16873 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16874 where
16875 E: serde::de::Error,
16876 {
16877 match value {
16878 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
16879 "host" => Ok(GeneratedField::Host),
16880 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
16881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16882 }
16883 }
16884 }
16885 deserializer.deserialize_identifier(GeneratedVisitor)
16886 }
16887 }
16888 struct GeneratedVisitor;
16889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16890 type Value = SubscribeRequest;
16891
16892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16893 formatter.write_str("struct meta.SubscribeRequest")
16894 }
16895
16896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
16897 where
16898 V: serde::de::MapAccess<'de>,
16899 {
16900 let mut subscribe_type__ = None;
16901 let mut host__ = None;
16902 let mut worker_id__ = None;
16903 while let Some(k) = map_.next_key()? {
16904 match k {
16905 GeneratedField::SubscribeType => {
16906 if subscribe_type__.is_some() {
16907 return Err(serde::de::Error::duplicate_field("subscribeType"));
16908 }
16909 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
16910 }
16911 GeneratedField::Host => {
16912 if host__.is_some() {
16913 return Err(serde::de::Error::duplicate_field("host"));
16914 }
16915 host__ = map_.next_value()?;
16916 }
16917 GeneratedField::WorkerId => {
16918 if worker_id__.is_some() {
16919 return Err(serde::de::Error::duplicate_field("workerId"));
16920 }
16921 worker_id__ =
16922 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16923 ;
16924 }
16925 }
16926 }
16927 Ok(SubscribeRequest {
16928 subscribe_type: subscribe_type__.unwrap_or_default(),
16929 host: host__,
16930 worker_id: worker_id__.unwrap_or_default(),
16931 })
16932 }
16933 }
16934 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
16935 }
16936}
16937impl serde::Serialize for SubscribeResponse {
16938 #[allow(deprecated)]
16939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16940 where
16941 S: serde::Serializer,
16942 {
16943 use serde::ser::SerializeStruct;
16944 let mut len = 0;
16945 if self.status.is_some() {
16946 len += 1;
16947 }
16948 if self.operation != 0 {
16949 len += 1;
16950 }
16951 if self.version != 0 {
16952 len += 1;
16953 }
16954 if self.info.is_some() {
16955 len += 1;
16956 }
16957 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
16958 if let Some(v) = self.status.as_ref() {
16959 struct_ser.serialize_field("status", v)?;
16960 }
16961 if self.operation != 0 {
16962 let v = subscribe_response::Operation::try_from(self.operation)
16963 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
16964 struct_ser.serialize_field("operation", &v)?;
16965 }
16966 if self.version != 0 {
16967 #[allow(clippy::needless_borrow)]
16968 #[allow(clippy::needless_borrows_for_generic_args)]
16969 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
16970 }
16971 if let Some(v) = self.info.as_ref() {
16972 match v {
16973 subscribe_response::Info::Database(v) => {
16974 struct_ser.serialize_field("database", v)?;
16975 }
16976 subscribe_response::Info::Schema(v) => {
16977 struct_ser.serialize_field("schema", v)?;
16978 }
16979 subscribe_response::Info::Function(v) => {
16980 struct_ser.serialize_field("function", v)?;
16981 }
16982 subscribe_response::Info::User(v) => {
16983 struct_ser.serialize_field("user", v)?;
16984 }
16985 subscribe_response::Info::SessionParam(v) => {
16986 struct_ser.serialize_field("sessionParam", v)?;
16987 }
16988 subscribe_response::Info::Node(v) => {
16989 struct_ser.serialize_field("node", v)?;
16990 }
16991 subscribe_response::Info::HummockVersionDeltas(v) => {
16992 struct_ser.serialize_field("hummockVersionDeltas", v)?;
16993 }
16994 subscribe_response::Info::Snapshot(v) => {
16995 struct_ser.serialize_field("snapshot", v)?;
16996 }
16997 subscribe_response::Info::MetaBackupManifestId(v) => {
16998 struct_ser.serialize_field("metaBackupManifestId", v)?;
16999 }
17000 subscribe_response::Info::SystemParams(v) => {
17001 struct_ser.serialize_field("systemParams", v)?;
17002 }
17003 subscribe_response::Info::HummockWriteLimits(v) => {
17004 struct_ser.serialize_field("hummockWriteLimits", v)?;
17005 }
17006 subscribe_response::Info::ObjectGroup(v) => {
17007 struct_ser.serialize_field("objectGroup", v)?;
17008 }
17009 subscribe_response::Info::Connection(v) => {
17010 struct_ser.serialize_field("connection", v)?;
17011 }
17012 subscribe_response::Info::HummockStats(v) => {
17013 struct_ser.serialize_field("hummockStats", v)?;
17014 }
17015 subscribe_response::Info::Recovery(v) => {
17016 struct_ser.serialize_field("recovery", v)?;
17017 }
17018 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
17019 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
17020 }
17021 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
17022 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
17023 }
17024 subscribe_response::Info::Secret(v) => {
17025 struct_ser.serialize_field("secret", v)?;
17026 }
17027 subscribe_response::Info::ClusterResource(v) => {
17028 struct_ser.serialize_field("clusterResource", v)?;
17029 }
17030 }
17031 }
17032 struct_ser.end()
17033 }
17034}
17035impl<'de> serde::Deserialize<'de> for SubscribeResponse {
17036 #[allow(deprecated)]
17037 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17038 where
17039 D: serde::Deserializer<'de>,
17040 {
17041 const FIELDS: &[&str] = &[
17042 "status",
17043 "operation",
17044 "version",
17045 "database",
17046 "schema",
17047 "function",
17048 "user",
17049 "session_param",
17050 "sessionParam",
17051 "node",
17052 "hummock_version_deltas",
17053 "hummockVersionDeltas",
17054 "snapshot",
17055 "meta_backup_manifest_id",
17056 "metaBackupManifestId",
17057 "system_params",
17058 "systemParams",
17059 "hummock_write_limits",
17060 "hummockWriteLimits",
17061 "object_group",
17062 "objectGroup",
17063 "connection",
17064 "hummock_stats",
17065 "hummockStats",
17066 "recovery",
17067 "streaming_worker_slot_mapping",
17068 "streamingWorkerSlotMapping",
17069 "serving_worker_slot_mappings",
17070 "servingWorkerSlotMappings",
17071 "secret",
17072 "cluster_resource",
17073 "clusterResource",
17074 ];
17075
17076 #[allow(clippy::enum_variant_names)]
17077 enum GeneratedField {
17078 Status,
17079 Operation,
17080 Version,
17081 Database,
17082 Schema,
17083 Function,
17084 User,
17085 SessionParam,
17086 Node,
17087 HummockVersionDeltas,
17088 Snapshot,
17089 MetaBackupManifestId,
17090 SystemParams,
17091 HummockWriteLimits,
17092 ObjectGroup,
17093 Connection,
17094 HummockStats,
17095 Recovery,
17096 StreamingWorkerSlotMapping,
17097 ServingWorkerSlotMappings,
17098 Secret,
17099 ClusterResource,
17100 }
17101 impl<'de> serde::Deserialize<'de> for GeneratedField {
17102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17103 where
17104 D: serde::Deserializer<'de>,
17105 {
17106 struct GeneratedVisitor;
17107
17108 impl serde::de::Visitor<'_> for GeneratedVisitor {
17109 type Value = GeneratedField;
17110
17111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17112 write!(formatter, "expected one of: {:?}", &FIELDS)
17113 }
17114
17115 #[allow(unused_variables)]
17116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17117 where
17118 E: serde::de::Error,
17119 {
17120 match value {
17121 "status" => Ok(GeneratedField::Status),
17122 "operation" => Ok(GeneratedField::Operation),
17123 "version" => Ok(GeneratedField::Version),
17124 "database" => Ok(GeneratedField::Database),
17125 "schema" => Ok(GeneratedField::Schema),
17126 "function" => Ok(GeneratedField::Function),
17127 "user" => Ok(GeneratedField::User),
17128 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
17129 "node" => Ok(GeneratedField::Node),
17130 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
17131 "snapshot" => Ok(GeneratedField::Snapshot),
17132 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
17133 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
17134 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
17135 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
17136 "connection" => Ok(GeneratedField::Connection),
17137 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
17138 "recovery" => Ok(GeneratedField::Recovery),
17139 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
17140 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
17141 "secret" => Ok(GeneratedField::Secret),
17142 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
17143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17144 }
17145 }
17146 }
17147 deserializer.deserialize_identifier(GeneratedVisitor)
17148 }
17149 }
17150 struct GeneratedVisitor;
17151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17152 type Value = SubscribeResponse;
17153
17154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17155 formatter.write_str("struct meta.SubscribeResponse")
17156 }
17157
17158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
17159 where
17160 V: serde::de::MapAccess<'de>,
17161 {
17162 let mut status__ = None;
17163 let mut operation__ = None;
17164 let mut version__ = None;
17165 let mut info__ = None;
17166 while let Some(k) = map_.next_key()? {
17167 match k {
17168 GeneratedField::Status => {
17169 if status__.is_some() {
17170 return Err(serde::de::Error::duplicate_field("status"));
17171 }
17172 status__ = map_.next_value()?;
17173 }
17174 GeneratedField::Operation => {
17175 if operation__.is_some() {
17176 return Err(serde::de::Error::duplicate_field("operation"));
17177 }
17178 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
17179 }
17180 GeneratedField::Version => {
17181 if version__.is_some() {
17182 return Err(serde::de::Error::duplicate_field("version"));
17183 }
17184 version__ =
17185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17186 ;
17187 }
17188 GeneratedField::Database => {
17189 if info__.is_some() {
17190 return Err(serde::de::Error::duplicate_field("database"));
17191 }
17192 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
17193;
17194 }
17195 GeneratedField::Schema => {
17196 if info__.is_some() {
17197 return Err(serde::de::Error::duplicate_field("schema"));
17198 }
17199 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
17200;
17201 }
17202 GeneratedField::Function => {
17203 if info__.is_some() {
17204 return Err(serde::de::Error::duplicate_field("function"));
17205 }
17206 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
17207;
17208 }
17209 GeneratedField::User => {
17210 if info__.is_some() {
17211 return Err(serde::de::Error::duplicate_field("user"));
17212 }
17213 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
17214;
17215 }
17216 GeneratedField::SessionParam => {
17217 if info__.is_some() {
17218 return Err(serde::de::Error::duplicate_field("sessionParam"));
17219 }
17220 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
17221;
17222 }
17223 GeneratedField::Node => {
17224 if info__.is_some() {
17225 return Err(serde::de::Error::duplicate_field("node"));
17226 }
17227 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
17228;
17229 }
17230 GeneratedField::HummockVersionDeltas => {
17231 if info__.is_some() {
17232 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
17233 }
17234 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
17235;
17236 }
17237 GeneratedField::Snapshot => {
17238 if info__.is_some() {
17239 return Err(serde::de::Error::duplicate_field("snapshot"));
17240 }
17241 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
17242;
17243 }
17244 GeneratedField::MetaBackupManifestId => {
17245 if info__.is_some() {
17246 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
17247 }
17248 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
17249;
17250 }
17251 GeneratedField::SystemParams => {
17252 if info__.is_some() {
17253 return Err(serde::de::Error::duplicate_field("systemParams"));
17254 }
17255 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
17256;
17257 }
17258 GeneratedField::HummockWriteLimits => {
17259 if info__.is_some() {
17260 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
17261 }
17262 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
17263;
17264 }
17265 GeneratedField::ObjectGroup => {
17266 if info__.is_some() {
17267 return Err(serde::de::Error::duplicate_field("objectGroup"));
17268 }
17269 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
17270;
17271 }
17272 GeneratedField::Connection => {
17273 if info__.is_some() {
17274 return Err(serde::de::Error::duplicate_field("connection"));
17275 }
17276 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
17277;
17278 }
17279 GeneratedField::HummockStats => {
17280 if info__.is_some() {
17281 return Err(serde::de::Error::duplicate_field("hummockStats"));
17282 }
17283 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
17284;
17285 }
17286 GeneratedField::Recovery => {
17287 if info__.is_some() {
17288 return Err(serde::de::Error::duplicate_field("recovery"));
17289 }
17290 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
17291;
17292 }
17293 GeneratedField::StreamingWorkerSlotMapping => {
17294 if info__.is_some() {
17295 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
17296 }
17297 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
17298;
17299 }
17300 GeneratedField::ServingWorkerSlotMappings => {
17301 if info__.is_some() {
17302 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
17303 }
17304 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
17305;
17306 }
17307 GeneratedField::Secret => {
17308 if info__.is_some() {
17309 return Err(serde::de::Error::duplicate_field("secret"));
17310 }
17311 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
17312;
17313 }
17314 GeneratedField::ClusterResource => {
17315 if info__.is_some() {
17316 return Err(serde::de::Error::duplicate_field("clusterResource"));
17317 }
17318 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
17319;
17320 }
17321 }
17322 }
17323 Ok(SubscribeResponse {
17324 status: status__,
17325 operation: operation__.unwrap_or_default(),
17326 version: version__.unwrap_or_default(),
17327 info: info__,
17328 })
17329 }
17330 }
17331 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
17332 }
17333}
17334impl serde::Serialize for subscribe_response::Operation {
17335 #[allow(deprecated)]
17336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17337 where
17338 S: serde::Serializer,
17339 {
17340 let variant = match self {
17341 Self::Unspecified => "UNSPECIFIED",
17342 Self::Add => "ADD",
17343 Self::Delete => "DELETE",
17344 Self::Update => "UPDATE",
17345 Self::Snapshot => "SNAPSHOT",
17346 };
17347 serializer.serialize_str(variant)
17348 }
17349}
17350impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
17351 #[allow(deprecated)]
17352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17353 where
17354 D: serde::Deserializer<'de>,
17355 {
17356 const FIELDS: &[&str] = &[
17357 "UNSPECIFIED",
17358 "ADD",
17359 "DELETE",
17360 "UPDATE",
17361 "SNAPSHOT",
17362 ];
17363
17364 struct GeneratedVisitor;
17365
17366 impl serde::de::Visitor<'_> for GeneratedVisitor {
17367 type Value = subscribe_response::Operation;
17368
17369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17370 write!(formatter, "expected one of: {:?}", &FIELDS)
17371 }
17372
17373 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17374 where
17375 E: serde::de::Error,
17376 {
17377 i32::try_from(v)
17378 .ok()
17379 .and_then(|x| x.try_into().ok())
17380 .ok_or_else(|| {
17381 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17382 })
17383 }
17384
17385 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17386 where
17387 E: serde::de::Error,
17388 {
17389 i32::try_from(v)
17390 .ok()
17391 .and_then(|x| x.try_into().ok())
17392 .ok_or_else(|| {
17393 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17394 })
17395 }
17396
17397 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17398 where
17399 E: serde::de::Error,
17400 {
17401 match value {
17402 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17403 "ADD" => Ok(subscribe_response::Operation::Add),
17404 "DELETE" => Ok(subscribe_response::Operation::Delete),
17405 "UPDATE" => Ok(subscribe_response::Operation::Update),
17406 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17407 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17408 }
17409 }
17410 }
17411 deserializer.deserialize_any(GeneratedVisitor)
17412 }
17413}
17414impl serde::Serialize for SubscribeType {
17415 #[allow(deprecated)]
17416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17417 where
17418 S: serde::Serializer,
17419 {
17420 let variant = match self {
17421 Self::Unspecified => "UNSPECIFIED",
17422 Self::Frontend => "FRONTEND",
17423 Self::Hummock => "HUMMOCK",
17424 Self::Compactor => "COMPACTOR",
17425 Self::Compute => "COMPUTE",
17426 };
17427 serializer.serialize_str(variant)
17428 }
17429}
17430impl<'de> serde::Deserialize<'de> for SubscribeType {
17431 #[allow(deprecated)]
17432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17433 where
17434 D: serde::Deserializer<'de>,
17435 {
17436 const FIELDS: &[&str] = &[
17437 "UNSPECIFIED",
17438 "FRONTEND",
17439 "HUMMOCK",
17440 "COMPACTOR",
17441 "COMPUTE",
17442 ];
17443
17444 struct GeneratedVisitor;
17445
17446 impl serde::de::Visitor<'_> for GeneratedVisitor {
17447 type Value = SubscribeType;
17448
17449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17450 write!(formatter, "expected one of: {:?}", &FIELDS)
17451 }
17452
17453 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17454 where
17455 E: serde::de::Error,
17456 {
17457 i32::try_from(v)
17458 .ok()
17459 .and_then(|x| x.try_into().ok())
17460 .ok_or_else(|| {
17461 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17462 })
17463 }
17464
17465 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17466 where
17467 E: serde::de::Error,
17468 {
17469 i32::try_from(v)
17470 .ok()
17471 .and_then(|x| x.try_into().ok())
17472 .ok_or_else(|| {
17473 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17474 })
17475 }
17476
17477 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17478 where
17479 E: serde::de::Error,
17480 {
17481 match value {
17482 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17483 "FRONTEND" => Ok(SubscribeType::Frontend),
17484 "HUMMOCK" => Ok(SubscribeType::Hummock),
17485 "COMPACTOR" => Ok(SubscribeType::Compactor),
17486 "COMPUTE" => Ok(SubscribeType::Compute),
17487 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17488 }
17489 }
17490 }
17491 deserializer.deserialize_any(GeneratedVisitor)
17492 }
17493}
17494impl serde::Serialize for SystemParams {
17495 #[allow(deprecated)]
17496 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17497 where
17498 S: serde::Serializer,
17499 {
17500 use serde::ser::SerializeStruct;
17501 let mut len = 0;
17502 if self.barrier_interval_ms.is_some() {
17503 len += 1;
17504 }
17505 if self.checkpoint_frequency.is_some() {
17506 len += 1;
17507 }
17508 if self.sstable_size_mb.is_some() {
17509 len += 1;
17510 }
17511 if self.block_size_kb.is_some() {
17512 len += 1;
17513 }
17514 if self.bloom_false_positive.is_some() {
17515 len += 1;
17516 }
17517 if self.state_store.is_some() {
17518 len += 1;
17519 }
17520 if self.data_directory.is_some() {
17521 len += 1;
17522 }
17523 if self.backup_storage_url.is_some() {
17524 len += 1;
17525 }
17526 if self.backup_storage_directory.is_some() {
17527 len += 1;
17528 }
17529 if self.telemetry_enabled.is_some() {
17530 len += 1;
17531 }
17532 if self.parallel_compact_size_mb.is_some() {
17533 len += 1;
17534 }
17535 if self.max_concurrent_creating_streaming_jobs.is_some() {
17536 len += 1;
17537 }
17538 if self.pause_on_next_bootstrap.is_some() {
17539 len += 1;
17540 }
17541 if self.wasm_storage_url.is_some() {
17542 len += 1;
17543 }
17544 if self.enable_tracing.is_some() {
17545 len += 1;
17546 }
17547 if self.use_new_object_prefix_strategy.is_some() {
17548 len += 1;
17549 }
17550 if self.license_key.is_some() {
17551 len += 1;
17552 }
17553 if self.time_travel_retention_ms.is_some() {
17554 len += 1;
17555 }
17556 if self.adaptive_parallelism_strategy.is_some() {
17557 len += 1;
17558 }
17559 if self.per_database_isolation.is_some() {
17560 len += 1;
17561 }
17562 if self.enforce_secret.is_some() {
17563 len += 1;
17564 }
17565 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
17566 if let Some(v) = self.barrier_interval_ms.as_ref() {
17567 struct_ser.serialize_field("barrierIntervalMs", v)?;
17568 }
17569 if let Some(v) = self.checkpoint_frequency.as_ref() {
17570 #[allow(clippy::needless_borrow)]
17571 #[allow(clippy::needless_borrows_for_generic_args)]
17572 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
17573 }
17574 if let Some(v) = self.sstable_size_mb.as_ref() {
17575 struct_ser.serialize_field("sstableSizeMb", v)?;
17576 }
17577 if let Some(v) = self.block_size_kb.as_ref() {
17578 struct_ser.serialize_field("blockSizeKb", v)?;
17579 }
17580 if let Some(v) = self.bloom_false_positive.as_ref() {
17581 struct_ser.serialize_field("bloomFalsePositive", v)?;
17582 }
17583 if let Some(v) = self.state_store.as_ref() {
17584 struct_ser.serialize_field("stateStore", v)?;
17585 }
17586 if let Some(v) = self.data_directory.as_ref() {
17587 struct_ser.serialize_field("dataDirectory", v)?;
17588 }
17589 if let Some(v) = self.backup_storage_url.as_ref() {
17590 struct_ser.serialize_field("backupStorageUrl", v)?;
17591 }
17592 if let Some(v) = self.backup_storage_directory.as_ref() {
17593 struct_ser.serialize_field("backupStorageDirectory", v)?;
17594 }
17595 if let Some(v) = self.telemetry_enabled.as_ref() {
17596 struct_ser.serialize_field("telemetryEnabled", v)?;
17597 }
17598 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
17599 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
17600 }
17601 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
17602 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
17603 }
17604 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
17605 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
17606 }
17607 if let Some(v) = self.wasm_storage_url.as_ref() {
17608 struct_ser.serialize_field("wasmStorageUrl", v)?;
17609 }
17610 if let Some(v) = self.enable_tracing.as_ref() {
17611 struct_ser.serialize_field("enableTracing", v)?;
17612 }
17613 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
17614 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
17615 }
17616 if let Some(v) = self.license_key.as_ref() {
17617 struct_ser.serialize_field("licenseKey", v)?;
17618 }
17619 if let Some(v) = self.time_travel_retention_ms.as_ref() {
17620 #[allow(clippy::needless_borrow)]
17621 #[allow(clippy::needless_borrows_for_generic_args)]
17622 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
17623 }
17624 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
17625 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
17626 }
17627 if let Some(v) = self.per_database_isolation.as_ref() {
17628 struct_ser.serialize_field("perDatabaseIsolation", v)?;
17629 }
17630 if let Some(v) = self.enforce_secret.as_ref() {
17631 struct_ser.serialize_field("enforceSecret", v)?;
17632 }
17633 struct_ser.end()
17634 }
17635}
17636impl<'de> serde::Deserialize<'de> for SystemParams {
17637 #[allow(deprecated)]
17638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17639 where
17640 D: serde::Deserializer<'de>,
17641 {
17642 const FIELDS: &[&str] = &[
17643 "barrier_interval_ms",
17644 "barrierIntervalMs",
17645 "checkpoint_frequency",
17646 "checkpointFrequency",
17647 "sstable_size_mb",
17648 "sstableSizeMb",
17649 "block_size_kb",
17650 "blockSizeKb",
17651 "bloom_false_positive",
17652 "bloomFalsePositive",
17653 "state_store",
17654 "stateStore",
17655 "data_directory",
17656 "dataDirectory",
17657 "backup_storage_url",
17658 "backupStorageUrl",
17659 "backup_storage_directory",
17660 "backupStorageDirectory",
17661 "telemetry_enabled",
17662 "telemetryEnabled",
17663 "parallel_compact_size_mb",
17664 "parallelCompactSizeMb",
17665 "max_concurrent_creating_streaming_jobs",
17666 "maxConcurrentCreatingStreamingJobs",
17667 "pause_on_next_bootstrap",
17668 "pauseOnNextBootstrap",
17669 "wasm_storage_url",
17670 "wasmStorageUrl",
17671 "enable_tracing",
17672 "enableTracing",
17673 "use_new_object_prefix_strategy",
17674 "useNewObjectPrefixStrategy",
17675 "license_key",
17676 "licenseKey",
17677 "time_travel_retention_ms",
17678 "timeTravelRetentionMs",
17679 "adaptive_parallelism_strategy",
17680 "adaptiveParallelismStrategy",
17681 "per_database_isolation",
17682 "perDatabaseIsolation",
17683 "enforce_secret",
17684 "enforceSecret",
17685 ];
17686
17687 #[allow(clippy::enum_variant_names)]
17688 enum GeneratedField {
17689 BarrierIntervalMs,
17690 CheckpointFrequency,
17691 SstableSizeMb,
17692 BlockSizeKb,
17693 BloomFalsePositive,
17694 StateStore,
17695 DataDirectory,
17696 BackupStorageUrl,
17697 BackupStorageDirectory,
17698 TelemetryEnabled,
17699 ParallelCompactSizeMb,
17700 MaxConcurrentCreatingStreamingJobs,
17701 PauseOnNextBootstrap,
17702 WasmStorageUrl,
17703 EnableTracing,
17704 UseNewObjectPrefixStrategy,
17705 LicenseKey,
17706 TimeTravelRetentionMs,
17707 AdaptiveParallelismStrategy,
17708 PerDatabaseIsolation,
17709 EnforceSecret,
17710 }
17711 impl<'de> serde::Deserialize<'de> for GeneratedField {
17712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17713 where
17714 D: serde::Deserializer<'de>,
17715 {
17716 struct GeneratedVisitor;
17717
17718 impl serde::de::Visitor<'_> for GeneratedVisitor {
17719 type Value = GeneratedField;
17720
17721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17722 write!(formatter, "expected one of: {:?}", &FIELDS)
17723 }
17724
17725 #[allow(unused_variables)]
17726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17727 where
17728 E: serde::de::Error,
17729 {
17730 match value {
17731 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
17732 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
17733 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
17734 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
17735 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
17736 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
17737 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
17738 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
17739 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
17740 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
17741 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
17742 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
17743 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
17744 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
17745 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
17746 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
17747 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
17748 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
17749 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
17750 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
17751 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
17752 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17753 }
17754 }
17755 }
17756 deserializer.deserialize_identifier(GeneratedVisitor)
17757 }
17758 }
17759 struct GeneratedVisitor;
17760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17761 type Value = SystemParams;
17762
17763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17764 formatter.write_str("struct meta.SystemParams")
17765 }
17766
17767 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
17768 where
17769 V: serde::de::MapAccess<'de>,
17770 {
17771 let mut barrier_interval_ms__ = None;
17772 let mut checkpoint_frequency__ = None;
17773 let mut sstable_size_mb__ = None;
17774 let mut block_size_kb__ = None;
17775 let mut bloom_false_positive__ = None;
17776 let mut state_store__ = None;
17777 let mut data_directory__ = None;
17778 let mut backup_storage_url__ = None;
17779 let mut backup_storage_directory__ = None;
17780 let mut telemetry_enabled__ = None;
17781 let mut parallel_compact_size_mb__ = None;
17782 let mut max_concurrent_creating_streaming_jobs__ = None;
17783 let mut pause_on_next_bootstrap__ = None;
17784 let mut wasm_storage_url__ = None;
17785 let mut enable_tracing__ = None;
17786 let mut use_new_object_prefix_strategy__ = None;
17787 let mut license_key__ = None;
17788 let mut time_travel_retention_ms__ = None;
17789 let mut adaptive_parallelism_strategy__ = None;
17790 let mut per_database_isolation__ = None;
17791 let mut enforce_secret__ = None;
17792 while let Some(k) = map_.next_key()? {
17793 match k {
17794 GeneratedField::BarrierIntervalMs => {
17795 if barrier_interval_ms__.is_some() {
17796 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
17797 }
17798 barrier_interval_ms__ =
17799 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17800 ;
17801 }
17802 GeneratedField::CheckpointFrequency => {
17803 if checkpoint_frequency__.is_some() {
17804 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
17805 }
17806 checkpoint_frequency__ =
17807 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17808 ;
17809 }
17810 GeneratedField::SstableSizeMb => {
17811 if sstable_size_mb__.is_some() {
17812 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
17813 }
17814 sstable_size_mb__ =
17815 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17816 ;
17817 }
17818 GeneratedField::BlockSizeKb => {
17819 if block_size_kb__.is_some() {
17820 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
17821 }
17822 block_size_kb__ =
17823 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17824 ;
17825 }
17826 GeneratedField::BloomFalsePositive => {
17827 if bloom_false_positive__.is_some() {
17828 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
17829 }
17830 bloom_false_positive__ =
17831 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17832 ;
17833 }
17834 GeneratedField::StateStore => {
17835 if state_store__.is_some() {
17836 return Err(serde::de::Error::duplicate_field("stateStore"));
17837 }
17838 state_store__ = map_.next_value()?;
17839 }
17840 GeneratedField::DataDirectory => {
17841 if data_directory__.is_some() {
17842 return Err(serde::de::Error::duplicate_field("dataDirectory"));
17843 }
17844 data_directory__ = map_.next_value()?;
17845 }
17846 GeneratedField::BackupStorageUrl => {
17847 if backup_storage_url__.is_some() {
17848 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
17849 }
17850 backup_storage_url__ = map_.next_value()?;
17851 }
17852 GeneratedField::BackupStorageDirectory => {
17853 if backup_storage_directory__.is_some() {
17854 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
17855 }
17856 backup_storage_directory__ = map_.next_value()?;
17857 }
17858 GeneratedField::TelemetryEnabled => {
17859 if telemetry_enabled__.is_some() {
17860 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
17861 }
17862 telemetry_enabled__ = map_.next_value()?;
17863 }
17864 GeneratedField::ParallelCompactSizeMb => {
17865 if parallel_compact_size_mb__.is_some() {
17866 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
17867 }
17868 parallel_compact_size_mb__ =
17869 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17870 ;
17871 }
17872 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
17873 if max_concurrent_creating_streaming_jobs__.is_some() {
17874 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
17875 }
17876 max_concurrent_creating_streaming_jobs__ =
17877 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17878 ;
17879 }
17880 GeneratedField::PauseOnNextBootstrap => {
17881 if pause_on_next_bootstrap__.is_some() {
17882 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
17883 }
17884 pause_on_next_bootstrap__ = map_.next_value()?;
17885 }
17886 GeneratedField::WasmStorageUrl => {
17887 if wasm_storage_url__.is_some() {
17888 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
17889 }
17890 wasm_storage_url__ = map_.next_value()?;
17891 }
17892 GeneratedField::EnableTracing => {
17893 if enable_tracing__.is_some() {
17894 return Err(serde::de::Error::duplicate_field("enableTracing"));
17895 }
17896 enable_tracing__ = map_.next_value()?;
17897 }
17898 GeneratedField::UseNewObjectPrefixStrategy => {
17899 if use_new_object_prefix_strategy__.is_some() {
17900 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
17901 }
17902 use_new_object_prefix_strategy__ = map_.next_value()?;
17903 }
17904 GeneratedField::LicenseKey => {
17905 if license_key__.is_some() {
17906 return Err(serde::de::Error::duplicate_field("licenseKey"));
17907 }
17908 license_key__ = map_.next_value()?;
17909 }
17910 GeneratedField::TimeTravelRetentionMs => {
17911 if time_travel_retention_ms__.is_some() {
17912 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
17913 }
17914 time_travel_retention_ms__ =
17915 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17916 ;
17917 }
17918 GeneratedField::AdaptiveParallelismStrategy => {
17919 if adaptive_parallelism_strategy__.is_some() {
17920 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
17921 }
17922 adaptive_parallelism_strategy__ = map_.next_value()?;
17923 }
17924 GeneratedField::PerDatabaseIsolation => {
17925 if per_database_isolation__.is_some() {
17926 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
17927 }
17928 per_database_isolation__ = map_.next_value()?;
17929 }
17930 GeneratedField::EnforceSecret => {
17931 if enforce_secret__.is_some() {
17932 return Err(serde::de::Error::duplicate_field("enforceSecret"));
17933 }
17934 enforce_secret__ = map_.next_value()?;
17935 }
17936 }
17937 }
17938 Ok(SystemParams {
17939 barrier_interval_ms: barrier_interval_ms__,
17940 checkpoint_frequency: checkpoint_frequency__,
17941 sstable_size_mb: sstable_size_mb__,
17942 block_size_kb: block_size_kb__,
17943 bloom_false_positive: bloom_false_positive__,
17944 state_store: state_store__,
17945 data_directory: data_directory__,
17946 backup_storage_url: backup_storage_url__,
17947 backup_storage_directory: backup_storage_directory__,
17948 telemetry_enabled: telemetry_enabled__,
17949 parallel_compact_size_mb: parallel_compact_size_mb__,
17950 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
17951 pause_on_next_bootstrap: pause_on_next_bootstrap__,
17952 wasm_storage_url: wasm_storage_url__,
17953 enable_tracing: enable_tracing__,
17954 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
17955 license_key: license_key__,
17956 time_travel_retention_ms: time_travel_retention_ms__,
17957 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
17958 per_database_isolation: per_database_isolation__,
17959 enforce_secret: enforce_secret__,
17960 })
17961 }
17962 }
17963 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
17964 }
17965}
17966impl serde::Serialize for TableFragments {
17967 #[allow(deprecated)]
17968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17969 where
17970 S: serde::Serializer,
17971 {
17972 use serde::ser::SerializeStruct;
17973 let mut len = 0;
17974 if self.table_id != 0 {
17975 len += 1;
17976 }
17977 if self.state != 0 {
17978 len += 1;
17979 }
17980 if !self.fragments.is_empty() {
17981 len += 1;
17982 }
17983 if !self.actor_status.is_empty() {
17984 len += 1;
17985 }
17986 if self.ctx.is_some() {
17987 len += 1;
17988 }
17989 if self.parallelism.is_some() {
17990 len += 1;
17991 }
17992 if self.max_parallelism.is_some() {
17993 len += 1;
17994 }
17995 if !self.node_label.is_empty() {
17996 len += 1;
17997 }
17998 if self.backfill_done {
17999 len += 1;
18000 }
18001 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
18002 if self.table_id != 0 {
18003 struct_ser.serialize_field("tableId", &self.table_id)?;
18004 }
18005 if self.state != 0 {
18006 let v = table_fragments::State::try_from(self.state)
18007 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
18008 struct_ser.serialize_field("state", &v)?;
18009 }
18010 if !self.fragments.is_empty() {
18011 struct_ser.serialize_field("fragments", &self.fragments)?;
18012 }
18013 if !self.actor_status.is_empty() {
18014 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
18015 }
18016 if let Some(v) = self.ctx.as_ref() {
18017 struct_ser.serialize_field("ctx", v)?;
18018 }
18019 if let Some(v) = self.parallelism.as_ref() {
18020 struct_ser.serialize_field("parallelism", v)?;
18021 }
18022 if let Some(v) = self.max_parallelism.as_ref() {
18023 struct_ser.serialize_field("maxParallelism", v)?;
18024 }
18025 if !self.node_label.is_empty() {
18026 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18027 }
18028 if self.backfill_done {
18029 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
18030 }
18031 struct_ser.end()
18032 }
18033}
18034impl<'de> serde::Deserialize<'de> for TableFragments {
18035 #[allow(deprecated)]
18036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18037 where
18038 D: serde::Deserializer<'de>,
18039 {
18040 const FIELDS: &[&str] = &[
18041 "table_id",
18042 "tableId",
18043 "state",
18044 "fragments",
18045 "actor_status",
18046 "actorStatus",
18047 "ctx",
18048 "parallelism",
18049 "max_parallelism",
18050 "maxParallelism",
18051 "node_label",
18052 "nodeLabel",
18053 "backfill_done",
18054 "backfillDone",
18055 ];
18056
18057 #[allow(clippy::enum_variant_names)]
18058 enum GeneratedField {
18059 TableId,
18060 State,
18061 Fragments,
18062 ActorStatus,
18063 Ctx,
18064 Parallelism,
18065 MaxParallelism,
18066 NodeLabel,
18067 BackfillDone,
18068 }
18069 impl<'de> serde::Deserialize<'de> for GeneratedField {
18070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18071 where
18072 D: serde::Deserializer<'de>,
18073 {
18074 struct GeneratedVisitor;
18075
18076 impl serde::de::Visitor<'_> for GeneratedVisitor {
18077 type Value = GeneratedField;
18078
18079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18080 write!(formatter, "expected one of: {:?}", &FIELDS)
18081 }
18082
18083 #[allow(unused_variables)]
18084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18085 where
18086 E: serde::de::Error,
18087 {
18088 match value {
18089 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18090 "state" => Ok(GeneratedField::State),
18091 "fragments" => Ok(GeneratedField::Fragments),
18092 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
18093 "ctx" => Ok(GeneratedField::Ctx),
18094 "parallelism" => Ok(GeneratedField::Parallelism),
18095 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
18096 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18097 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
18098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18099 }
18100 }
18101 }
18102 deserializer.deserialize_identifier(GeneratedVisitor)
18103 }
18104 }
18105 struct GeneratedVisitor;
18106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18107 type Value = TableFragments;
18108
18109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18110 formatter.write_str("struct meta.TableFragments")
18111 }
18112
18113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
18114 where
18115 V: serde::de::MapAccess<'de>,
18116 {
18117 let mut table_id__ = None;
18118 let mut state__ = None;
18119 let mut fragments__ = None;
18120 let mut actor_status__ = None;
18121 let mut ctx__ = None;
18122 let mut parallelism__ = None;
18123 let mut max_parallelism__ = None;
18124 let mut node_label__ = None;
18125 let mut backfill_done__ = None;
18126 while let Some(k) = map_.next_key()? {
18127 match k {
18128 GeneratedField::TableId => {
18129 if table_id__.is_some() {
18130 return Err(serde::de::Error::duplicate_field("tableId"));
18131 }
18132 table_id__ =
18133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18134 ;
18135 }
18136 GeneratedField::State => {
18137 if state__.is_some() {
18138 return Err(serde::de::Error::duplicate_field("state"));
18139 }
18140 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
18141 }
18142 GeneratedField::Fragments => {
18143 if fragments__.is_some() {
18144 return Err(serde::de::Error::duplicate_field("fragments"));
18145 }
18146 fragments__ = Some(
18147 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18148 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18149 );
18150 }
18151 GeneratedField::ActorStatus => {
18152 if actor_status__.is_some() {
18153 return Err(serde::de::Error::duplicate_field("actorStatus"));
18154 }
18155 actor_status__ = Some(
18156 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18157 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18158 );
18159 }
18160 GeneratedField::Ctx => {
18161 if ctx__.is_some() {
18162 return Err(serde::de::Error::duplicate_field("ctx"));
18163 }
18164 ctx__ = map_.next_value()?;
18165 }
18166 GeneratedField::Parallelism => {
18167 if parallelism__.is_some() {
18168 return Err(serde::de::Error::duplicate_field("parallelism"));
18169 }
18170 parallelism__ = map_.next_value()?;
18171 }
18172 GeneratedField::MaxParallelism => {
18173 if max_parallelism__.is_some() {
18174 return Err(serde::de::Error::duplicate_field("maxParallelism"));
18175 }
18176 max_parallelism__ =
18177 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18178 ;
18179 }
18180 GeneratedField::NodeLabel => {
18181 if node_label__.is_some() {
18182 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18183 }
18184 node_label__ = Some(map_.next_value()?);
18185 }
18186 GeneratedField::BackfillDone => {
18187 if backfill_done__.is_some() {
18188 return Err(serde::de::Error::duplicate_field("backfillDone"));
18189 }
18190 backfill_done__ = Some(map_.next_value()?);
18191 }
18192 }
18193 }
18194 Ok(TableFragments {
18195 table_id: table_id__.unwrap_or_default(),
18196 state: state__.unwrap_or_default(),
18197 fragments: fragments__.unwrap_or_default(),
18198 actor_status: actor_status__.unwrap_or_default(),
18199 ctx: ctx__,
18200 parallelism: parallelism__,
18201 max_parallelism: max_parallelism__,
18202 node_label: node_label__.unwrap_or_default(),
18203 backfill_done: backfill_done__.unwrap_or_default(),
18204 })
18205 }
18206 }
18207 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
18208 }
18209}
18210impl serde::Serialize for table_fragments::ActorStatus {
18211 #[allow(deprecated)]
18212 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18213 where
18214 S: serde::Serializer,
18215 {
18216 use serde::ser::SerializeStruct;
18217 let mut len = 0;
18218 if self.location.is_some() {
18219 len += 1;
18220 }
18221 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
18222 if let Some(v) = self.location.as_ref() {
18223 struct_ser.serialize_field("location", v)?;
18224 }
18225 struct_ser.end()
18226 }
18227}
18228impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
18229 #[allow(deprecated)]
18230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18231 where
18232 D: serde::Deserializer<'de>,
18233 {
18234 const FIELDS: &[&str] = &[
18235 "location",
18236 ];
18237
18238 #[allow(clippy::enum_variant_names)]
18239 enum GeneratedField {
18240 Location,
18241 }
18242 impl<'de> serde::Deserialize<'de> for GeneratedField {
18243 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18244 where
18245 D: serde::Deserializer<'de>,
18246 {
18247 struct GeneratedVisitor;
18248
18249 impl serde::de::Visitor<'_> for GeneratedVisitor {
18250 type Value = GeneratedField;
18251
18252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18253 write!(formatter, "expected one of: {:?}", &FIELDS)
18254 }
18255
18256 #[allow(unused_variables)]
18257 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18258 where
18259 E: serde::de::Error,
18260 {
18261 match value {
18262 "location" => Ok(GeneratedField::Location),
18263 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18264 }
18265 }
18266 }
18267 deserializer.deserialize_identifier(GeneratedVisitor)
18268 }
18269 }
18270 struct GeneratedVisitor;
18271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18272 type Value = table_fragments::ActorStatus;
18273
18274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18275 formatter.write_str("struct meta.TableFragments.ActorStatus")
18276 }
18277
18278 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
18279 where
18280 V: serde::de::MapAccess<'de>,
18281 {
18282 let mut location__ = None;
18283 while let Some(k) = map_.next_key()? {
18284 match k {
18285 GeneratedField::Location => {
18286 if location__.is_some() {
18287 return Err(serde::de::Error::duplicate_field("location"));
18288 }
18289 location__ = map_.next_value()?;
18290 }
18291 }
18292 }
18293 Ok(table_fragments::ActorStatus {
18294 location: location__,
18295 })
18296 }
18297 }
18298 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
18299 }
18300}
18301impl serde::Serialize for table_fragments::Fragment {
18302 #[allow(deprecated)]
18303 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18304 where
18305 S: serde::Serializer,
18306 {
18307 use serde::ser::SerializeStruct;
18308 let mut len = 0;
18309 if self.fragment_id != 0 {
18310 len += 1;
18311 }
18312 if self.fragment_type_mask != 0 {
18313 len += 1;
18314 }
18315 if self.distribution_type != 0 {
18316 len += 1;
18317 }
18318 if !self.actors.is_empty() {
18319 len += 1;
18320 }
18321 if !self.state_table_ids.is_empty() {
18322 len += 1;
18323 }
18324 if !self.upstream_fragment_ids.is_empty() {
18325 len += 1;
18326 }
18327 if self.maybe_vnode_count.is_some() {
18328 len += 1;
18329 }
18330 if self.nodes.is_some() {
18331 len += 1;
18332 }
18333 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
18334 if self.fragment_id != 0 {
18335 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
18336 }
18337 if self.fragment_type_mask != 0 {
18338 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
18339 }
18340 if self.distribution_type != 0 {
18341 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
18342 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
18343 struct_ser.serialize_field("distributionType", &v)?;
18344 }
18345 if !self.actors.is_empty() {
18346 struct_ser.serialize_field("actors", &self.actors)?;
18347 }
18348 if !self.state_table_ids.is_empty() {
18349 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
18350 }
18351 if !self.upstream_fragment_ids.is_empty() {
18352 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
18353 }
18354 if let Some(v) = self.maybe_vnode_count.as_ref() {
18355 struct_ser.serialize_field("maybeVnodeCount", v)?;
18356 }
18357 if let Some(v) = self.nodes.as_ref() {
18358 struct_ser.serialize_field("nodes", v)?;
18359 }
18360 struct_ser.end()
18361 }
18362}
18363impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
18364 #[allow(deprecated)]
18365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18366 where
18367 D: serde::Deserializer<'de>,
18368 {
18369 const FIELDS: &[&str] = &[
18370 "fragment_id",
18371 "fragmentId",
18372 "fragment_type_mask",
18373 "fragmentTypeMask",
18374 "distribution_type",
18375 "distributionType",
18376 "actors",
18377 "state_table_ids",
18378 "stateTableIds",
18379 "upstream_fragment_ids",
18380 "upstreamFragmentIds",
18381 "maybe_vnode_count",
18382 "maybeVnodeCount",
18383 "nodes",
18384 ];
18385
18386 #[allow(clippy::enum_variant_names)]
18387 enum GeneratedField {
18388 FragmentId,
18389 FragmentTypeMask,
18390 DistributionType,
18391 Actors,
18392 StateTableIds,
18393 UpstreamFragmentIds,
18394 MaybeVnodeCount,
18395 Nodes,
18396 }
18397 impl<'de> serde::Deserialize<'de> for GeneratedField {
18398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18399 where
18400 D: serde::Deserializer<'de>,
18401 {
18402 struct GeneratedVisitor;
18403
18404 impl serde::de::Visitor<'_> for GeneratedVisitor {
18405 type Value = GeneratedField;
18406
18407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18408 write!(formatter, "expected one of: {:?}", &FIELDS)
18409 }
18410
18411 #[allow(unused_variables)]
18412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18413 where
18414 E: serde::de::Error,
18415 {
18416 match value {
18417 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
18418 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
18419 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
18420 "actors" => Ok(GeneratedField::Actors),
18421 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
18422 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
18423 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
18424 "nodes" => Ok(GeneratedField::Nodes),
18425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18426 }
18427 }
18428 }
18429 deserializer.deserialize_identifier(GeneratedVisitor)
18430 }
18431 }
18432 struct GeneratedVisitor;
18433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18434 type Value = table_fragments::Fragment;
18435
18436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18437 formatter.write_str("struct meta.TableFragments.Fragment")
18438 }
18439
18440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
18441 where
18442 V: serde::de::MapAccess<'de>,
18443 {
18444 let mut fragment_id__ = None;
18445 let mut fragment_type_mask__ = None;
18446 let mut distribution_type__ = None;
18447 let mut actors__ = None;
18448 let mut state_table_ids__ = None;
18449 let mut upstream_fragment_ids__ = None;
18450 let mut maybe_vnode_count__ = None;
18451 let mut nodes__ = None;
18452 while let Some(k) = map_.next_key()? {
18453 match k {
18454 GeneratedField::FragmentId => {
18455 if fragment_id__.is_some() {
18456 return Err(serde::de::Error::duplicate_field("fragmentId"));
18457 }
18458 fragment_id__ =
18459 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18460 ;
18461 }
18462 GeneratedField::FragmentTypeMask => {
18463 if fragment_type_mask__.is_some() {
18464 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
18465 }
18466 fragment_type_mask__ =
18467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18468 ;
18469 }
18470 GeneratedField::DistributionType => {
18471 if distribution_type__.is_some() {
18472 return Err(serde::de::Error::duplicate_field("distributionType"));
18473 }
18474 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
18475 }
18476 GeneratedField::Actors => {
18477 if actors__.is_some() {
18478 return Err(serde::de::Error::duplicate_field("actors"));
18479 }
18480 actors__ = Some(map_.next_value()?);
18481 }
18482 GeneratedField::StateTableIds => {
18483 if state_table_ids__.is_some() {
18484 return Err(serde::de::Error::duplicate_field("stateTableIds"));
18485 }
18486 state_table_ids__ =
18487 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18488 .into_iter().map(|x| x.0).collect())
18489 ;
18490 }
18491 GeneratedField::UpstreamFragmentIds => {
18492 if upstream_fragment_ids__.is_some() {
18493 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
18494 }
18495 upstream_fragment_ids__ =
18496 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18497 .into_iter().map(|x| x.0).collect())
18498 ;
18499 }
18500 GeneratedField::MaybeVnodeCount => {
18501 if maybe_vnode_count__.is_some() {
18502 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
18503 }
18504 maybe_vnode_count__ =
18505 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18506 ;
18507 }
18508 GeneratedField::Nodes => {
18509 if nodes__.is_some() {
18510 return Err(serde::de::Error::duplicate_field("nodes"));
18511 }
18512 nodes__ = map_.next_value()?;
18513 }
18514 }
18515 }
18516 Ok(table_fragments::Fragment {
18517 fragment_id: fragment_id__.unwrap_or_default(),
18518 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
18519 distribution_type: distribution_type__.unwrap_or_default(),
18520 actors: actors__.unwrap_or_default(),
18521 state_table_ids: state_table_ids__.unwrap_or_default(),
18522 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
18523 maybe_vnode_count: maybe_vnode_count__,
18524 nodes: nodes__,
18525 })
18526 }
18527 }
18528 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
18529 }
18530}
18531impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
18532 #[allow(deprecated)]
18533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18534 where
18535 S: serde::Serializer,
18536 {
18537 let variant = match self {
18538 Self::Unspecified => "UNSPECIFIED",
18539 Self::Single => "SINGLE",
18540 Self::Hash => "HASH",
18541 };
18542 serializer.serialize_str(variant)
18543 }
18544}
18545impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
18546 #[allow(deprecated)]
18547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18548 where
18549 D: serde::Deserializer<'de>,
18550 {
18551 const FIELDS: &[&str] = &[
18552 "UNSPECIFIED",
18553 "SINGLE",
18554 "HASH",
18555 ];
18556
18557 struct GeneratedVisitor;
18558
18559 impl serde::de::Visitor<'_> for GeneratedVisitor {
18560 type Value = table_fragments::fragment::FragmentDistributionType;
18561
18562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18563 write!(formatter, "expected one of: {:?}", &FIELDS)
18564 }
18565
18566 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18567 where
18568 E: serde::de::Error,
18569 {
18570 i32::try_from(v)
18571 .ok()
18572 .and_then(|x| x.try_into().ok())
18573 .ok_or_else(|| {
18574 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18575 })
18576 }
18577
18578 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18579 where
18580 E: serde::de::Error,
18581 {
18582 i32::try_from(v)
18583 .ok()
18584 .and_then(|x| x.try_into().ok())
18585 .ok_or_else(|| {
18586 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18587 })
18588 }
18589
18590 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18591 where
18592 E: serde::de::Error,
18593 {
18594 match value {
18595 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
18596 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
18597 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
18598 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18599 }
18600 }
18601 }
18602 deserializer.deserialize_any(GeneratedVisitor)
18603 }
18604}
18605impl serde::Serialize for table_fragments::State {
18606 #[allow(deprecated)]
18607 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18608 where
18609 S: serde::Serializer,
18610 {
18611 let variant = match self {
18612 Self::Unspecified => "UNSPECIFIED",
18613 Self::Initial => "INITIAL",
18614 Self::Creating => "CREATING",
18615 Self::Created => "CREATED",
18616 };
18617 serializer.serialize_str(variant)
18618 }
18619}
18620impl<'de> serde::Deserialize<'de> for table_fragments::State {
18621 #[allow(deprecated)]
18622 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18623 where
18624 D: serde::Deserializer<'de>,
18625 {
18626 const FIELDS: &[&str] = &[
18627 "UNSPECIFIED",
18628 "INITIAL",
18629 "CREATING",
18630 "CREATED",
18631 ];
18632
18633 struct GeneratedVisitor;
18634
18635 impl serde::de::Visitor<'_> for GeneratedVisitor {
18636 type Value = table_fragments::State;
18637
18638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18639 write!(formatter, "expected one of: {:?}", &FIELDS)
18640 }
18641
18642 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18643 where
18644 E: serde::de::Error,
18645 {
18646 i32::try_from(v)
18647 .ok()
18648 .and_then(|x| x.try_into().ok())
18649 .ok_or_else(|| {
18650 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18651 })
18652 }
18653
18654 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18655 where
18656 E: serde::de::Error,
18657 {
18658 i32::try_from(v)
18659 .ok()
18660 .and_then(|x| x.try_into().ok())
18661 .ok_or_else(|| {
18662 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18663 })
18664 }
18665
18666 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18667 where
18668 E: serde::de::Error,
18669 {
18670 match value {
18671 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
18672 "INITIAL" => Ok(table_fragments::State::Initial),
18673 "CREATING" => Ok(table_fragments::State::Creating),
18674 "CREATED" => Ok(table_fragments::State::Created),
18675 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18676 }
18677 }
18678 }
18679 deserializer.deserialize_any(GeneratedVisitor)
18680 }
18681}
18682impl serde::Serialize for TableParallelism {
18683 #[allow(deprecated)]
18684 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18685 where
18686 S: serde::Serializer,
18687 {
18688 use serde::ser::SerializeStruct;
18689 let mut len = 0;
18690 if self.parallelism.is_some() {
18691 len += 1;
18692 }
18693 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
18694 if let Some(v) = self.parallelism.as_ref() {
18695 match v {
18696 table_parallelism::Parallelism::Fixed(v) => {
18697 struct_ser.serialize_field("fixed", v)?;
18698 }
18699 table_parallelism::Parallelism::Auto(v) => {
18700 struct_ser.serialize_field("auto", v)?;
18701 }
18702 table_parallelism::Parallelism::Custom(v) => {
18703 struct_ser.serialize_field("custom", v)?;
18704 }
18705 table_parallelism::Parallelism::Adaptive(v) => {
18706 struct_ser.serialize_field("adaptive", v)?;
18707 }
18708 }
18709 }
18710 struct_ser.end()
18711 }
18712}
18713impl<'de> serde::Deserialize<'de> for TableParallelism {
18714 #[allow(deprecated)]
18715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18716 where
18717 D: serde::Deserializer<'de>,
18718 {
18719 const FIELDS: &[&str] = &[
18720 "fixed",
18721 "auto",
18722 "custom",
18723 "adaptive",
18724 ];
18725
18726 #[allow(clippy::enum_variant_names)]
18727 enum GeneratedField {
18728 Fixed,
18729 Auto,
18730 Custom,
18731 Adaptive,
18732 }
18733 impl<'de> serde::Deserialize<'de> for GeneratedField {
18734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18735 where
18736 D: serde::Deserializer<'de>,
18737 {
18738 struct GeneratedVisitor;
18739
18740 impl serde::de::Visitor<'_> for GeneratedVisitor {
18741 type Value = GeneratedField;
18742
18743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18744 write!(formatter, "expected one of: {:?}", &FIELDS)
18745 }
18746
18747 #[allow(unused_variables)]
18748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18749 where
18750 E: serde::de::Error,
18751 {
18752 match value {
18753 "fixed" => Ok(GeneratedField::Fixed),
18754 "auto" => Ok(GeneratedField::Auto),
18755 "custom" => Ok(GeneratedField::Custom),
18756 "adaptive" => Ok(GeneratedField::Adaptive),
18757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18758 }
18759 }
18760 }
18761 deserializer.deserialize_identifier(GeneratedVisitor)
18762 }
18763 }
18764 struct GeneratedVisitor;
18765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18766 type Value = TableParallelism;
18767
18768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18769 formatter.write_str("struct meta.TableParallelism")
18770 }
18771
18772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
18773 where
18774 V: serde::de::MapAccess<'de>,
18775 {
18776 let mut parallelism__ = None;
18777 while let Some(k) = map_.next_key()? {
18778 match k {
18779 GeneratedField::Fixed => {
18780 if parallelism__.is_some() {
18781 return Err(serde::de::Error::duplicate_field("fixed"));
18782 }
18783 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
18784;
18785 }
18786 GeneratedField::Auto => {
18787 if parallelism__.is_some() {
18788 return Err(serde::de::Error::duplicate_field("auto"));
18789 }
18790 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
18791;
18792 }
18793 GeneratedField::Custom => {
18794 if parallelism__.is_some() {
18795 return Err(serde::de::Error::duplicate_field("custom"));
18796 }
18797 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
18798;
18799 }
18800 GeneratedField::Adaptive => {
18801 if parallelism__.is_some() {
18802 return Err(serde::de::Error::duplicate_field("adaptive"));
18803 }
18804 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
18805;
18806 }
18807 }
18808 }
18809 Ok(TableParallelism {
18810 parallelism: parallelism__,
18811 })
18812 }
18813 }
18814 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
18815 }
18816}
18817impl serde::Serialize for table_parallelism::AdaptiveParallelism {
18818 #[allow(deprecated)]
18819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18820 where
18821 S: serde::Serializer,
18822 {
18823 use serde::ser::SerializeStruct;
18824 let len = 0;
18825 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
18826 struct_ser.end()
18827 }
18828}
18829impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
18830 #[allow(deprecated)]
18831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18832 where
18833 D: serde::Deserializer<'de>,
18834 {
18835 const FIELDS: &[&str] = &[
18836 ];
18837
18838 #[allow(clippy::enum_variant_names)]
18839 enum GeneratedField {
18840 }
18841 impl<'de> serde::Deserialize<'de> for GeneratedField {
18842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18843 where
18844 D: serde::Deserializer<'de>,
18845 {
18846 struct GeneratedVisitor;
18847
18848 impl serde::de::Visitor<'_> for GeneratedVisitor {
18849 type Value = GeneratedField;
18850
18851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18852 write!(formatter, "expected one of: {:?}", &FIELDS)
18853 }
18854
18855 #[allow(unused_variables)]
18856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18857 where
18858 E: serde::de::Error,
18859 {
18860 Err(serde::de::Error::unknown_field(value, FIELDS))
18861 }
18862 }
18863 deserializer.deserialize_identifier(GeneratedVisitor)
18864 }
18865 }
18866 struct GeneratedVisitor;
18867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18868 type Value = table_parallelism::AdaptiveParallelism;
18869
18870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18871 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
18872 }
18873
18874 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
18875 where
18876 V: serde::de::MapAccess<'de>,
18877 {
18878 while map_.next_key::<GeneratedField>()?.is_some() {
18879 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18880 }
18881 Ok(table_parallelism::AdaptiveParallelism {
18882 })
18883 }
18884 }
18885 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
18886 }
18887}
18888impl serde::Serialize for table_parallelism::AutoParallelism {
18889 #[allow(deprecated)]
18890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18891 where
18892 S: serde::Serializer,
18893 {
18894 use serde::ser::SerializeStruct;
18895 let len = 0;
18896 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
18897 struct_ser.end()
18898 }
18899}
18900impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
18901 #[allow(deprecated)]
18902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18903 where
18904 D: serde::Deserializer<'de>,
18905 {
18906 const FIELDS: &[&str] = &[
18907 ];
18908
18909 #[allow(clippy::enum_variant_names)]
18910 enum GeneratedField {
18911 }
18912 impl<'de> serde::Deserialize<'de> for GeneratedField {
18913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18914 where
18915 D: serde::Deserializer<'de>,
18916 {
18917 struct GeneratedVisitor;
18918
18919 impl serde::de::Visitor<'_> for GeneratedVisitor {
18920 type Value = GeneratedField;
18921
18922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18923 write!(formatter, "expected one of: {:?}", &FIELDS)
18924 }
18925
18926 #[allow(unused_variables)]
18927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18928 where
18929 E: serde::de::Error,
18930 {
18931 Err(serde::de::Error::unknown_field(value, FIELDS))
18932 }
18933 }
18934 deserializer.deserialize_identifier(GeneratedVisitor)
18935 }
18936 }
18937 struct GeneratedVisitor;
18938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18939 type Value = table_parallelism::AutoParallelism;
18940
18941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18942 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
18943 }
18944
18945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
18946 where
18947 V: serde::de::MapAccess<'de>,
18948 {
18949 while map_.next_key::<GeneratedField>()?.is_some() {
18950 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18951 }
18952 Ok(table_parallelism::AutoParallelism {
18953 })
18954 }
18955 }
18956 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
18957 }
18958}
18959impl serde::Serialize for table_parallelism::CustomParallelism {
18960 #[allow(deprecated)]
18961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18962 where
18963 S: serde::Serializer,
18964 {
18965 use serde::ser::SerializeStruct;
18966 let len = 0;
18967 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
18968 struct_ser.end()
18969 }
18970}
18971impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
18972 #[allow(deprecated)]
18973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18974 where
18975 D: serde::Deserializer<'de>,
18976 {
18977 const FIELDS: &[&str] = &[
18978 ];
18979
18980 #[allow(clippy::enum_variant_names)]
18981 enum GeneratedField {
18982 }
18983 impl<'de> serde::Deserialize<'de> for GeneratedField {
18984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18985 where
18986 D: serde::Deserializer<'de>,
18987 {
18988 struct GeneratedVisitor;
18989
18990 impl serde::de::Visitor<'_> for GeneratedVisitor {
18991 type Value = GeneratedField;
18992
18993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18994 write!(formatter, "expected one of: {:?}", &FIELDS)
18995 }
18996
18997 #[allow(unused_variables)]
18998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18999 where
19000 E: serde::de::Error,
19001 {
19002 Err(serde::de::Error::unknown_field(value, FIELDS))
19003 }
19004 }
19005 deserializer.deserialize_identifier(GeneratedVisitor)
19006 }
19007 }
19008 struct GeneratedVisitor;
19009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19010 type Value = table_parallelism::CustomParallelism;
19011
19012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19013 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
19014 }
19015
19016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
19017 where
19018 V: serde::de::MapAccess<'de>,
19019 {
19020 while map_.next_key::<GeneratedField>()?.is_some() {
19021 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19022 }
19023 Ok(table_parallelism::CustomParallelism {
19024 })
19025 }
19026 }
19027 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
19028 }
19029}
19030impl serde::Serialize for table_parallelism::FixedParallelism {
19031 #[allow(deprecated)]
19032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19033 where
19034 S: serde::Serializer,
19035 {
19036 use serde::ser::SerializeStruct;
19037 let mut len = 0;
19038 if self.parallelism != 0 {
19039 len += 1;
19040 }
19041 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
19042 if self.parallelism != 0 {
19043 struct_ser.serialize_field("parallelism", &self.parallelism)?;
19044 }
19045 struct_ser.end()
19046 }
19047}
19048impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
19049 #[allow(deprecated)]
19050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19051 where
19052 D: serde::Deserializer<'de>,
19053 {
19054 const FIELDS: &[&str] = &[
19055 "parallelism",
19056 ];
19057
19058 #[allow(clippy::enum_variant_names)]
19059 enum GeneratedField {
19060 Parallelism,
19061 }
19062 impl<'de> serde::Deserialize<'de> for GeneratedField {
19063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19064 where
19065 D: serde::Deserializer<'de>,
19066 {
19067 struct GeneratedVisitor;
19068
19069 impl serde::de::Visitor<'_> for GeneratedVisitor {
19070 type Value = GeneratedField;
19071
19072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19073 write!(formatter, "expected one of: {:?}", &FIELDS)
19074 }
19075
19076 #[allow(unused_variables)]
19077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19078 where
19079 E: serde::de::Error,
19080 {
19081 match value {
19082 "parallelism" => Ok(GeneratedField::Parallelism),
19083 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19084 }
19085 }
19086 }
19087 deserializer.deserialize_identifier(GeneratedVisitor)
19088 }
19089 }
19090 struct GeneratedVisitor;
19091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19092 type Value = table_parallelism::FixedParallelism;
19093
19094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19095 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
19096 }
19097
19098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
19099 where
19100 V: serde::de::MapAccess<'de>,
19101 {
19102 let mut parallelism__ = None;
19103 while let Some(k) = map_.next_key()? {
19104 match k {
19105 GeneratedField::Parallelism => {
19106 if parallelism__.is_some() {
19107 return Err(serde::de::Error::duplicate_field("parallelism"));
19108 }
19109 parallelism__ =
19110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19111 ;
19112 }
19113 }
19114 }
19115 Ok(table_parallelism::FixedParallelism {
19116 parallelism: parallelism__.unwrap_or_default(),
19117 })
19118 }
19119 }
19120 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
19121 }
19122}
19123impl serde::Serialize for TelemetryInfoResponse {
19124 #[allow(deprecated)]
19125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19126 where
19127 S: serde::Serializer,
19128 {
19129 use serde::ser::SerializeStruct;
19130 let mut len = 0;
19131 if self.tracking_id.is_some() {
19132 len += 1;
19133 }
19134 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
19135 if let Some(v) = self.tracking_id.as_ref() {
19136 struct_ser.serialize_field("trackingId", v)?;
19137 }
19138 struct_ser.end()
19139 }
19140}
19141impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
19142 #[allow(deprecated)]
19143 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19144 where
19145 D: serde::Deserializer<'de>,
19146 {
19147 const FIELDS: &[&str] = &[
19148 "tracking_id",
19149 "trackingId",
19150 ];
19151
19152 #[allow(clippy::enum_variant_names)]
19153 enum GeneratedField {
19154 TrackingId,
19155 }
19156 impl<'de> serde::Deserialize<'de> for GeneratedField {
19157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19158 where
19159 D: serde::Deserializer<'de>,
19160 {
19161 struct GeneratedVisitor;
19162
19163 impl serde::de::Visitor<'_> for GeneratedVisitor {
19164 type Value = GeneratedField;
19165
19166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19167 write!(formatter, "expected one of: {:?}", &FIELDS)
19168 }
19169
19170 #[allow(unused_variables)]
19171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19172 where
19173 E: serde::de::Error,
19174 {
19175 match value {
19176 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
19177 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19178 }
19179 }
19180 }
19181 deserializer.deserialize_identifier(GeneratedVisitor)
19182 }
19183 }
19184 struct GeneratedVisitor;
19185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19186 type Value = TelemetryInfoResponse;
19187
19188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19189 formatter.write_str("struct meta.TelemetryInfoResponse")
19190 }
19191
19192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
19193 where
19194 V: serde::de::MapAccess<'de>,
19195 {
19196 let mut tracking_id__ = None;
19197 while let Some(k) = map_.next_key()? {
19198 match k {
19199 GeneratedField::TrackingId => {
19200 if tracking_id__.is_some() {
19201 return Err(serde::de::Error::duplicate_field("trackingId"));
19202 }
19203 tracking_id__ = map_.next_value()?;
19204 }
19205 }
19206 }
19207 Ok(TelemetryInfoResponse {
19208 tracking_id: tracking_id__,
19209 })
19210 }
19211 }
19212 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
19213 }
19214}
19215impl serde::Serialize for ThrottleTarget {
19216 #[allow(deprecated)]
19217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19218 where
19219 S: serde::Serializer,
19220 {
19221 let variant = match self {
19222 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
19223 Self::Source => "SOURCE",
19224 Self::Mv => "MV",
19225 Self::Table => "TABLE",
19226 Self::Sink => "SINK",
19227 Self::Fragment => "FRAGMENT",
19228 };
19229 serializer.serialize_str(variant)
19230 }
19231}
19232impl<'de> serde::Deserialize<'de> for ThrottleTarget {
19233 #[allow(deprecated)]
19234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19235 where
19236 D: serde::Deserializer<'de>,
19237 {
19238 const FIELDS: &[&str] = &[
19239 "THROTTLE_TARGET_UNSPECIFIED",
19240 "SOURCE",
19241 "MV",
19242 "TABLE",
19243 "SINK",
19244 "FRAGMENT",
19245 ];
19246
19247 struct GeneratedVisitor;
19248
19249 impl serde::de::Visitor<'_> for GeneratedVisitor {
19250 type Value = ThrottleTarget;
19251
19252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19253 write!(formatter, "expected one of: {:?}", &FIELDS)
19254 }
19255
19256 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19257 where
19258 E: serde::de::Error,
19259 {
19260 i32::try_from(v)
19261 .ok()
19262 .and_then(|x| x.try_into().ok())
19263 .ok_or_else(|| {
19264 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19265 })
19266 }
19267
19268 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19269 where
19270 E: serde::de::Error,
19271 {
19272 i32::try_from(v)
19273 .ok()
19274 .and_then(|x| x.try_into().ok())
19275 .ok_or_else(|| {
19276 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19277 })
19278 }
19279
19280 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19281 where
19282 E: serde::de::Error,
19283 {
19284 match value {
19285 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
19286 "SOURCE" => Ok(ThrottleTarget::Source),
19287 "MV" => Ok(ThrottleTarget::Mv),
19288 "TABLE" => Ok(ThrottleTarget::Table),
19289 "SINK" => Ok(ThrottleTarget::Sink),
19290 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
19291 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19292 }
19293 }
19294 }
19295 deserializer.deserialize_any(GeneratedVisitor)
19296 }
19297}
19298impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
19299 #[allow(deprecated)]
19300 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19301 where
19302 S: serde::Serializer,
19303 {
19304 use serde::ser::SerializeStruct;
19305 let mut len = 0;
19306 if self.id != 0 {
19307 len += 1;
19308 }
19309 if !self.node_label.is_empty() {
19310 len += 1;
19311 }
19312 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
19313 if self.id != 0 {
19314 struct_ser.serialize_field("id", &self.id)?;
19315 }
19316 if !self.node_label.is_empty() {
19317 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
19318 }
19319 struct_ser.end()
19320 }
19321}
19322impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
19323 #[allow(deprecated)]
19324 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19325 where
19326 D: serde::Deserializer<'de>,
19327 {
19328 const FIELDS: &[&str] = &[
19329 "id",
19330 "node_label",
19331 "nodeLabel",
19332 ];
19333
19334 #[allow(clippy::enum_variant_names)]
19335 enum GeneratedField {
19336 Id,
19337 NodeLabel,
19338 }
19339 impl<'de> serde::Deserialize<'de> for GeneratedField {
19340 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19341 where
19342 D: serde::Deserializer<'de>,
19343 {
19344 struct GeneratedVisitor;
19345
19346 impl serde::de::Visitor<'_> for GeneratedVisitor {
19347 type Value = GeneratedField;
19348
19349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19350 write!(formatter, "expected one of: {:?}", &FIELDS)
19351 }
19352
19353 #[allow(unused_variables)]
19354 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19355 where
19356 E: serde::de::Error,
19357 {
19358 match value {
19359 "id" => Ok(GeneratedField::Id),
19360 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
19361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19362 }
19363 }
19364 }
19365 deserializer.deserialize_identifier(GeneratedVisitor)
19366 }
19367 }
19368 struct GeneratedVisitor;
19369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19370 type Value = UpdateStreamingJobNodeLabelsRequest;
19371
19372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19373 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
19374 }
19375
19376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
19377 where
19378 V: serde::de::MapAccess<'de>,
19379 {
19380 let mut id__ = None;
19381 let mut node_label__ = None;
19382 while let Some(k) = map_.next_key()? {
19383 match k {
19384 GeneratedField::Id => {
19385 if id__.is_some() {
19386 return Err(serde::de::Error::duplicate_field("id"));
19387 }
19388 id__ =
19389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19390 ;
19391 }
19392 GeneratedField::NodeLabel => {
19393 if node_label__.is_some() {
19394 return Err(serde::de::Error::duplicate_field("nodeLabel"));
19395 }
19396 node_label__ = Some(map_.next_value()?);
19397 }
19398 }
19399 }
19400 Ok(UpdateStreamingJobNodeLabelsRequest {
19401 id: id__.unwrap_or_default(),
19402 node_label: node_label__.unwrap_or_default(),
19403 })
19404 }
19405 }
19406 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
19407 }
19408}
19409impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
19410 #[allow(deprecated)]
19411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19412 where
19413 S: serde::Serializer,
19414 {
19415 use serde::ser::SerializeStruct;
19416 let len = 0;
19417 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
19418 struct_ser.end()
19419 }
19420}
19421impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
19422 #[allow(deprecated)]
19423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19424 where
19425 D: serde::Deserializer<'de>,
19426 {
19427 const FIELDS: &[&str] = &[
19428 ];
19429
19430 #[allow(clippy::enum_variant_names)]
19431 enum GeneratedField {
19432 }
19433 impl<'de> serde::Deserialize<'de> for GeneratedField {
19434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19435 where
19436 D: serde::Deserializer<'de>,
19437 {
19438 struct GeneratedVisitor;
19439
19440 impl serde::de::Visitor<'_> for GeneratedVisitor {
19441 type Value = GeneratedField;
19442
19443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19444 write!(formatter, "expected one of: {:?}", &FIELDS)
19445 }
19446
19447 #[allow(unused_variables)]
19448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19449 where
19450 E: serde::de::Error,
19451 {
19452 Err(serde::de::Error::unknown_field(value, FIELDS))
19453 }
19454 }
19455 deserializer.deserialize_identifier(GeneratedVisitor)
19456 }
19457 }
19458 struct GeneratedVisitor;
19459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19460 type Value = UpdateStreamingJobNodeLabelsResponse;
19461
19462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19463 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
19464 }
19465
19466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
19467 where
19468 V: serde::de::MapAccess<'de>,
19469 {
19470 while map_.next_key::<GeneratedField>()?.is_some() {
19471 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19472 }
19473 Ok(UpdateStreamingJobNodeLabelsResponse {
19474 })
19475 }
19476 }
19477 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
19478 }
19479}
19480impl serde::Serialize for WorkerReschedule {
19481 #[allow(deprecated)]
19482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19483 where
19484 S: serde::Serializer,
19485 {
19486 use serde::ser::SerializeStruct;
19487 let mut len = 0;
19488 if !self.worker_actor_diff.is_empty() {
19489 len += 1;
19490 }
19491 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
19492 if !self.worker_actor_diff.is_empty() {
19493 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
19494 }
19495 struct_ser.end()
19496 }
19497}
19498impl<'de> serde::Deserialize<'de> for WorkerReschedule {
19499 #[allow(deprecated)]
19500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19501 where
19502 D: serde::Deserializer<'de>,
19503 {
19504 const FIELDS: &[&str] = &[
19505 "worker_actor_diff",
19506 "workerActorDiff",
19507 ];
19508
19509 #[allow(clippy::enum_variant_names)]
19510 enum GeneratedField {
19511 WorkerActorDiff,
19512 }
19513 impl<'de> serde::Deserialize<'de> for GeneratedField {
19514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19515 where
19516 D: serde::Deserializer<'de>,
19517 {
19518 struct GeneratedVisitor;
19519
19520 impl serde::de::Visitor<'_> for GeneratedVisitor {
19521 type Value = GeneratedField;
19522
19523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19524 write!(formatter, "expected one of: {:?}", &FIELDS)
19525 }
19526
19527 #[allow(unused_variables)]
19528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19529 where
19530 E: serde::de::Error,
19531 {
19532 match value {
19533 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
19534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19535 }
19536 }
19537 }
19538 deserializer.deserialize_identifier(GeneratedVisitor)
19539 }
19540 }
19541 struct GeneratedVisitor;
19542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19543 type Value = WorkerReschedule;
19544
19545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19546 formatter.write_str("struct meta.WorkerReschedule")
19547 }
19548
19549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
19550 where
19551 V: serde::de::MapAccess<'de>,
19552 {
19553 let mut worker_actor_diff__ = None;
19554 while let Some(k) = map_.next_key()? {
19555 match k {
19556 GeneratedField::WorkerActorDiff => {
19557 if worker_actor_diff__.is_some() {
19558 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
19559 }
19560 worker_actor_diff__ = Some(
19561 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
19562 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
19563 );
19564 }
19565 }
19566 }
19567 Ok(WorkerReschedule {
19568 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
19569 })
19570 }
19571 }
19572 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
19573 }
19574}