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 if self.adaptive_parallelism_strategy.is_some() {
12402 len += 1;
12403 }
12404 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12405 if self.table_id != 0 {
12406 struct_ser.serialize_field("tableId", &self.table_id)?;
12407 }
12408 if self.state != 0 {
12409 let v = table_fragments::State::try_from(self.state)
12410 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12411 struct_ser.serialize_field("state", &v)?;
12412 }
12413 if let Some(v) = self.parallelism.as_ref() {
12414 struct_ser.serialize_field("parallelism", v)?;
12415 }
12416 if self.max_parallelism != 0 {
12417 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12418 }
12419 if !self.name.is_empty() {
12420 struct_ser.serialize_field("name", &self.name)?;
12421 }
12422 if !self.resource_group.is_empty() {
12423 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12424 }
12425 if !self.config_override.is_empty() {
12426 struct_ser.serialize_field("configOverride", &self.config_override)?;
12427 }
12428 if self.database_id != 0 {
12429 struct_ser.serialize_field("databaseId", &self.database_id)?;
12430 }
12431 if self.schema_id != 0 {
12432 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12433 }
12434 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
12435 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
12436 }
12437 struct_ser.end()
12438 }
12439}
12440impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12441 #[allow(deprecated)]
12442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12443 where
12444 D: serde::Deserializer<'de>,
12445 {
12446 const FIELDS: &[&str] = &[
12447 "table_id",
12448 "tableId",
12449 "state",
12450 "parallelism",
12451 "max_parallelism",
12452 "maxParallelism",
12453 "name",
12454 "resource_group",
12455 "resourceGroup",
12456 "config_override",
12457 "configOverride",
12458 "database_id",
12459 "databaseId",
12460 "schema_id",
12461 "schemaId",
12462 "adaptive_parallelism_strategy",
12463 "adaptiveParallelismStrategy",
12464 ];
12465
12466 #[allow(clippy::enum_variant_names)]
12467 enum GeneratedField {
12468 TableId,
12469 State,
12470 Parallelism,
12471 MaxParallelism,
12472 Name,
12473 ResourceGroup,
12474 ConfigOverride,
12475 DatabaseId,
12476 SchemaId,
12477 AdaptiveParallelismStrategy,
12478 }
12479 impl<'de> serde::Deserialize<'de> for GeneratedField {
12480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12481 where
12482 D: serde::Deserializer<'de>,
12483 {
12484 struct GeneratedVisitor;
12485
12486 impl serde::de::Visitor<'_> for GeneratedVisitor {
12487 type Value = GeneratedField;
12488
12489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12490 write!(formatter, "expected one of: {:?}", &FIELDS)
12491 }
12492
12493 #[allow(unused_variables)]
12494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12495 where
12496 E: serde::de::Error,
12497 {
12498 match value {
12499 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12500 "state" => Ok(GeneratedField::State),
12501 "parallelism" => Ok(GeneratedField::Parallelism),
12502 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12503 "name" => Ok(GeneratedField::Name),
12504 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12505 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12506 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12507 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12508 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12509 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12510 }
12511 }
12512 }
12513 deserializer.deserialize_identifier(GeneratedVisitor)
12514 }
12515 }
12516 struct GeneratedVisitor;
12517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12518 type Value = list_streaming_job_states_response::StreamingJobState;
12519
12520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12521 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12522 }
12523
12524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12525 where
12526 V: serde::de::MapAccess<'de>,
12527 {
12528 let mut table_id__ = None;
12529 let mut state__ = None;
12530 let mut parallelism__ = None;
12531 let mut max_parallelism__ = None;
12532 let mut name__ = None;
12533 let mut resource_group__ = None;
12534 let mut config_override__ = None;
12535 let mut database_id__ = None;
12536 let mut schema_id__ = None;
12537 let mut adaptive_parallelism_strategy__ = None;
12538 while let Some(k) = map_.next_key()? {
12539 match k {
12540 GeneratedField::TableId => {
12541 if table_id__.is_some() {
12542 return Err(serde::de::Error::duplicate_field("tableId"));
12543 }
12544 table_id__ =
12545 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12546 ;
12547 }
12548 GeneratedField::State => {
12549 if state__.is_some() {
12550 return Err(serde::de::Error::duplicate_field("state"));
12551 }
12552 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12553 }
12554 GeneratedField::Parallelism => {
12555 if parallelism__.is_some() {
12556 return Err(serde::de::Error::duplicate_field("parallelism"));
12557 }
12558 parallelism__ = map_.next_value()?;
12559 }
12560 GeneratedField::MaxParallelism => {
12561 if max_parallelism__.is_some() {
12562 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12563 }
12564 max_parallelism__ =
12565 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12566 ;
12567 }
12568 GeneratedField::Name => {
12569 if name__.is_some() {
12570 return Err(serde::de::Error::duplicate_field("name"));
12571 }
12572 name__ = Some(map_.next_value()?);
12573 }
12574 GeneratedField::ResourceGroup => {
12575 if resource_group__.is_some() {
12576 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12577 }
12578 resource_group__ = Some(map_.next_value()?);
12579 }
12580 GeneratedField::ConfigOverride => {
12581 if config_override__.is_some() {
12582 return Err(serde::de::Error::duplicate_field("configOverride"));
12583 }
12584 config_override__ = Some(map_.next_value()?);
12585 }
12586 GeneratedField::DatabaseId => {
12587 if database_id__.is_some() {
12588 return Err(serde::de::Error::duplicate_field("databaseId"));
12589 }
12590 database_id__ =
12591 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12592 ;
12593 }
12594 GeneratedField::SchemaId => {
12595 if schema_id__.is_some() {
12596 return Err(serde::de::Error::duplicate_field("schemaId"));
12597 }
12598 schema_id__ =
12599 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12600 ;
12601 }
12602 GeneratedField::AdaptiveParallelismStrategy => {
12603 if adaptive_parallelism_strategy__.is_some() {
12604 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12605 }
12606 adaptive_parallelism_strategy__ = map_.next_value()?;
12607 }
12608 }
12609 }
12610 Ok(list_streaming_job_states_response::StreamingJobState {
12611 table_id: table_id__.unwrap_or_default(),
12612 state: state__.unwrap_or_default(),
12613 parallelism: parallelism__,
12614 max_parallelism: max_parallelism__.unwrap_or_default(),
12615 name: name__.unwrap_or_default(),
12616 resource_group: resource_group__.unwrap_or_default(),
12617 config_override: config_override__.unwrap_or_default(),
12618 database_id: database_id__.unwrap_or_default(),
12619 schema_id: schema_id__.unwrap_or_default(),
12620 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
12621 })
12622 }
12623 }
12624 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12625 }
12626}
12627impl serde::Serialize for ListTableFragmentsRequest {
12628 #[allow(deprecated)]
12629 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12630 where
12631 S: serde::Serializer,
12632 {
12633 use serde::ser::SerializeStruct;
12634 let mut len = 0;
12635 if !self.table_ids.is_empty() {
12636 len += 1;
12637 }
12638 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12639 if !self.table_ids.is_empty() {
12640 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12641 }
12642 struct_ser.end()
12643 }
12644}
12645impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12646 #[allow(deprecated)]
12647 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12648 where
12649 D: serde::Deserializer<'de>,
12650 {
12651 const FIELDS: &[&str] = &[
12652 "table_ids",
12653 "tableIds",
12654 ];
12655
12656 #[allow(clippy::enum_variant_names)]
12657 enum GeneratedField {
12658 TableIds,
12659 }
12660 impl<'de> serde::Deserialize<'de> for GeneratedField {
12661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12662 where
12663 D: serde::Deserializer<'de>,
12664 {
12665 struct GeneratedVisitor;
12666
12667 impl serde::de::Visitor<'_> for GeneratedVisitor {
12668 type Value = GeneratedField;
12669
12670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12671 write!(formatter, "expected one of: {:?}", &FIELDS)
12672 }
12673
12674 #[allow(unused_variables)]
12675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12676 where
12677 E: serde::de::Error,
12678 {
12679 match value {
12680 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12682 }
12683 }
12684 }
12685 deserializer.deserialize_identifier(GeneratedVisitor)
12686 }
12687 }
12688 struct GeneratedVisitor;
12689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12690 type Value = ListTableFragmentsRequest;
12691
12692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12693 formatter.write_str("struct meta.ListTableFragmentsRequest")
12694 }
12695
12696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12697 where
12698 V: serde::de::MapAccess<'de>,
12699 {
12700 let mut table_ids__ = None;
12701 while let Some(k) = map_.next_key()? {
12702 match k {
12703 GeneratedField::TableIds => {
12704 if table_ids__.is_some() {
12705 return Err(serde::de::Error::duplicate_field("tableIds"));
12706 }
12707 table_ids__ =
12708 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12709 .into_iter().map(|x| x.0).collect())
12710 ;
12711 }
12712 }
12713 }
12714 Ok(ListTableFragmentsRequest {
12715 table_ids: table_ids__.unwrap_or_default(),
12716 })
12717 }
12718 }
12719 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12720 }
12721}
12722impl serde::Serialize for ListTableFragmentsResponse {
12723 #[allow(deprecated)]
12724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12725 where
12726 S: serde::Serializer,
12727 {
12728 use serde::ser::SerializeStruct;
12729 let mut len = 0;
12730 if !self.table_fragments.is_empty() {
12731 len += 1;
12732 }
12733 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12734 if !self.table_fragments.is_empty() {
12735 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12736 }
12737 struct_ser.end()
12738 }
12739}
12740impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12741 #[allow(deprecated)]
12742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12743 where
12744 D: serde::Deserializer<'de>,
12745 {
12746 const FIELDS: &[&str] = &[
12747 "table_fragments",
12748 "tableFragments",
12749 ];
12750
12751 #[allow(clippy::enum_variant_names)]
12752 enum GeneratedField {
12753 TableFragments,
12754 }
12755 impl<'de> serde::Deserialize<'de> for GeneratedField {
12756 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12757 where
12758 D: serde::Deserializer<'de>,
12759 {
12760 struct GeneratedVisitor;
12761
12762 impl serde::de::Visitor<'_> for GeneratedVisitor {
12763 type Value = GeneratedField;
12764
12765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12766 write!(formatter, "expected one of: {:?}", &FIELDS)
12767 }
12768
12769 #[allow(unused_variables)]
12770 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12771 where
12772 E: serde::de::Error,
12773 {
12774 match value {
12775 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
12776 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12777 }
12778 }
12779 }
12780 deserializer.deserialize_identifier(GeneratedVisitor)
12781 }
12782 }
12783 struct GeneratedVisitor;
12784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12785 type Value = ListTableFragmentsResponse;
12786
12787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12788 formatter.write_str("struct meta.ListTableFragmentsResponse")
12789 }
12790
12791 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12792 where
12793 V: serde::de::MapAccess<'de>,
12794 {
12795 let mut table_fragments__ = None;
12796 while let Some(k) = map_.next_key()? {
12797 match k {
12798 GeneratedField::TableFragments => {
12799 if table_fragments__.is_some() {
12800 return Err(serde::de::Error::duplicate_field("tableFragments"));
12801 }
12802 table_fragments__ = Some(
12803 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12804 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12805 );
12806 }
12807 }
12808 }
12809 Ok(ListTableFragmentsResponse {
12810 table_fragments: table_fragments__.unwrap_or_default(),
12811 })
12812 }
12813 }
12814 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
12815 }
12816}
12817impl serde::Serialize for list_table_fragments_response::ActorInfo {
12818 #[allow(deprecated)]
12819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12820 where
12821 S: serde::Serializer,
12822 {
12823 use serde::ser::SerializeStruct;
12824 let mut len = 0;
12825 if self.id != 0 {
12826 len += 1;
12827 }
12828 if self.node.is_some() {
12829 len += 1;
12830 }
12831 if !self.dispatcher.is_empty() {
12832 len += 1;
12833 }
12834 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
12835 if self.id != 0 {
12836 struct_ser.serialize_field("id", &self.id)?;
12837 }
12838 if let Some(v) = self.node.as_ref() {
12839 struct_ser.serialize_field("node", v)?;
12840 }
12841 if !self.dispatcher.is_empty() {
12842 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12843 }
12844 struct_ser.end()
12845 }
12846}
12847impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
12848 #[allow(deprecated)]
12849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12850 where
12851 D: serde::Deserializer<'de>,
12852 {
12853 const FIELDS: &[&str] = &[
12854 "id",
12855 "node",
12856 "dispatcher",
12857 ];
12858
12859 #[allow(clippy::enum_variant_names)]
12860 enum GeneratedField {
12861 Id,
12862 Node,
12863 Dispatcher,
12864 }
12865 impl<'de> serde::Deserialize<'de> for GeneratedField {
12866 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12867 where
12868 D: serde::Deserializer<'de>,
12869 {
12870 struct GeneratedVisitor;
12871
12872 impl serde::de::Visitor<'_> for GeneratedVisitor {
12873 type Value = GeneratedField;
12874
12875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12876 write!(formatter, "expected one of: {:?}", &FIELDS)
12877 }
12878
12879 #[allow(unused_variables)]
12880 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12881 where
12882 E: serde::de::Error,
12883 {
12884 match value {
12885 "id" => Ok(GeneratedField::Id),
12886 "node" => Ok(GeneratedField::Node),
12887 "dispatcher" => Ok(GeneratedField::Dispatcher),
12888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12889 }
12890 }
12891 }
12892 deserializer.deserialize_identifier(GeneratedVisitor)
12893 }
12894 }
12895 struct GeneratedVisitor;
12896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12897 type Value = list_table_fragments_response::ActorInfo;
12898
12899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12900 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
12901 }
12902
12903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12904 where
12905 V: serde::de::MapAccess<'de>,
12906 {
12907 let mut id__ = None;
12908 let mut node__ = None;
12909 let mut dispatcher__ = None;
12910 while let Some(k) = map_.next_key()? {
12911 match k {
12912 GeneratedField::Id => {
12913 if id__.is_some() {
12914 return Err(serde::de::Error::duplicate_field("id"));
12915 }
12916 id__ =
12917 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12918 ;
12919 }
12920 GeneratedField::Node => {
12921 if node__.is_some() {
12922 return Err(serde::de::Error::duplicate_field("node"));
12923 }
12924 node__ = map_.next_value()?;
12925 }
12926 GeneratedField::Dispatcher => {
12927 if dispatcher__.is_some() {
12928 return Err(serde::de::Error::duplicate_field("dispatcher"));
12929 }
12930 dispatcher__ = Some(map_.next_value()?);
12931 }
12932 }
12933 }
12934 Ok(list_table_fragments_response::ActorInfo {
12935 id: id__.unwrap_or_default(),
12936 node: node__,
12937 dispatcher: dispatcher__.unwrap_or_default(),
12938 })
12939 }
12940 }
12941 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12942 }
12943}
12944impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12945 #[allow(deprecated)]
12946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12947 where
12948 S: serde::Serializer,
12949 {
12950 use serde::ser::SerializeStruct;
12951 let mut len = 0;
12952 if self.id != 0 {
12953 len += 1;
12954 }
12955 if !self.actors.is_empty() {
12956 len += 1;
12957 }
12958 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12959 if self.id != 0 {
12960 struct_ser.serialize_field("id", &self.id)?;
12961 }
12962 if !self.actors.is_empty() {
12963 struct_ser.serialize_field("actors", &self.actors)?;
12964 }
12965 struct_ser.end()
12966 }
12967}
12968impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12969 #[allow(deprecated)]
12970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12971 where
12972 D: serde::Deserializer<'de>,
12973 {
12974 const FIELDS: &[&str] = &[
12975 "id",
12976 "actors",
12977 ];
12978
12979 #[allow(clippy::enum_variant_names)]
12980 enum GeneratedField {
12981 Id,
12982 Actors,
12983 }
12984 impl<'de> serde::Deserialize<'de> for GeneratedField {
12985 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12986 where
12987 D: serde::Deserializer<'de>,
12988 {
12989 struct GeneratedVisitor;
12990
12991 impl serde::de::Visitor<'_> for GeneratedVisitor {
12992 type Value = GeneratedField;
12993
12994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12995 write!(formatter, "expected one of: {:?}", &FIELDS)
12996 }
12997
12998 #[allow(unused_variables)]
12999 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13000 where
13001 E: serde::de::Error,
13002 {
13003 match value {
13004 "id" => Ok(GeneratedField::Id),
13005 "actors" => Ok(GeneratedField::Actors),
13006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13007 }
13008 }
13009 }
13010 deserializer.deserialize_identifier(GeneratedVisitor)
13011 }
13012 }
13013 struct GeneratedVisitor;
13014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13015 type Value = list_table_fragments_response::FragmentInfo;
13016
13017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13018 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
13019 }
13020
13021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
13022 where
13023 V: serde::de::MapAccess<'de>,
13024 {
13025 let mut id__ = None;
13026 let mut actors__ = None;
13027 while let Some(k) = map_.next_key()? {
13028 match k {
13029 GeneratedField::Id => {
13030 if id__.is_some() {
13031 return Err(serde::de::Error::duplicate_field("id"));
13032 }
13033 id__ =
13034 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13035 ;
13036 }
13037 GeneratedField::Actors => {
13038 if actors__.is_some() {
13039 return Err(serde::de::Error::duplicate_field("actors"));
13040 }
13041 actors__ = Some(map_.next_value()?);
13042 }
13043 }
13044 }
13045 Ok(list_table_fragments_response::FragmentInfo {
13046 id: id__.unwrap_or_default(),
13047 actors: actors__.unwrap_or_default(),
13048 })
13049 }
13050 }
13051 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
13052 }
13053}
13054impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
13055 #[allow(deprecated)]
13056 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13057 where
13058 S: serde::Serializer,
13059 {
13060 use serde::ser::SerializeStruct;
13061 let mut len = 0;
13062 if !self.fragments.is_empty() {
13063 len += 1;
13064 }
13065 if self.ctx.is_some() {
13066 len += 1;
13067 }
13068 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
13069 if !self.fragments.is_empty() {
13070 struct_ser.serialize_field("fragments", &self.fragments)?;
13071 }
13072 if let Some(v) = self.ctx.as_ref() {
13073 struct_ser.serialize_field("ctx", v)?;
13074 }
13075 struct_ser.end()
13076 }
13077}
13078impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
13079 #[allow(deprecated)]
13080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13081 where
13082 D: serde::Deserializer<'de>,
13083 {
13084 const FIELDS: &[&str] = &[
13085 "fragments",
13086 "ctx",
13087 ];
13088
13089 #[allow(clippy::enum_variant_names)]
13090 enum GeneratedField {
13091 Fragments,
13092 Ctx,
13093 }
13094 impl<'de> serde::Deserialize<'de> for GeneratedField {
13095 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13096 where
13097 D: serde::Deserializer<'de>,
13098 {
13099 struct GeneratedVisitor;
13100
13101 impl serde::de::Visitor<'_> for GeneratedVisitor {
13102 type Value = GeneratedField;
13103
13104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13105 write!(formatter, "expected one of: {:?}", &FIELDS)
13106 }
13107
13108 #[allow(unused_variables)]
13109 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13110 where
13111 E: serde::de::Error,
13112 {
13113 match value {
13114 "fragments" => Ok(GeneratedField::Fragments),
13115 "ctx" => Ok(GeneratedField::Ctx),
13116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13117 }
13118 }
13119 }
13120 deserializer.deserialize_identifier(GeneratedVisitor)
13121 }
13122 }
13123 struct GeneratedVisitor;
13124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13125 type Value = list_table_fragments_response::TableFragmentInfo;
13126
13127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13128 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
13129 }
13130
13131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
13132 where
13133 V: serde::de::MapAccess<'de>,
13134 {
13135 let mut fragments__ = None;
13136 let mut ctx__ = None;
13137 while let Some(k) = map_.next_key()? {
13138 match k {
13139 GeneratedField::Fragments => {
13140 if fragments__.is_some() {
13141 return Err(serde::de::Error::duplicate_field("fragments"));
13142 }
13143 fragments__ = Some(map_.next_value()?);
13144 }
13145 GeneratedField::Ctx => {
13146 if ctx__.is_some() {
13147 return Err(serde::de::Error::duplicate_field("ctx"));
13148 }
13149 ctx__ = map_.next_value()?;
13150 }
13151 }
13152 }
13153 Ok(list_table_fragments_response::TableFragmentInfo {
13154 fragments: fragments__.unwrap_or_default(),
13155 ctx: ctx__,
13156 })
13157 }
13158 }
13159 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
13160 }
13161}
13162impl serde::Serialize for ListUnmigratedTablesRequest {
13163 #[allow(deprecated)]
13164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13165 where
13166 S: serde::Serializer,
13167 {
13168 use serde::ser::SerializeStruct;
13169 let len = 0;
13170 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
13171 struct_ser.end()
13172 }
13173}
13174impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
13175 #[allow(deprecated)]
13176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13177 where
13178 D: serde::Deserializer<'de>,
13179 {
13180 const FIELDS: &[&str] = &[
13181 ];
13182
13183 #[allow(clippy::enum_variant_names)]
13184 enum GeneratedField {
13185 }
13186 impl<'de> serde::Deserialize<'de> for GeneratedField {
13187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13188 where
13189 D: serde::Deserializer<'de>,
13190 {
13191 struct GeneratedVisitor;
13192
13193 impl serde::de::Visitor<'_> for GeneratedVisitor {
13194 type Value = GeneratedField;
13195
13196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13197 write!(formatter, "expected one of: {:?}", &FIELDS)
13198 }
13199
13200 #[allow(unused_variables)]
13201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13202 where
13203 E: serde::de::Error,
13204 {
13205 Err(serde::de::Error::unknown_field(value, FIELDS))
13206 }
13207 }
13208 deserializer.deserialize_identifier(GeneratedVisitor)
13209 }
13210 }
13211 struct GeneratedVisitor;
13212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13213 type Value = ListUnmigratedTablesRequest;
13214
13215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13216 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
13217 }
13218
13219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
13220 where
13221 V: serde::de::MapAccess<'de>,
13222 {
13223 while map_.next_key::<GeneratedField>()?.is_some() {
13224 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13225 }
13226 Ok(ListUnmigratedTablesRequest {
13227 })
13228 }
13229 }
13230 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
13231 }
13232}
13233impl serde::Serialize for ListUnmigratedTablesResponse {
13234 #[allow(deprecated)]
13235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13236 where
13237 S: serde::Serializer,
13238 {
13239 use serde::ser::SerializeStruct;
13240 let mut len = 0;
13241 if !self.tables.is_empty() {
13242 len += 1;
13243 }
13244 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
13245 if !self.tables.is_empty() {
13246 struct_ser.serialize_field("tables", &self.tables)?;
13247 }
13248 struct_ser.end()
13249 }
13250}
13251impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
13252 #[allow(deprecated)]
13253 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13254 where
13255 D: serde::Deserializer<'de>,
13256 {
13257 const FIELDS: &[&str] = &[
13258 "tables",
13259 ];
13260
13261 #[allow(clippy::enum_variant_names)]
13262 enum GeneratedField {
13263 Tables,
13264 }
13265 impl<'de> serde::Deserialize<'de> for GeneratedField {
13266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13267 where
13268 D: serde::Deserializer<'de>,
13269 {
13270 struct GeneratedVisitor;
13271
13272 impl serde::de::Visitor<'_> for GeneratedVisitor {
13273 type Value = GeneratedField;
13274
13275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13276 write!(formatter, "expected one of: {:?}", &FIELDS)
13277 }
13278
13279 #[allow(unused_variables)]
13280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13281 where
13282 E: serde::de::Error,
13283 {
13284 match value {
13285 "tables" => Ok(GeneratedField::Tables),
13286 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13287 }
13288 }
13289 }
13290 deserializer.deserialize_identifier(GeneratedVisitor)
13291 }
13292 }
13293 struct GeneratedVisitor;
13294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13295 type Value = ListUnmigratedTablesResponse;
13296
13297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13298 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
13299 }
13300
13301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
13302 where
13303 V: serde::de::MapAccess<'de>,
13304 {
13305 let mut tables__ = None;
13306 while let Some(k) = map_.next_key()? {
13307 match k {
13308 GeneratedField::Tables => {
13309 if tables__.is_some() {
13310 return Err(serde::de::Error::duplicate_field("tables"));
13311 }
13312 tables__ = Some(map_.next_value()?);
13313 }
13314 }
13315 }
13316 Ok(ListUnmigratedTablesResponse {
13317 tables: tables__.unwrap_or_default(),
13318 })
13319 }
13320 }
13321 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
13322 }
13323}
13324impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
13325 #[allow(deprecated)]
13326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13327 where
13328 S: serde::Serializer,
13329 {
13330 use serde::ser::SerializeStruct;
13331 let mut len = 0;
13332 if self.table_id != 0 {
13333 len += 1;
13334 }
13335 if !self.table_name.is_empty() {
13336 len += 1;
13337 }
13338 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
13339 if self.table_id != 0 {
13340 struct_ser.serialize_field("tableId", &self.table_id)?;
13341 }
13342 if !self.table_name.is_empty() {
13343 struct_ser.serialize_field("tableName", &self.table_name)?;
13344 }
13345 struct_ser.end()
13346 }
13347}
13348impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
13349 #[allow(deprecated)]
13350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13351 where
13352 D: serde::Deserializer<'de>,
13353 {
13354 const FIELDS: &[&str] = &[
13355 "table_id",
13356 "tableId",
13357 "table_name",
13358 "tableName",
13359 ];
13360
13361 #[allow(clippy::enum_variant_names)]
13362 enum GeneratedField {
13363 TableId,
13364 TableName,
13365 }
13366 impl<'de> serde::Deserialize<'de> for GeneratedField {
13367 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13368 where
13369 D: serde::Deserializer<'de>,
13370 {
13371 struct GeneratedVisitor;
13372
13373 impl serde::de::Visitor<'_> for GeneratedVisitor {
13374 type Value = GeneratedField;
13375
13376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13377 write!(formatter, "expected one of: {:?}", &FIELDS)
13378 }
13379
13380 #[allow(unused_variables)]
13381 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13382 where
13383 E: serde::de::Error,
13384 {
13385 match value {
13386 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13387 "tableName" | "table_name" => Ok(GeneratedField::TableName),
13388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13389 }
13390 }
13391 }
13392 deserializer.deserialize_identifier(GeneratedVisitor)
13393 }
13394 }
13395 struct GeneratedVisitor;
13396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13397 type Value = list_unmigrated_tables_response::UnmigratedTable;
13398
13399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13400 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
13401 }
13402
13403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
13404 where
13405 V: serde::de::MapAccess<'de>,
13406 {
13407 let mut table_id__ = None;
13408 let mut table_name__ = None;
13409 while let Some(k) = map_.next_key()? {
13410 match k {
13411 GeneratedField::TableId => {
13412 if table_id__.is_some() {
13413 return Err(serde::de::Error::duplicate_field("tableId"));
13414 }
13415 table_id__ =
13416 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13417 ;
13418 }
13419 GeneratedField::TableName => {
13420 if table_name__.is_some() {
13421 return Err(serde::de::Error::duplicate_field("tableName"));
13422 }
13423 table_name__ = Some(map_.next_value()?);
13424 }
13425 }
13426 }
13427 Ok(list_unmigrated_tables_response::UnmigratedTable {
13428 table_id: table_id__.unwrap_or_default(),
13429 table_name: table_name__.unwrap_or_default(),
13430 })
13431 }
13432 }
13433 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13434 }
13435}
13436impl serde::Serialize for MembersRequest {
13437 #[allow(deprecated)]
13438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13439 where
13440 S: serde::Serializer,
13441 {
13442 use serde::ser::SerializeStruct;
13443 let len = 0;
13444 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13445 struct_ser.end()
13446 }
13447}
13448impl<'de> serde::Deserialize<'de> for MembersRequest {
13449 #[allow(deprecated)]
13450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13451 where
13452 D: serde::Deserializer<'de>,
13453 {
13454 const FIELDS: &[&str] = &[
13455 ];
13456
13457 #[allow(clippy::enum_variant_names)]
13458 enum GeneratedField {
13459 }
13460 impl<'de> serde::Deserialize<'de> for GeneratedField {
13461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13462 where
13463 D: serde::Deserializer<'de>,
13464 {
13465 struct GeneratedVisitor;
13466
13467 impl serde::de::Visitor<'_> for GeneratedVisitor {
13468 type Value = GeneratedField;
13469
13470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13471 write!(formatter, "expected one of: {:?}", &FIELDS)
13472 }
13473
13474 #[allow(unused_variables)]
13475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13476 where
13477 E: serde::de::Error,
13478 {
13479 Err(serde::de::Error::unknown_field(value, FIELDS))
13480 }
13481 }
13482 deserializer.deserialize_identifier(GeneratedVisitor)
13483 }
13484 }
13485 struct GeneratedVisitor;
13486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13487 type Value = MembersRequest;
13488
13489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13490 formatter.write_str("struct meta.MembersRequest")
13491 }
13492
13493 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13494 where
13495 V: serde::de::MapAccess<'de>,
13496 {
13497 while map_.next_key::<GeneratedField>()?.is_some() {
13498 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13499 }
13500 Ok(MembersRequest {
13501 })
13502 }
13503 }
13504 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13505 }
13506}
13507impl serde::Serialize for MembersResponse {
13508 #[allow(deprecated)]
13509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13510 where
13511 S: serde::Serializer,
13512 {
13513 use serde::ser::SerializeStruct;
13514 let mut len = 0;
13515 if !self.members.is_empty() {
13516 len += 1;
13517 }
13518 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13519 if !self.members.is_empty() {
13520 struct_ser.serialize_field("members", &self.members)?;
13521 }
13522 struct_ser.end()
13523 }
13524}
13525impl<'de> serde::Deserialize<'de> for MembersResponse {
13526 #[allow(deprecated)]
13527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13528 where
13529 D: serde::Deserializer<'de>,
13530 {
13531 const FIELDS: &[&str] = &[
13532 "members",
13533 ];
13534
13535 #[allow(clippy::enum_variant_names)]
13536 enum GeneratedField {
13537 Members,
13538 }
13539 impl<'de> serde::Deserialize<'de> for GeneratedField {
13540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13541 where
13542 D: serde::Deserializer<'de>,
13543 {
13544 struct GeneratedVisitor;
13545
13546 impl serde::de::Visitor<'_> for GeneratedVisitor {
13547 type Value = GeneratedField;
13548
13549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13550 write!(formatter, "expected one of: {:?}", &FIELDS)
13551 }
13552
13553 #[allow(unused_variables)]
13554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13555 where
13556 E: serde::de::Error,
13557 {
13558 match value {
13559 "members" => Ok(GeneratedField::Members),
13560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13561 }
13562 }
13563 }
13564 deserializer.deserialize_identifier(GeneratedVisitor)
13565 }
13566 }
13567 struct GeneratedVisitor;
13568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13569 type Value = MembersResponse;
13570
13571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13572 formatter.write_str("struct meta.MembersResponse")
13573 }
13574
13575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13576 where
13577 V: serde::de::MapAccess<'de>,
13578 {
13579 let mut members__ = None;
13580 while let Some(k) = map_.next_key()? {
13581 match k {
13582 GeneratedField::Members => {
13583 if members__.is_some() {
13584 return Err(serde::de::Error::duplicate_field("members"));
13585 }
13586 members__ = Some(map_.next_value()?);
13587 }
13588 }
13589 }
13590 Ok(MembersResponse {
13591 members: members__.unwrap_or_default(),
13592 })
13593 }
13594 }
13595 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13596 }
13597}
13598impl serde::Serialize for MetaMember {
13599 #[allow(deprecated)]
13600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13601 where
13602 S: serde::Serializer,
13603 {
13604 use serde::ser::SerializeStruct;
13605 let mut len = 0;
13606 if self.address.is_some() {
13607 len += 1;
13608 }
13609 if self.is_leader {
13610 len += 1;
13611 }
13612 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13613 if let Some(v) = self.address.as_ref() {
13614 struct_ser.serialize_field("address", v)?;
13615 }
13616 if self.is_leader {
13617 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13618 }
13619 struct_ser.end()
13620 }
13621}
13622impl<'de> serde::Deserialize<'de> for MetaMember {
13623 #[allow(deprecated)]
13624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13625 where
13626 D: serde::Deserializer<'de>,
13627 {
13628 const FIELDS: &[&str] = &[
13629 "address",
13630 "is_leader",
13631 "isLeader",
13632 ];
13633
13634 #[allow(clippy::enum_variant_names)]
13635 enum GeneratedField {
13636 Address,
13637 IsLeader,
13638 }
13639 impl<'de> serde::Deserialize<'de> for GeneratedField {
13640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13641 where
13642 D: serde::Deserializer<'de>,
13643 {
13644 struct GeneratedVisitor;
13645
13646 impl serde::de::Visitor<'_> for GeneratedVisitor {
13647 type Value = GeneratedField;
13648
13649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13650 write!(formatter, "expected one of: {:?}", &FIELDS)
13651 }
13652
13653 #[allow(unused_variables)]
13654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13655 where
13656 E: serde::de::Error,
13657 {
13658 match value {
13659 "address" => Ok(GeneratedField::Address),
13660 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13662 }
13663 }
13664 }
13665 deserializer.deserialize_identifier(GeneratedVisitor)
13666 }
13667 }
13668 struct GeneratedVisitor;
13669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13670 type Value = MetaMember;
13671
13672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13673 formatter.write_str("struct meta.MetaMember")
13674 }
13675
13676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13677 where
13678 V: serde::de::MapAccess<'de>,
13679 {
13680 let mut address__ = None;
13681 let mut is_leader__ = None;
13682 while let Some(k) = map_.next_key()? {
13683 match k {
13684 GeneratedField::Address => {
13685 if address__.is_some() {
13686 return Err(serde::de::Error::duplicate_field("address"));
13687 }
13688 address__ = map_.next_value()?;
13689 }
13690 GeneratedField::IsLeader => {
13691 if is_leader__.is_some() {
13692 return Err(serde::de::Error::duplicate_field("isLeader"));
13693 }
13694 is_leader__ = Some(map_.next_value()?);
13695 }
13696 }
13697 }
13698 Ok(MetaMember {
13699 address: address__,
13700 is_leader: is_leader__.unwrap_or_default(),
13701 })
13702 }
13703 }
13704 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13705 }
13706}
13707impl serde::Serialize for MetaSnapshot {
13708 #[allow(deprecated)]
13709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13710 where
13711 S: serde::Serializer,
13712 {
13713 use serde::ser::SerializeStruct;
13714 let mut len = 0;
13715 if !self.databases.is_empty() {
13716 len += 1;
13717 }
13718 if !self.schemas.is_empty() {
13719 len += 1;
13720 }
13721 if !self.sources.is_empty() {
13722 len += 1;
13723 }
13724 if !self.sinks.is_empty() {
13725 len += 1;
13726 }
13727 if !self.tables.is_empty() {
13728 len += 1;
13729 }
13730 if !self.indexes.is_empty() {
13731 len += 1;
13732 }
13733 if !self.views.is_empty() {
13734 len += 1;
13735 }
13736 if !self.functions.is_empty() {
13737 len += 1;
13738 }
13739 if !self.connections.is_empty() {
13740 len += 1;
13741 }
13742 if !self.subscriptions.is_empty() {
13743 len += 1;
13744 }
13745 if !self.users.is_empty() {
13746 len += 1;
13747 }
13748 if self.session_params.is_some() {
13749 len += 1;
13750 }
13751 if !self.secrets.is_empty() {
13752 len += 1;
13753 }
13754 if self.cluster_resource.is_some() {
13755 len += 1;
13756 }
13757 if !self.nodes.is_empty() {
13758 len += 1;
13759 }
13760 if self.hummock_version.is_some() {
13761 len += 1;
13762 }
13763 if self.meta_backup_manifest_id.is_some() {
13764 len += 1;
13765 }
13766 if self.hummock_write_limits.is_some() {
13767 len += 1;
13768 }
13769 if !self.streaming_worker_slot_mappings.is_empty() {
13770 len += 1;
13771 }
13772 if !self.serving_worker_slot_mappings.is_empty() {
13773 len += 1;
13774 }
13775 if !self.object_dependencies.is_empty() {
13776 len += 1;
13777 }
13778 if self.version.is_some() {
13779 len += 1;
13780 }
13781 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13782 if !self.databases.is_empty() {
13783 struct_ser.serialize_field("databases", &self.databases)?;
13784 }
13785 if !self.schemas.is_empty() {
13786 struct_ser.serialize_field("schemas", &self.schemas)?;
13787 }
13788 if !self.sources.is_empty() {
13789 struct_ser.serialize_field("sources", &self.sources)?;
13790 }
13791 if !self.sinks.is_empty() {
13792 struct_ser.serialize_field("sinks", &self.sinks)?;
13793 }
13794 if !self.tables.is_empty() {
13795 struct_ser.serialize_field("tables", &self.tables)?;
13796 }
13797 if !self.indexes.is_empty() {
13798 struct_ser.serialize_field("indexes", &self.indexes)?;
13799 }
13800 if !self.views.is_empty() {
13801 struct_ser.serialize_field("views", &self.views)?;
13802 }
13803 if !self.functions.is_empty() {
13804 struct_ser.serialize_field("functions", &self.functions)?;
13805 }
13806 if !self.connections.is_empty() {
13807 struct_ser.serialize_field("connections", &self.connections)?;
13808 }
13809 if !self.subscriptions.is_empty() {
13810 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13811 }
13812 if !self.users.is_empty() {
13813 struct_ser.serialize_field("users", &self.users)?;
13814 }
13815 if let Some(v) = self.session_params.as_ref() {
13816 struct_ser.serialize_field("sessionParams", v)?;
13817 }
13818 if !self.secrets.is_empty() {
13819 struct_ser.serialize_field("secrets", &self.secrets)?;
13820 }
13821 if let Some(v) = self.cluster_resource.as_ref() {
13822 struct_ser.serialize_field("clusterResource", v)?;
13823 }
13824 if !self.nodes.is_empty() {
13825 struct_ser.serialize_field("nodes", &self.nodes)?;
13826 }
13827 if let Some(v) = self.hummock_version.as_ref() {
13828 struct_ser.serialize_field("hummockVersion", v)?;
13829 }
13830 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
13831 struct_ser.serialize_field("metaBackupManifestId", v)?;
13832 }
13833 if let Some(v) = self.hummock_write_limits.as_ref() {
13834 struct_ser.serialize_field("hummockWriteLimits", v)?;
13835 }
13836 if !self.streaming_worker_slot_mappings.is_empty() {
13837 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
13838 }
13839 if !self.serving_worker_slot_mappings.is_empty() {
13840 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
13841 }
13842 if !self.object_dependencies.is_empty() {
13843 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
13844 }
13845 if let Some(v) = self.version.as_ref() {
13846 struct_ser.serialize_field("version", v)?;
13847 }
13848 struct_ser.end()
13849 }
13850}
13851impl<'de> serde::Deserialize<'de> for MetaSnapshot {
13852 #[allow(deprecated)]
13853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13854 where
13855 D: serde::Deserializer<'de>,
13856 {
13857 const FIELDS: &[&str] = &[
13858 "databases",
13859 "schemas",
13860 "sources",
13861 "sinks",
13862 "tables",
13863 "indexes",
13864 "views",
13865 "functions",
13866 "connections",
13867 "subscriptions",
13868 "users",
13869 "session_params",
13870 "sessionParams",
13871 "secrets",
13872 "cluster_resource",
13873 "clusterResource",
13874 "nodes",
13875 "hummock_version",
13876 "hummockVersion",
13877 "meta_backup_manifest_id",
13878 "metaBackupManifestId",
13879 "hummock_write_limits",
13880 "hummockWriteLimits",
13881 "streaming_worker_slot_mappings",
13882 "streamingWorkerSlotMappings",
13883 "serving_worker_slot_mappings",
13884 "servingWorkerSlotMappings",
13885 "object_dependencies",
13886 "objectDependencies",
13887 "version",
13888 ];
13889
13890 #[allow(clippy::enum_variant_names)]
13891 enum GeneratedField {
13892 Databases,
13893 Schemas,
13894 Sources,
13895 Sinks,
13896 Tables,
13897 Indexes,
13898 Views,
13899 Functions,
13900 Connections,
13901 Subscriptions,
13902 Users,
13903 SessionParams,
13904 Secrets,
13905 ClusterResource,
13906 Nodes,
13907 HummockVersion,
13908 MetaBackupManifestId,
13909 HummockWriteLimits,
13910 StreamingWorkerSlotMappings,
13911 ServingWorkerSlotMappings,
13912 ObjectDependencies,
13913 Version,
13914 }
13915 impl<'de> serde::Deserialize<'de> for GeneratedField {
13916 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13917 where
13918 D: serde::Deserializer<'de>,
13919 {
13920 struct GeneratedVisitor;
13921
13922 impl serde::de::Visitor<'_> for GeneratedVisitor {
13923 type Value = GeneratedField;
13924
13925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13926 write!(formatter, "expected one of: {:?}", &FIELDS)
13927 }
13928
13929 #[allow(unused_variables)]
13930 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13931 where
13932 E: serde::de::Error,
13933 {
13934 match value {
13935 "databases" => Ok(GeneratedField::Databases),
13936 "schemas" => Ok(GeneratedField::Schemas),
13937 "sources" => Ok(GeneratedField::Sources),
13938 "sinks" => Ok(GeneratedField::Sinks),
13939 "tables" => Ok(GeneratedField::Tables),
13940 "indexes" => Ok(GeneratedField::Indexes),
13941 "views" => Ok(GeneratedField::Views),
13942 "functions" => Ok(GeneratedField::Functions),
13943 "connections" => Ok(GeneratedField::Connections),
13944 "subscriptions" => Ok(GeneratedField::Subscriptions),
13945 "users" => Ok(GeneratedField::Users),
13946 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13947 "secrets" => Ok(GeneratedField::Secrets),
13948 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13949 "nodes" => Ok(GeneratedField::Nodes),
13950 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13951 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13952 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13953 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13954 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13955 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
13956 "version" => Ok(GeneratedField::Version),
13957 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13958 }
13959 }
13960 }
13961 deserializer.deserialize_identifier(GeneratedVisitor)
13962 }
13963 }
13964 struct GeneratedVisitor;
13965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13966 type Value = MetaSnapshot;
13967
13968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13969 formatter.write_str("struct meta.MetaSnapshot")
13970 }
13971
13972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13973 where
13974 V: serde::de::MapAccess<'de>,
13975 {
13976 let mut databases__ = None;
13977 let mut schemas__ = None;
13978 let mut sources__ = None;
13979 let mut sinks__ = None;
13980 let mut tables__ = None;
13981 let mut indexes__ = None;
13982 let mut views__ = None;
13983 let mut functions__ = None;
13984 let mut connections__ = None;
13985 let mut subscriptions__ = None;
13986 let mut users__ = None;
13987 let mut session_params__ = None;
13988 let mut secrets__ = None;
13989 let mut cluster_resource__ = None;
13990 let mut nodes__ = None;
13991 let mut hummock_version__ = None;
13992 let mut meta_backup_manifest_id__ = None;
13993 let mut hummock_write_limits__ = None;
13994 let mut streaming_worker_slot_mappings__ = None;
13995 let mut serving_worker_slot_mappings__ = None;
13996 let mut object_dependencies__ = None;
13997 let mut version__ = None;
13998 while let Some(k) = map_.next_key()? {
13999 match k {
14000 GeneratedField::Databases => {
14001 if databases__.is_some() {
14002 return Err(serde::de::Error::duplicate_field("databases"));
14003 }
14004 databases__ = Some(map_.next_value()?);
14005 }
14006 GeneratedField::Schemas => {
14007 if schemas__.is_some() {
14008 return Err(serde::de::Error::duplicate_field("schemas"));
14009 }
14010 schemas__ = Some(map_.next_value()?);
14011 }
14012 GeneratedField::Sources => {
14013 if sources__.is_some() {
14014 return Err(serde::de::Error::duplicate_field("sources"));
14015 }
14016 sources__ = Some(map_.next_value()?);
14017 }
14018 GeneratedField::Sinks => {
14019 if sinks__.is_some() {
14020 return Err(serde::de::Error::duplicate_field("sinks"));
14021 }
14022 sinks__ = Some(map_.next_value()?);
14023 }
14024 GeneratedField::Tables => {
14025 if tables__.is_some() {
14026 return Err(serde::de::Error::duplicate_field("tables"));
14027 }
14028 tables__ = Some(map_.next_value()?);
14029 }
14030 GeneratedField::Indexes => {
14031 if indexes__.is_some() {
14032 return Err(serde::de::Error::duplicate_field("indexes"));
14033 }
14034 indexes__ = Some(map_.next_value()?);
14035 }
14036 GeneratedField::Views => {
14037 if views__.is_some() {
14038 return Err(serde::de::Error::duplicate_field("views"));
14039 }
14040 views__ = Some(map_.next_value()?);
14041 }
14042 GeneratedField::Functions => {
14043 if functions__.is_some() {
14044 return Err(serde::de::Error::duplicate_field("functions"));
14045 }
14046 functions__ = Some(map_.next_value()?);
14047 }
14048 GeneratedField::Connections => {
14049 if connections__.is_some() {
14050 return Err(serde::de::Error::duplicate_field("connections"));
14051 }
14052 connections__ = Some(map_.next_value()?);
14053 }
14054 GeneratedField::Subscriptions => {
14055 if subscriptions__.is_some() {
14056 return Err(serde::de::Error::duplicate_field("subscriptions"));
14057 }
14058 subscriptions__ = Some(map_.next_value()?);
14059 }
14060 GeneratedField::Users => {
14061 if users__.is_some() {
14062 return Err(serde::de::Error::duplicate_field("users"));
14063 }
14064 users__ = Some(map_.next_value()?);
14065 }
14066 GeneratedField::SessionParams => {
14067 if session_params__.is_some() {
14068 return Err(serde::de::Error::duplicate_field("sessionParams"));
14069 }
14070 session_params__ = map_.next_value()?;
14071 }
14072 GeneratedField::Secrets => {
14073 if secrets__.is_some() {
14074 return Err(serde::de::Error::duplicate_field("secrets"));
14075 }
14076 secrets__ = Some(map_.next_value()?);
14077 }
14078 GeneratedField::ClusterResource => {
14079 if cluster_resource__.is_some() {
14080 return Err(serde::de::Error::duplicate_field("clusterResource"));
14081 }
14082 cluster_resource__ = map_.next_value()?;
14083 }
14084 GeneratedField::Nodes => {
14085 if nodes__.is_some() {
14086 return Err(serde::de::Error::duplicate_field("nodes"));
14087 }
14088 nodes__ = Some(map_.next_value()?);
14089 }
14090 GeneratedField::HummockVersion => {
14091 if hummock_version__.is_some() {
14092 return Err(serde::de::Error::duplicate_field("hummockVersion"));
14093 }
14094 hummock_version__ = map_.next_value()?;
14095 }
14096 GeneratedField::MetaBackupManifestId => {
14097 if meta_backup_manifest_id__.is_some() {
14098 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14099 }
14100 meta_backup_manifest_id__ = map_.next_value()?;
14101 }
14102 GeneratedField::HummockWriteLimits => {
14103 if hummock_write_limits__.is_some() {
14104 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14105 }
14106 hummock_write_limits__ = map_.next_value()?;
14107 }
14108 GeneratedField::StreamingWorkerSlotMappings => {
14109 if streaming_worker_slot_mappings__.is_some() {
14110 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
14111 }
14112 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
14113 }
14114 GeneratedField::ServingWorkerSlotMappings => {
14115 if serving_worker_slot_mappings__.is_some() {
14116 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14117 }
14118 serving_worker_slot_mappings__ = Some(map_.next_value()?);
14119 }
14120 GeneratedField::ObjectDependencies => {
14121 if object_dependencies__.is_some() {
14122 return Err(serde::de::Error::duplicate_field("objectDependencies"));
14123 }
14124 object_dependencies__ = Some(map_.next_value()?);
14125 }
14126 GeneratedField::Version => {
14127 if version__.is_some() {
14128 return Err(serde::de::Error::duplicate_field("version"));
14129 }
14130 version__ = map_.next_value()?;
14131 }
14132 }
14133 }
14134 Ok(MetaSnapshot {
14135 databases: databases__.unwrap_or_default(),
14136 schemas: schemas__.unwrap_or_default(),
14137 sources: sources__.unwrap_or_default(),
14138 sinks: sinks__.unwrap_or_default(),
14139 tables: tables__.unwrap_or_default(),
14140 indexes: indexes__.unwrap_or_default(),
14141 views: views__.unwrap_or_default(),
14142 functions: functions__.unwrap_or_default(),
14143 connections: connections__.unwrap_or_default(),
14144 subscriptions: subscriptions__.unwrap_or_default(),
14145 users: users__.unwrap_or_default(),
14146 session_params: session_params__,
14147 secrets: secrets__.unwrap_or_default(),
14148 cluster_resource: cluster_resource__,
14149 nodes: nodes__.unwrap_or_default(),
14150 hummock_version: hummock_version__,
14151 meta_backup_manifest_id: meta_backup_manifest_id__,
14152 hummock_write_limits: hummock_write_limits__,
14153 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
14154 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
14155 object_dependencies: object_dependencies__.unwrap_or_default(),
14156 version: version__,
14157 })
14158 }
14159 }
14160 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
14161 }
14162}
14163impl serde::Serialize for meta_snapshot::SnapshotVersion {
14164 #[allow(deprecated)]
14165 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14166 where
14167 S: serde::Serializer,
14168 {
14169 use serde::ser::SerializeStruct;
14170 let mut len = 0;
14171 if self.catalog_version != 0 {
14172 len += 1;
14173 }
14174 if self.worker_node_version != 0 {
14175 len += 1;
14176 }
14177 if self.streaming_worker_slot_mapping_version != 0 {
14178 len += 1;
14179 }
14180 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
14181 if self.catalog_version != 0 {
14182 #[allow(clippy::needless_borrow)]
14183 #[allow(clippy::needless_borrows_for_generic_args)]
14184 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
14185 }
14186 if self.worker_node_version != 0 {
14187 #[allow(clippy::needless_borrow)]
14188 #[allow(clippy::needless_borrows_for_generic_args)]
14189 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
14190 }
14191 if self.streaming_worker_slot_mapping_version != 0 {
14192 #[allow(clippy::needless_borrow)]
14193 #[allow(clippy::needless_borrows_for_generic_args)]
14194 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
14195 }
14196 struct_ser.end()
14197 }
14198}
14199impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
14200 #[allow(deprecated)]
14201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14202 where
14203 D: serde::Deserializer<'de>,
14204 {
14205 const FIELDS: &[&str] = &[
14206 "catalog_version",
14207 "catalogVersion",
14208 "worker_node_version",
14209 "workerNodeVersion",
14210 "streaming_worker_slot_mapping_version",
14211 "streamingWorkerSlotMappingVersion",
14212 ];
14213
14214 #[allow(clippy::enum_variant_names)]
14215 enum GeneratedField {
14216 CatalogVersion,
14217 WorkerNodeVersion,
14218 StreamingWorkerSlotMappingVersion,
14219 }
14220 impl<'de> serde::Deserialize<'de> for GeneratedField {
14221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14222 where
14223 D: serde::Deserializer<'de>,
14224 {
14225 struct GeneratedVisitor;
14226
14227 impl serde::de::Visitor<'_> for GeneratedVisitor {
14228 type Value = GeneratedField;
14229
14230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14231 write!(formatter, "expected one of: {:?}", &FIELDS)
14232 }
14233
14234 #[allow(unused_variables)]
14235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14236 where
14237 E: serde::de::Error,
14238 {
14239 match value {
14240 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
14241 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
14242 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
14243 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14244 }
14245 }
14246 }
14247 deserializer.deserialize_identifier(GeneratedVisitor)
14248 }
14249 }
14250 struct GeneratedVisitor;
14251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14252 type Value = meta_snapshot::SnapshotVersion;
14253
14254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14255 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
14256 }
14257
14258 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
14259 where
14260 V: serde::de::MapAccess<'de>,
14261 {
14262 let mut catalog_version__ = None;
14263 let mut worker_node_version__ = None;
14264 let mut streaming_worker_slot_mapping_version__ = None;
14265 while let Some(k) = map_.next_key()? {
14266 match k {
14267 GeneratedField::CatalogVersion => {
14268 if catalog_version__.is_some() {
14269 return Err(serde::de::Error::duplicate_field("catalogVersion"));
14270 }
14271 catalog_version__ =
14272 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14273 ;
14274 }
14275 GeneratedField::WorkerNodeVersion => {
14276 if worker_node_version__.is_some() {
14277 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
14278 }
14279 worker_node_version__ =
14280 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14281 ;
14282 }
14283 GeneratedField::StreamingWorkerSlotMappingVersion => {
14284 if streaming_worker_slot_mapping_version__.is_some() {
14285 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
14286 }
14287 streaming_worker_slot_mapping_version__ =
14288 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14289 ;
14290 }
14291 }
14292 }
14293 Ok(meta_snapshot::SnapshotVersion {
14294 catalog_version: catalog_version__.unwrap_or_default(),
14295 worker_node_version: worker_node_version__.unwrap_or_default(),
14296 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
14297 })
14298 }
14299 }
14300 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
14301 }
14302}
14303impl serde::Serialize for MigrationPlan {
14304 #[allow(deprecated)]
14305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14306 where
14307 S: serde::Serializer,
14308 {
14309 use serde::ser::SerializeStruct;
14310 let mut len = 0;
14311 if !self.worker_slot_migration_plan.is_empty() {
14312 len += 1;
14313 }
14314 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
14315 if !self.worker_slot_migration_plan.is_empty() {
14316 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
14317 .map(|(k, v)| (k, v.to_string())).collect();
14318 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
14319 }
14320 struct_ser.end()
14321 }
14322}
14323impl<'de> serde::Deserialize<'de> for MigrationPlan {
14324 #[allow(deprecated)]
14325 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14326 where
14327 D: serde::Deserializer<'de>,
14328 {
14329 const FIELDS: &[&str] = &[
14330 "worker_slot_migration_plan",
14331 "workerSlotMigrationPlan",
14332 ];
14333
14334 #[allow(clippy::enum_variant_names)]
14335 enum GeneratedField {
14336 WorkerSlotMigrationPlan,
14337 }
14338 impl<'de> serde::Deserialize<'de> for GeneratedField {
14339 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14340 where
14341 D: serde::Deserializer<'de>,
14342 {
14343 struct GeneratedVisitor;
14344
14345 impl serde::de::Visitor<'_> for GeneratedVisitor {
14346 type Value = GeneratedField;
14347
14348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14349 write!(formatter, "expected one of: {:?}", &FIELDS)
14350 }
14351
14352 #[allow(unused_variables)]
14353 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14354 where
14355 E: serde::de::Error,
14356 {
14357 match value {
14358 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
14359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14360 }
14361 }
14362 }
14363 deserializer.deserialize_identifier(GeneratedVisitor)
14364 }
14365 }
14366 struct GeneratedVisitor;
14367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14368 type Value = MigrationPlan;
14369
14370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14371 formatter.write_str("struct meta.MigrationPlan")
14372 }
14373
14374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
14375 where
14376 V: serde::de::MapAccess<'de>,
14377 {
14378 let mut worker_slot_migration_plan__ = None;
14379 while let Some(k) = map_.next_key()? {
14380 match k {
14381 GeneratedField::WorkerSlotMigrationPlan => {
14382 if worker_slot_migration_plan__.is_some() {
14383 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
14384 }
14385 worker_slot_migration_plan__ = Some(
14386 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14387 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
14388 );
14389 }
14390 }
14391 }
14392 Ok(MigrationPlan {
14393 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
14394 })
14395 }
14396 }
14397 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
14398 }
14399}
14400impl serde::Serialize for Object {
14401 #[allow(deprecated)]
14402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14403 where
14404 S: serde::Serializer,
14405 {
14406 use serde::ser::SerializeStruct;
14407 let mut len = 0;
14408 if self.object_info.is_some() {
14409 len += 1;
14410 }
14411 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
14412 if let Some(v) = self.object_info.as_ref() {
14413 match v {
14414 object::ObjectInfo::Database(v) => {
14415 struct_ser.serialize_field("database", v)?;
14416 }
14417 object::ObjectInfo::Schema(v) => {
14418 struct_ser.serialize_field("schema", v)?;
14419 }
14420 object::ObjectInfo::Table(v) => {
14421 struct_ser.serialize_field("table", v)?;
14422 }
14423 object::ObjectInfo::Index(v) => {
14424 struct_ser.serialize_field("index", v)?;
14425 }
14426 object::ObjectInfo::Source(v) => {
14427 struct_ser.serialize_field("source", v)?;
14428 }
14429 object::ObjectInfo::Sink(v) => {
14430 struct_ser.serialize_field("sink", v)?;
14431 }
14432 object::ObjectInfo::View(v) => {
14433 struct_ser.serialize_field("view", v)?;
14434 }
14435 object::ObjectInfo::Function(v) => {
14436 struct_ser.serialize_field("function", v)?;
14437 }
14438 object::ObjectInfo::Connection(v) => {
14439 struct_ser.serialize_field("connection", v)?;
14440 }
14441 object::ObjectInfo::Subscription(v) => {
14442 struct_ser.serialize_field("subscription", v)?;
14443 }
14444 object::ObjectInfo::Secret(v) => {
14445 struct_ser.serialize_field("secret", v)?;
14446 }
14447 }
14448 }
14449 struct_ser.end()
14450 }
14451}
14452impl<'de> serde::Deserialize<'de> for Object {
14453 #[allow(deprecated)]
14454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14455 where
14456 D: serde::Deserializer<'de>,
14457 {
14458 const FIELDS: &[&str] = &[
14459 "database",
14460 "schema",
14461 "table",
14462 "index",
14463 "source",
14464 "sink",
14465 "view",
14466 "function",
14467 "connection",
14468 "subscription",
14469 "secret",
14470 ];
14471
14472 #[allow(clippy::enum_variant_names)]
14473 enum GeneratedField {
14474 Database,
14475 Schema,
14476 Table,
14477 Index,
14478 Source,
14479 Sink,
14480 View,
14481 Function,
14482 Connection,
14483 Subscription,
14484 Secret,
14485 }
14486 impl<'de> serde::Deserialize<'de> for GeneratedField {
14487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14488 where
14489 D: serde::Deserializer<'de>,
14490 {
14491 struct GeneratedVisitor;
14492
14493 impl serde::de::Visitor<'_> for GeneratedVisitor {
14494 type Value = GeneratedField;
14495
14496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14497 write!(formatter, "expected one of: {:?}", &FIELDS)
14498 }
14499
14500 #[allow(unused_variables)]
14501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14502 where
14503 E: serde::de::Error,
14504 {
14505 match value {
14506 "database" => Ok(GeneratedField::Database),
14507 "schema" => Ok(GeneratedField::Schema),
14508 "table" => Ok(GeneratedField::Table),
14509 "index" => Ok(GeneratedField::Index),
14510 "source" => Ok(GeneratedField::Source),
14511 "sink" => Ok(GeneratedField::Sink),
14512 "view" => Ok(GeneratedField::View),
14513 "function" => Ok(GeneratedField::Function),
14514 "connection" => Ok(GeneratedField::Connection),
14515 "subscription" => Ok(GeneratedField::Subscription),
14516 "secret" => Ok(GeneratedField::Secret),
14517 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14518 }
14519 }
14520 }
14521 deserializer.deserialize_identifier(GeneratedVisitor)
14522 }
14523 }
14524 struct GeneratedVisitor;
14525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14526 type Value = Object;
14527
14528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14529 formatter.write_str("struct meta.Object")
14530 }
14531
14532 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14533 where
14534 V: serde::de::MapAccess<'de>,
14535 {
14536 let mut object_info__ = None;
14537 while let Some(k) = map_.next_key()? {
14538 match k {
14539 GeneratedField::Database => {
14540 if object_info__.is_some() {
14541 return Err(serde::de::Error::duplicate_field("database"));
14542 }
14543 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14544;
14545 }
14546 GeneratedField::Schema => {
14547 if object_info__.is_some() {
14548 return Err(serde::de::Error::duplicate_field("schema"));
14549 }
14550 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14551;
14552 }
14553 GeneratedField::Table => {
14554 if object_info__.is_some() {
14555 return Err(serde::de::Error::duplicate_field("table"));
14556 }
14557 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14558;
14559 }
14560 GeneratedField::Index => {
14561 if object_info__.is_some() {
14562 return Err(serde::de::Error::duplicate_field("index"));
14563 }
14564 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14565;
14566 }
14567 GeneratedField::Source => {
14568 if object_info__.is_some() {
14569 return Err(serde::de::Error::duplicate_field("source"));
14570 }
14571 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14572;
14573 }
14574 GeneratedField::Sink => {
14575 if object_info__.is_some() {
14576 return Err(serde::de::Error::duplicate_field("sink"));
14577 }
14578 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14579;
14580 }
14581 GeneratedField::View => {
14582 if object_info__.is_some() {
14583 return Err(serde::de::Error::duplicate_field("view"));
14584 }
14585 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14586;
14587 }
14588 GeneratedField::Function => {
14589 if object_info__.is_some() {
14590 return Err(serde::de::Error::duplicate_field("function"));
14591 }
14592 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14593;
14594 }
14595 GeneratedField::Connection => {
14596 if object_info__.is_some() {
14597 return Err(serde::de::Error::duplicate_field("connection"));
14598 }
14599 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14600;
14601 }
14602 GeneratedField::Subscription => {
14603 if object_info__.is_some() {
14604 return Err(serde::de::Error::duplicate_field("subscription"));
14605 }
14606 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14607;
14608 }
14609 GeneratedField::Secret => {
14610 if object_info__.is_some() {
14611 return Err(serde::de::Error::duplicate_field("secret"));
14612 }
14613 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14614;
14615 }
14616 }
14617 }
14618 Ok(Object {
14619 object_info: object_info__,
14620 })
14621 }
14622 }
14623 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14624 }
14625}
14626impl serde::Serialize for ObjectDependency {
14627 #[allow(deprecated)]
14628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14629 where
14630 S: serde::Serializer,
14631 {
14632 use serde::ser::SerializeStruct;
14633 let mut len = 0;
14634 if self.object_id != 0 {
14635 len += 1;
14636 }
14637 if self.referenced_object_id != 0 {
14638 len += 1;
14639 }
14640 if self.referenced_object_type != 0 {
14641 len += 1;
14642 }
14643 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14644 if self.object_id != 0 {
14645 struct_ser.serialize_field("objectId", &self.object_id)?;
14646 }
14647 if self.referenced_object_id != 0 {
14648 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14649 }
14650 if self.referenced_object_type != 0 {
14651 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14652 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14653 struct_ser.serialize_field("referencedObjectType", &v)?;
14654 }
14655 struct_ser.end()
14656 }
14657}
14658impl<'de> serde::Deserialize<'de> for ObjectDependency {
14659 #[allow(deprecated)]
14660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14661 where
14662 D: serde::Deserializer<'de>,
14663 {
14664 const FIELDS: &[&str] = &[
14665 "object_id",
14666 "objectId",
14667 "referenced_object_id",
14668 "referencedObjectId",
14669 "referenced_object_type",
14670 "referencedObjectType",
14671 ];
14672
14673 #[allow(clippy::enum_variant_names)]
14674 enum GeneratedField {
14675 ObjectId,
14676 ReferencedObjectId,
14677 ReferencedObjectType,
14678 }
14679 impl<'de> serde::Deserialize<'de> for GeneratedField {
14680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14681 where
14682 D: serde::Deserializer<'de>,
14683 {
14684 struct GeneratedVisitor;
14685
14686 impl serde::de::Visitor<'_> for GeneratedVisitor {
14687 type Value = GeneratedField;
14688
14689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14690 write!(formatter, "expected one of: {:?}", &FIELDS)
14691 }
14692
14693 #[allow(unused_variables)]
14694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14695 where
14696 E: serde::de::Error,
14697 {
14698 match value {
14699 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14700 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14701 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14702 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14703 }
14704 }
14705 }
14706 deserializer.deserialize_identifier(GeneratedVisitor)
14707 }
14708 }
14709 struct GeneratedVisitor;
14710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14711 type Value = ObjectDependency;
14712
14713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14714 formatter.write_str("struct meta.ObjectDependency")
14715 }
14716
14717 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14718 where
14719 V: serde::de::MapAccess<'de>,
14720 {
14721 let mut object_id__ = None;
14722 let mut referenced_object_id__ = None;
14723 let mut referenced_object_type__ = None;
14724 while let Some(k) = map_.next_key()? {
14725 match k {
14726 GeneratedField::ObjectId => {
14727 if object_id__.is_some() {
14728 return Err(serde::de::Error::duplicate_field("objectId"));
14729 }
14730 object_id__ =
14731 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14732 ;
14733 }
14734 GeneratedField::ReferencedObjectId => {
14735 if referenced_object_id__.is_some() {
14736 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14737 }
14738 referenced_object_id__ =
14739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14740 ;
14741 }
14742 GeneratedField::ReferencedObjectType => {
14743 if referenced_object_type__.is_some() {
14744 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14745 }
14746 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14747 }
14748 }
14749 }
14750 Ok(ObjectDependency {
14751 object_id: object_id__.unwrap_or_default(),
14752 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14753 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14754 })
14755 }
14756 }
14757 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14758 }
14759}
14760impl serde::Serialize for ObjectGroup {
14761 #[allow(deprecated)]
14762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14763 where
14764 S: serde::Serializer,
14765 {
14766 use serde::ser::SerializeStruct;
14767 let mut len = 0;
14768 if !self.objects.is_empty() {
14769 len += 1;
14770 }
14771 if !self.dependencies.is_empty() {
14772 len += 1;
14773 }
14774 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14775 if !self.objects.is_empty() {
14776 struct_ser.serialize_field("objects", &self.objects)?;
14777 }
14778 if !self.dependencies.is_empty() {
14779 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14780 }
14781 struct_ser.end()
14782 }
14783}
14784impl<'de> serde::Deserialize<'de> for ObjectGroup {
14785 #[allow(deprecated)]
14786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14787 where
14788 D: serde::Deserializer<'de>,
14789 {
14790 const FIELDS: &[&str] = &[
14791 "objects",
14792 "dependencies",
14793 ];
14794
14795 #[allow(clippy::enum_variant_names)]
14796 enum GeneratedField {
14797 Objects,
14798 Dependencies,
14799 }
14800 impl<'de> serde::Deserialize<'de> for GeneratedField {
14801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14802 where
14803 D: serde::Deserializer<'de>,
14804 {
14805 struct GeneratedVisitor;
14806
14807 impl serde::de::Visitor<'_> for GeneratedVisitor {
14808 type Value = GeneratedField;
14809
14810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14811 write!(formatter, "expected one of: {:?}", &FIELDS)
14812 }
14813
14814 #[allow(unused_variables)]
14815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14816 where
14817 E: serde::de::Error,
14818 {
14819 match value {
14820 "objects" => Ok(GeneratedField::Objects),
14821 "dependencies" => Ok(GeneratedField::Dependencies),
14822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14823 }
14824 }
14825 }
14826 deserializer.deserialize_identifier(GeneratedVisitor)
14827 }
14828 }
14829 struct GeneratedVisitor;
14830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14831 type Value = ObjectGroup;
14832
14833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14834 formatter.write_str("struct meta.ObjectGroup")
14835 }
14836
14837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
14838 where
14839 V: serde::de::MapAccess<'de>,
14840 {
14841 let mut objects__ = None;
14842 let mut dependencies__ = None;
14843 while let Some(k) = map_.next_key()? {
14844 match k {
14845 GeneratedField::Objects => {
14846 if objects__.is_some() {
14847 return Err(serde::de::Error::duplicate_field("objects"));
14848 }
14849 objects__ = Some(map_.next_value()?);
14850 }
14851 GeneratedField::Dependencies => {
14852 if dependencies__.is_some() {
14853 return Err(serde::de::Error::duplicate_field("dependencies"));
14854 }
14855 dependencies__ = Some(map_.next_value()?);
14856 }
14857 }
14858 }
14859 Ok(ObjectGroup {
14860 objects: objects__.unwrap_or_default(),
14861 dependencies: dependencies__.unwrap_or_default(),
14862 })
14863 }
14864 }
14865 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
14866 }
14867}
14868impl serde::Serialize for PauseRequest {
14869 #[allow(deprecated)]
14870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14871 where
14872 S: serde::Serializer,
14873 {
14874 use serde::ser::SerializeStruct;
14875 let len = 0;
14876 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
14877 struct_ser.end()
14878 }
14879}
14880impl<'de> serde::Deserialize<'de> for PauseRequest {
14881 #[allow(deprecated)]
14882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14883 where
14884 D: serde::Deserializer<'de>,
14885 {
14886 const FIELDS: &[&str] = &[
14887 ];
14888
14889 #[allow(clippy::enum_variant_names)]
14890 enum GeneratedField {
14891 }
14892 impl<'de> serde::Deserialize<'de> for GeneratedField {
14893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14894 where
14895 D: serde::Deserializer<'de>,
14896 {
14897 struct GeneratedVisitor;
14898
14899 impl serde::de::Visitor<'_> for GeneratedVisitor {
14900 type Value = GeneratedField;
14901
14902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14903 write!(formatter, "expected one of: {:?}", &FIELDS)
14904 }
14905
14906 #[allow(unused_variables)]
14907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14908 where
14909 E: serde::de::Error,
14910 {
14911 Err(serde::de::Error::unknown_field(value, FIELDS))
14912 }
14913 }
14914 deserializer.deserialize_identifier(GeneratedVisitor)
14915 }
14916 }
14917 struct GeneratedVisitor;
14918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14919 type Value = PauseRequest;
14920
14921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14922 formatter.write_str("struct meta.PauseRequest")
14923 }
14924
14925 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
14926 where
14927 V: serde::de::MapAccess<'de>,
14928 {
14929 while map_.next_key::<GeneratedField>()?.is_some() {
14930 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14931 }
14932 Ok(PauseRequest {
14933 })
14934 }
14935 }
14936 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
14937 }
14938}
14939impl serde::Serialize for PauseResponse {
14940 #[allow(deprecated)]
14941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14942 where
14943 S: serde::Serializer,
14944 {
14945 use serde::ser::SerializeStruct;
14946 let len = 0;
14947 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
14948 struct_ser.end()
14949 }
14950}
14951impl<'de> serde::Deserialize<'de> for PauseResponse {
14952 #[allow(deprecated)]
14953 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14954 where
14955 D: serde::Deserializer<'de>,
14956 {
14957 const FIELDS: &[&str] = &[
14958 ];
14959
14960 #[allow(clippy::enum_variant_names)]
14961 enum GeneratedField {
14962 }
14963 impl<'de> serde::Deserialize<'de> for GeneratedField {
14964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14965 where
14966 D: serde::Deserializer<'de>,
14967 {
14968 struct GeneratedVisitor;
14969
14970 impl serde::de::Visitor<'_> for GeneratedVisitor {
14971 type Value = GeneratedField;
14972
14973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14974 write!(formatter, "expected one of: {:?}", &FIELDS)
14975 }
14976
14977 #[allow(unused_variables)]
14978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14979 where
14980 E: serde::de::Error,
14981 {
14982 Err(serde::de::Error::unknown_field(value, FIELDS))
14983 }
14984 }
14985 deserializer.deserialize_identifier(GeneratedVisitor)
14986 }
14987 }
14988 struct GeneratedVisitor;
14989 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14990 type Value = PauseResponse;
14991
14992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14993 formatter.write_str("struct meta.PauseResponse")
14994 }
14995
14996 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
14997 where
14998 V: serde::de::MapAccess<'de>,
14999 {
15000 while map_.next_key::<GeneratedField>()?.is_some() {
15001 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15002 }
15003 Ok(PauseResponse {
15004 })
15005 }
15006 }
15007 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
15008 }
15009}
15010impl serde::Serialize for PropertyUpdateOptions {
15011 #[allow(deprecated)]
15012 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15013 where
15014 S: serde::Serializer,
15015 {
15016 use serde::ser::SerializeStruct;
15017 let mut len = 0;
15018 if self.reset_splits {
15019 len += 1;
15020 }
15021 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
15022 if self.reset_splits {
15023 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
15024 }
15025 struct_ser.end()
15026 }
15027}
15028impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
15029 #[allow(deprecated)]
15030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15031 where
15032 D: serde::Deserializer<'de>,
15033 {
15034 const FIELDS: &[&str] = &[
15035 "reset_splits",
15036 "resetSplits",
15037 ];
15038
15039 #[allow(clippy::enum_variant_names)]
15040 enum GeneratedField {
15041 ResetSplits,
15042 }
15043 impl<'de> serde::Deserialize<'de> for GeneratedField {
15044 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15045 where
15046 D: serde::Deserializer<'de>,
15047 {
15048 struct GeneratedVisitor;
15049
15050 impl serde::de::Visitor<'_> for GeneratedVisitor {
15051 type Value = GeneratedField;
15052
15053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15054 write!(formatter, "expected one of: {:?}", &FIELDS)
15055 }
15056
15057 #[allow(unused_variables)]
15058 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15059 where
15060 E: serde::de::Error,
15061 {
15062 match value {
15063 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
15064 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15065 }
15066 }
15067 }
15068 deserializer.deserialize_identifier(GeneratedVisitor)
15069 }
15070 }
15071 struct GeneratedVisitor;
15072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15073 type Value = PropertyUpdateOptions;
15074
15075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15076 formatter.write_str("struct meta.PropertyUpdateOptions")
15077 }
15078
15079 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
15080 where
15081 V: serde::de::MapAccess<'de>,
15082 {
15083 let mut reset_splits__ = None;
15084 while let Some(k) = map_.next_key()? {
15085 match k {
15086 GeneratedField::ResetSplits => {
15087 if reset_splits__.is_some() {
15088 return Err(serde::de::Error::duplicate_field("resetSplits"));
15089 }
15090 reset_splits__ = Some(map_.next_value()?);
15091 }
15092 }
15093 }
15094 Ok(PropertyUpdateOptions {
15095 reset_splits: reset_splits__.unwrap_or_default(),
15096 })
15097 }
15098 }
15099 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
15100 }
15101}
15102impl serde::Serialize for RecoverRequest {
15103 #[allow(deprecated)]
15104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15105 where
15106 S: serde::Serializer,
15107 {
15108 use serde::ser::SerializeStruct;
15109 let len = 0;
15110 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
15111 struct_ser.end()
15112 }
15113}
15114impl<'de> serde::Deserialize<'de> for RecoverRequest {
15115 #[allow(deprecated)]
15116 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15117 where
15118 D: serde::Deserializer<'de>,
15119 {
15120 const FIELDS: &[&str] = &[
15121 ];
15122
15123 #[allow(clippy::enum_variant_names)]
15124 enum GeneratedField {
15125 }
15126 impl<'de> serde::Deserialize<'de> for GeneratedField {
15127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15128 where
15129 D: serde::Deserializer<'de>,
15130 {
15131 struct GeneratedVisitor;
15132
15133 impl serde::de::Visitor<'_> for GeneratedVisitor {
15134 type Value = GeneratedField;
15135
15136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15137 write!(formatter, "expected one of: {:?}", &FIELDS)
15138 }
15139
15140 #[allow(unused_variables)]
15141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15142 where
15143 E: serde::de::Error,
15144 {
15145 Err(serde::de::Error::unknown_field(value, FIELDS))
15146 }
15147 }
15148 deserializer.deserialize_identifier(GeneratedVisitor)
15149 }
15150 }
15151 struct GeneratedVisitor;
15152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15153 type Value = RecoverRequest;
15154
15155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15156 formatter.write_str("struct meta.RecoverRequest")
15157 }
15158
15159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
15160 where
15161 V: serde::de::MapAccess<'de>,
15162 {
15163 while map_.next_key::<GeneratedField>()?.is_some() {
15164 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15165 }
15166 Ok(RecoverRequest {
15167 })
15168 }
15169 }
15170 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
15171 }
15172}
15173impl serde::Serialize for RecoverResponse {
15174 #[allow(deprecated)]
15175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15176 where
15177 S: serde::Serializer,
15178 {
15179 use serde::ser::SerializeStruct;
15180 let len = 0;
15181 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
15182 struct_ser.end()
15183 }
15184}
15185impl<'de> serde::Deserialize<'de> for RecoverResponse {
15186 #[allow(deprecated)]
15187 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15188 where
15189 D: serde::Deserializer<'de>,
15190 {
15191 const FIELDS: &[&str] = &[
15192 ];
15193
15194 #[allow(clippy::enum_variant_names)]
15195 enum GeneratedField {
15196 }
15197 impl<'de> serde::Deserialize<'de> for GeneratedField {
15198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15199 where
15200 D: serde::Deserializer<'de>,
15201 {
15202 struct GeneratedVisitor;
15203
15204 impl serde::de::Visitor<'_> for GeneratedVisitor {
15205 type Value = GeneratedField;
15206
15207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15208 write!(formatter, "expected one of: {:?}", &FIELDS)
15209 }
15210
15211 #[allow(unused_variables)]
15212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15213 where
15214 E: serde::de::Error,
15215 {
15216 Err(serde::de::Error::unknown_field(value, FIELDS))
15217 }
15218 }
15219 deserializer.deserialize_identifier(GeneratedVisitor)
15220 }
15221 }
15222 struct GeneratedVisitor;
15223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15224 type Value = RecoverResponse;
15225
15226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15227 formatter.write_str("struct meta.RecoverResponse")
15228 }
15229
15230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
15231 where
15232 V: serde::de::MapAccess<'de>,
15233 {
15234 while map_.next_key::<GeneratedField>()?.is_some() {
15235 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15236 }
15237 Ok(RecoverResponse {
15238 })
15239 }
15240 }
15241 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
15242 }
15243}
15244impl serde::Serialize for Recovery {
15245 #[allow(deprecated)]
15246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15247 where
15248 S: serde::Serializer,
15249 {
15250 use serde::ser::SerializeStruct;
15251 let len = 0;
15252 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
15253 struct_ser.end()
15254 }
15255}
15256impl<'de> serde::Deserialize<'de> for Recovery {
15257 #[allow(deprecated)]
15258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15259 where
15260 D: serde::Deserializer<'de>,
15261 {
15262 const FIELDS: &[&str] = &[
15263 ];
15264
15265 #[allow(clippy::enum_variant_names)]
15266 enum GeneratedField {
15267 }
15268 impl<'de> serde::Deserialize<'de> for GeneratedField {
15269 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15270 where
15271 D: serde::Deserializer<'de>,
15272 {
15273 struct GeneratedVisitor;
15274
15275 impl serde::de::Visitor<'_> for GeneratedVisitor {
15276 type Value = GeneratedField;
15277
15278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15279 write!(formatter, "expected one of: {:?}", &FIELDS)
15280 }
15281
15282 #[allow(unused_variables)]
15283 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15284 where
15285 E: serde::de::Error,
15286 {
15287 Err(serde::de::Error::unknown_field(value, FIELDS))
15288 }
15289 }
15290 deserializer.deserialize_identifier(GeneratedVisitor)
15291 }
15292 }
15293 struct GeneratedVisitor;
15294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15295 type Value = Recovery;
15296
15297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15298 formatter.write_str("struct meta.Recovery")
15299 }
15300
15301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
15302 where
15303 V: serde::de::MapAccess<'de>,
15304 {
15305 while map_.next_key::<GeneratedField>()?.is_some() {
15306 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15307 }
15308 Ok(Recovery {
15309 })
15310 }
15311 }
15312 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
15313 }
15314}
15315impl serde::Serialize for RecoveryStatus {
15316 #[allow(deprecated)]
15317 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15318 where
15319 S: serde::Serializer,
15320 {
15321 let variant = match self {
15322 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
15323 Self::StatusStarting => "STATUS_STARTING",
15324 Self::StatusRecovering => "STATUS_RECOVERING",
15325 Self::StatusRunning => "STATUS_RUNNING",
15326 };
15327 serializer.serialize_str(variant)
15328 }
15329}
15330impl<'de> serde::Deserialize<'de> for RecoveryStatus {
15331 #[allow(deprecated)]
15332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15333 where
15334 D: serde::Deserializer<'de>,
15335 {
15336 const FIELDS: &[&str] = &[
15337 "STATUS_UNSPECIFIED",
15338 "STATUS_STARTING",
15339 "STATUS_RECOVERING",
15340 "STATUS_RUNNING",
15341 ];
15342
15343 struct GeneratedVisitor;
15344
15345 impl serde::de::Visitor<'_> for GeneratedVisitor {
15346 type Value = RecoveryStatus;
15347
15348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15349 write!(formatter, "expected one of: {:?}", &FIELDS)
15350 }
15351
15352 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15353 where
15354 E: serde::de::Error,
15355 {
15356 i32::try_from(v)
15357 .ok()
15358 .and_then(|x| x.try_into().ok())
15359 .ok_or_else(|| {
15360 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15361 })
15362 }
15363
15364 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15365 where
15366 E: serde::de::Error,
15367 {
15368 i32::try_from(v)
15369 .ok()
15370 .and_then(|x| x.try_into().ok())
15371 .ok_or_else(|| {
15372 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15373 })
15374 }
15375
15376 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15377 where
15378 E: serde::de::Error,
15379 {
15380 match value {
15381 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
15382 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
15383 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
15384 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
15385 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15386 }
15387 }
15388 }
15389 deserializer.deserialize_any(GeneratedVisitor)
15390 }
15391}
15392impl serde::Serialize for RefreshRequest {
15393 #[allow(deprecated)]
15394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15395 where
15396 S: serde::Serializer,
15397 {
15398 use serde::ser::SerializeStruct;
15399 let mut len = 0;
15400 if self.table_id != 0 {
15401 len += 1;
15402 }
15403 if self.associated_source_id != 0 {
15404 len += 1;
15405 }
15406 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
15407 if self.table_id != 0 {
15408 struct_ser.serialize_field("tableId", &self.table_id)?;
15409 }
15410 if self.associated_source_id != 0 {
15411 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
15412 }
15413 struct_ser.end()
15414 }
15415}
15416impl<'de> serde::Deserialize<'de> for RefreshRequest {
15417 #[allow(deprecated)]
15418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15419 where
15420 D: serde::Deserializer<'de>,
15421 {
15422 const FIELDS: &[&str] = &[
15423 "table_id",
15424 "tableId",
15425 "associated_source_id",
15426 "associatedSourceId",
15427 ];
15428
15429 #[allow(clippy::enum_variant_names)]
15430 enum GeneratedField {
15431 TableId,
15432 AssociatedSourceId,
15433 }
15434 impl<'de> serde::Deserialize<'de> for GeneratedField {
15435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15436 where
15437 D: serde::Deserializer<'de>,
15438 {
15439 struct GeneratedVisitor;
15440
15441 impl serde::de::Visitor<'_> for GeneratedVisitor {
15442 type Value = GeneratedField;
15443
15444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15445 write!(formatter, "expected one of: {:?}", &FIELDS)
15446 }
15447
15448 #[allow(unused_variables)]
15449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15450 where
15451 E: serde::de::Error,
15452 {
15453 match value {
15454 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15455 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15457 }
15458 }
15459 }
15460 deserializer.deserialize_identifier(GeneratedVisitor)
15461 }
15462 }
15463 struct GeneratedVisitor;
15464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15465 type Value = RefreshRequest;
15466
15467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15468 formatter.write_str("struct meta.RefreshRequest")
15469 }
15470
15471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15472 where
15473 V: serde::de::MapAccess<'de>,
15474 {
15475 let mut table_id__ = None;
15476 let mut associated_source_id__ = None;
15477 while let Some(k) = map_.next_key()? {
15478 match k {
15479 GeneratedField::TableId => {
15480 if table_id__.is_some() {
15481 return Err(serde::de::Error::duplicate_field("tableId"));
15482 }
15483 table_id__ =
15484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15485 ;
15486 }
15487 GeneratedField::AssociatedSourceId => {
15488 if associated_source_id__.is_some() {
15489 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15490 }
15491 associated_source_id__ =
15492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15493 ;
15494 }
15495 }
15496 }
15497 Ok(RefreshRequest {
15498 table_id: table_id__.unwrap_or_default(),
15499 associated_source_id: associated_source_id__.unwrap_or_default(),
15500 })
15501 }
15502 }
15503 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15504 }
15505}
15506impl serde::Serialize for RefreshResponse {
15507 #[allow(deprecated)]
15508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15509 where
15510 S: serde::Serializer,
15511 {
15512 use serde::ser::SerializeStruct;
15513 let mut len = 0;
15514 if self.status.is_some() {
15515 len += 1;
15516 }
15517 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15518 if let Some(v) = self.status.as_ref() {
15519 struct_ser.serialize_field("status", v)?;
15520 }
15521 struct_ser.end()
15522 }
15523}
15524impl<'de> serde::Deserialize<'de> for RefreshResponse {
15525 #[allow(deprecated)]
15526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15527 where
15528 D: serde::Deserializer<'de>,
15529 {
15530 const FIELDS: &[&str] = &[
15531 "status",
15532 ];
15533
15534 #[allow(clippy::enum_variant_names)]
15535 enum GeneratedField {
15536 Status,
15537 }
15538 impl<'de> serde::Deserialize<'de> for GeneratedField {
15539 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15540 where
15541 D: serde::Deserializer<'de>,
15542 {
15543 struct GeneratedVisitor;
15544
15545 impl serde::de::Visitor<'_> for GeneratedVisitor {
15546 type Value = GeneratedField;
15547
15548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15549 write!(formatter, "expected one of: {:?}", &FIELDS)
15550 }
15551
15552 #[allow(unused_variables)]
15553 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15554 where
15555 E: serde::de::Error,
15556 {
15557 match value {
15558 "status" => Ok(GeneratedField::Status),
15559 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15560 }
15561 }
15562 }
15563 deserializer.deserialize_identifier(GeneratedVisitor)
15564 }
15565 }
15566 struct GeneratedVisitor;
15567 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15568 type Value = RefreshResponse;
15569
15570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15571 formatter.write_str("struct meta.RefreshResponse")
15572 }
15573
15574 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15575 where
15576 V: serde::de::MapAccess<'de>,
15577 {
15578 let mut status__ = None;
15579 while let Some(k) = map_.next_key()? {
15580 match k {
15581 GeneratedField::Status => {
15582 if status__.is_some() {
15583 return Err(serde::de::Error::duplicate_field("status"));
15584 }
15585 status__ = map_.next_value()?;
15586 }
15587 }
15588 }
15589 Ok(RefreshResponse {
15590 status: status__,
15591 })
15592 }
15593 }
15594 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15595 }
15596}
15597impl serde::Serialize for RelationIdInfos {
15598 #[allow(deprecated)]
15599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15600 where
15601 S: serde::Serializer,
15602 {
15603 use serde::ser::SerializeStruct;
15604 let mut len = 0;
15605 if !self.map.is_empty() {
15606 len += 1;
15607 }
15608 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15609 if !self.map.is_empty() {
15610 struct_ser.serialize_field("map", &self.map)?;
15611 }
15612 struct_ser.end()
15613 }
15614}
15615impl<'de> serde::Deserialize<'de> for RelationIdInfos {
15616 #[allow(deprecated)]
15617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15618 where
15619 D: serde::Deserializer<'de>,
15620 {
15621 const FIELDS: &[&str] = &[
15622 "map",
15623 ];
15624
15625 #[allow(clippy::enum_variant_names)]
15626 enum GeneratedField {
15627 Map,
15628 }
15629 impl<'de> serde::Deserialize<'de> for GeneratedField {
15630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15631 where
15632 D: serde::Deserializer<'de>,
15633 {
15634 struct GeneratedVisitor;
15635
15636 impl serde::de::Visitor<'_> for GeneratedVisitor {
15637 type Value = GeneratedField;
15638
15639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15640 write!(formatter, "expected one of: {:?}", &FIELDS)
15641 }
15642
15643 #[allow(unused_variables)]
15644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15645 where
15646 E: serde::de::Error,
15647 {
15648 match value {
15649 "map" => Ok(GeneratedField::Map),
15650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15651 }
15652 }
15653 }
15654 deserializer.deserialize_identifier(GeneratedVisitor)
15655 }
15656 }
15657 struct GeneratedVisitor;
15658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15659 type Value = RelationIdInfos;
15660
15661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15662 formatter.write_str("struct meta.RelationIdInfos")
15663 }
15664
15665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15666 where
15667 V: serde::de::MapAccess<'de>,
15668 {
15669 let mut map__ = None;
15670 while let Some(k) = map_.next_key()? {
15671 match k {
15672 GeneratedField::Map => {
15673 if map__.is_some() {
15674 return Err(serde::de::Error::duplicate_field("map"));
15675 }
15676 map__ = Some(
15677 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15678 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15679 );
15680 }
15681 }
15682 }
15683 Ok(RelationIdInfos {
15684 map: map__.unwrap_or_default(),
15685 })
15686 }
15687 }
15688 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15689 }
15690}
15691impl serde::Serialize for RescheduleRequest {
15692 #[allow(deprecated)]
15693 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15694 where
15695 S: serde::Serializer,
15696 {
15697 use serde::ser::SerializeStruct;
15698 let mut len = 0;
15699 if self.revision != 0 {
15700 len += 1;
15701 }
15702 if self.resolve_no_shuffle_upstream {
15703 len += 1;
15704 }
15705 if !self.worker_reschedules.is_empty() {
15706 len += 1;
15707 }
15708 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15709 if self.revision != 0 {
15710 #[allow(clippy::needless_borrow)]
15711 #[allow(clippy::needless_borrows_for_generic_args)]
15712 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15713 }
15714 if self.resolve_no_shuffle_upstream {
15715 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15716 }
15717 if !self.worker_reschedules.is_empty() {
15718 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15719 }
15720 struct_ser.end()
15721 }
15722}
15723impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15724 #[allow(deprecated)]
15725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15726 where
15727 D: serde::Deserializer<'de>,
15728 {
15729 const FIELDS: &[&str] = &[
15730 "revision",
15731 "resolve_no_shuffle_upstream",
15732 "resolveNoShuffleUpstream",
15733 "worker_reschedules",
15734 "workerReschedules",
15735 ];
15736
15737 #[allow(clippy::enum_variant_names)]
15738 enum GeneratedField {
15739 Revision,
15740 ResolveNoShuffleUpstream,
15741 WorkerReschedules,
15742 }
15743 impl<'de> serde::Deserialize<'de> for GeneratedField {
15744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15745 where
15746 D: serde::Deserializer<'de>,
15747 {
15748 struct GeneratedVisitor;
15749
15750 impl serde::de::Visitor<'_> for GeneratedVisitor {
15751 type Value = GeneratedField;
15752
15753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15754 write!(formatter, "expected one of: {:?}", &FIELDS)
15755 }
15756
15757 #[allow(unused_variables)]
15758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15759 where
15760 E: serde::de::Error,
15761 {
15762 match value {
15763 "revision" => Ok(GeneratedField::Revision),
15764 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15765 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15767 }
15768 }
15769 }
15770 deserializer.deserialize_identifier(GeneratedVisitor)
15771 }
15772 }
15773 struct GeneratedVisitor;
15774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15775 type Value = RescheduleRequest;
15776
15777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15778 formatter.write_str("struct meta.RescheduleRequest")
15779 }
15780
15781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15782 where
15783 V: serde::de::MapAccess<'de>,
15784 {
15785 let mut revision__ = None;
15786 let mut resolve_no_shuffle_upstream__ = None;
15787 let mut worker_reschedules__ = None;
15788 while let Some(k) = map_.next_key()? {
15789 match k {
15790 GeneratedField::Revision => {
15791 if revision__.is_some() {
15792 return Err(serde::de::Error::duplicate_field("revision"));
15793 }
15794 revision__ =
15795 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15796 ;
15797 }
15798 GeneratedField::ResolveNoShuffleUpstream => {
15799 if resolve_no_shuffle_upstream__.is_some() {
15800 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
15801 }
15802 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
15803 }
15804 GeneratedField::WorkerReschedules => {
15805 if worker_reschedules__.is_some() {
15806 return Err(serde::de::Error::duplicate_field("workerReschedules"));
15807 }
15808 worker_reschedules__ = Some(
15809 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15810 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15811 );
15812 }
15813 }
15814 }
15815 Ok(RescheduleRequest {
15816 revision: revision__.unwrap_or_default(),
15817 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
15818 worker_reschedules: worker_reschedules__.unwrap_or_default(),
15819 })
15820 }
15821 }
15822 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
15823 }
15824}
15825impl serde::Serialize for RescheduleResponse {
15826 #[allow(deprecated)]
15827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15828 where
15829 S: serde::Serializer,
15830 {
15831 use serde::ser::SerializeStruct;
15832 let mut len = 0;
15833 if self.success {
15834 len += 1;
15835 }
15836 if self.revision != 0 {
15837 len += 1;
15838 }
15839 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
15840 if self.success {
15841 struct_ser.serialize_field("success", &self.success)?;
15842 }
15843 if self.revision != 0 {
15844 #[allow(clippy::needless_borrow)]
15845 #[allow(clippy::needless_borrows_for_generic_args)]
15846 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15847 }
15848 struct_ser.end()
15849 }
15850}
15851impl<'de> serde::Deserialize<'de> for RescheduleResponse {
15852 #[allow(deprecated)]
15853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15854 where
15855 D: serde::Deserializer<'de>,
15856 {
15857 const FIELDS: &[&str] = &[
15858 "success",
15859 "revision",
15860 ];
15861
15862 #[allow(clippy::enum_variant_names)]
15863 enum GeneratedField {
15864 Success,
15865 Revision,
15866 }
15867 impl<'de> serde::Deserialize<'de> for GeneratedField {
15868 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15869 where
15870 D: serde::Deserializer<'de>,
15871 {
15872 struct GeneratedVisitor;
15873
15874 impl serde::de::Visitor<'_> for GeneratedVisitor {
15875 type Value = GeneratedField;
15876
15877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15878 write!(formatter, "expected one of: {:?}", &FIELDS)
15879 }
15880
15881 #[allow(unused_variables)]
15882 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15883 where
15884 E: serde::de::Error,
15885 {
15886 match value {
15887 "success" => Ok(GeneratedField::Success),
15888 "revision" => Ok(GeneratedField::Revision),
15889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15890 }
15891 }
15892 }
15893 deserializer.deserialize_identifier(GeneratedVisitor)
15894 }
15895 }
15896 struct GeneratedVisitor;
15897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15898 type Value = RescheduleResponse;
15899
15900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15901 formatter.write_str("struct meta.RescheduleResponse")
15902 }
15903
15904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
15905 where
15906 V: serde::de::MapAccess<'de>,
15907 {
15908 let mut success__ = None;
15909 let mut revision__ = None;
15910 while let Some(k) = map_.next_key()? {
15911 match k {
15912 GeneratedField::Success => {
15913 if success__.is_some() {
15914 return Err(serde::de::Error::duplicate_field("success"));
15915 }
15916 success__ = Some(map_.next_value()?);
15917 }
15918 GeneratedField::Revision => {
15919 if revision__.is_some() {
15920 return Err(serde::de::Error::duplicate_field("revision"));
15921 }
15922 revision__ =
15923 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15924 ;
15925 }
15926 }
15927 }
15928 Ok(RescheduleResponse {
15929 success: success__.unwrap_or_default(),
15930 revision: revision__.unwrap_or_default(),
15931 })
15932 }
15933 }
15934 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
15935 }
15936}
15937impl serde::Serialize for ResetSourceSplitsRequest {
15938 #[allow(deprecated)]
15939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15940 where
15941 S: serde::Serializer,
15942 {
15943 use serde::ser::SerializeStruct;
15944 let mut len = 0;
15945 if self.source_id != 0 {
15946 len += 1;
15947 }
15948 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
15949 if self.source_id != 0 {
15950 struct_ser.serialize_field("sourceId", &self.source_id)?;
15951 }
15952 struct_ser.end()
15953 }
15954}
15955impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
15956 #[allow(deprecated)]
15957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15958 where
15959 D: serde::Deserializer<'de>,
15960 {
15961 const FIELDS: &[&str] = &[
15962 "source_id",
15963 "sourceId",
15964 ];
15965
15966 #[allow(clippy::enum_variant_names)]
15967 enum GeneratedField {
15968 SourceId,
15969 }
15970 impl<'de> serde::Deserialize<'de> for GeneratedField {
15971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15972 where
15973 D: serde::Deserializer<'de>,
15974 {
15975 struct GeneratedVisitor;
15976
15977 impl serde::de::Visitor<'_> for GeneratedVisitor {
15978 type Value = GeneratedField;
15979
15980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15981 write!(formatter, "expected one of: {:?}", &FIELDS)
15982 }
15983
15984 #[allow(unused_variables)]
15985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15986 where
15987 E: serde::de::Error,
15988 {
15989 match value {
15990 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15992 }
15993 }
15994 }
15995 deserializer.deserialize_identifier(GeneratedVisitor)
15996 }
15997 }
15998 struct GeneratedVisitor;
15999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16000 type Value = ResetSourceSplitsRequest;
16001
16002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16003 formatter.write_str("struct meta.ResetSourceSplitsRequest")
16004 }
16005
16006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
16007 where
16008 V: serde::de::MapAccess<'de>,
16009 {
16010 let mut source_id__ = None;
16011 while let Some(k) = map_.next_key()? {
16012 match k {
16013 GeneratedField::SourceId => {
16014 if source_id__.is_some() {
16015 return Err(serde::de::Error::duplicate_field("sourceId"));
16016 }
16017 source_id__ =
16018 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16019 ;
16020 }
16021 }
16022 }
16023 Ok(ResetSourceSplitsRequest {
16024 source_id: source_id__.unwrap_or_default(),
16025 })
16026 }
16027 }
16028 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
16029 }
16030}
16031impl serde::Serialize for ResetSourceSplitsResponse {
16032 #[allow(deprecated)]
16033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16034 where
16035 S: serde::Serializer,
16036 {
16037 use serde::ser::SerializeStruct;
16038 let len = 0;
16039 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
16040 struct_ser.end()
16041 }
16042}
16043impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
16044 #[allow(deprecated)]
16045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16046 where
16047 D: serde::Deserializer<'de>,
16048 {
16049 const FIELDS: &[&str] = &[
16050 ];
16051
16052 #[allow(clippy::enum_variant_names)]
16053 enum GeneratedField {
16054 }
16055 impl<'de> serde::Deserialize<'de> for GeneratedField {
16056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16057 where
16058 D: serde::Deserializer<'de>,
16059 {
16060 struct GeneratedVisitor;
16061
16062 impl serde::de::Visitor<'_> for GeneratedVisitor {
16063 type Value = GeneratedField;
16064
16065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16066 write!(formatter, "expected one of: {:?}", &FIELDS)
16067 }
16068
16069 #[allow(unused_variables)]
16070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16071 where
16072 E: serde::de::Error,
16073 {
16074 Err(serde::de::Error::unknown_field(value, FIELDS))
16075 }
16076 }
16077 deserializer.deserialize_identifier(GeneratedVisitor)
16078 }
16079 }
16080 struct GeneratedVisitor;
16081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16082 type Value = ResetSourceSplitsResponse;
16083
16084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16085 formatter.write_str("struct meta.ResetSourceSplitsResponse")
16086 }
16087
16088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
16089 where
16090 V: serde::de::MapAccess<'de>,
16091 {
16092 while map_.next_key::<GeneratedField>()?.is_some() {
16093 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16094 }
16095 Ok(ResetSourceSplitsResponse {
16096 })
16097 }
16098 }
16099 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
16100 }
16101}
16102impl serde::Serialize for ResumeRequest {
16103 #[allow(deprecated)]
16104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16105 where
16106 S: serde::Serializer,
16107 {
16108 use serde::ser::SerializeStruct;
16109 let len = 0;
16110 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
16111 struct_ser.end()
16112 }
16113}
16114impl<'de> serde::Deserialize<'de> for ResumeRequest {
16115 #[allow(deprecated)]
16116 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16117 where
16118 D: serde::Deserializer<'de>,
16119 {
16120 const FIELDS: &[&str] = &[
16121 ];
16122
16123 #[allow(clippy::enum_variant_names)]
16124 enum GeneratedField {
16125 }
16126 impl<'de> serde::Deserialize<'de> for GeneratedField {
16127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16128 where
16129 D: serde::Deserializer<'de>,
16130 {
16131 struct GeneratedVisitor;
16132
16133 impl serde::de::Visitor<'_> for GeneratedVisitor {
16134 type Value = GeneratedField;
16135
16136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16137 write!(formatter, "expected one of: {:?}", &FIELDS)
16138 }
16139
16140 #[allow(unused_variables)]
16141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16142 where
16143 E: serde::de::Error,
16144 {
16145 Err(serde::de::Error::unknown_field(value, FIELDS))
16146 }
16147 }
16148 deserializer.deserialize_identifier(GeneratedVisitor)
16149 }
16150 }
16151 struct GeneratedVisitor;
16152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16153 type Value = ResumeRequest;
16154
16155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16156 formatter.write_str("struct meta.ResumeRequest")
16157 }
16158
16159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
16160 where
16161 V: serde::de::MapAccess<'de>,
16162 {
16163 while map_.next_key::<GeneratedField>()?.is_some() {
16164 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16165 }
16166 Ok(ResumeRequest {
16167 })
16168 }
16169 }
16170 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
16171 }
16172}
16173impl serde::Serialize for ResumeResponse {
16174 #[allow(deprecated)]
16175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16176 where
16177 S: serde::Serializer,
16178 {
16179 use serde::ser::SerializeStruct;
16180 let len = 0;
16181 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
16182 struct_ser.end()
16183 }
16184}
16185impl<'de> serde::Deserialize<'de> for ResumeResponse {
16186 #[allow(deprecated)]
16187 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16188 where
16189 D: serde::Deserializer<'de>,
16190 {
16191 const FIELDS: &[&str] = &[
16192 ];
16193
16194 #[allow(clippy::enum_variant_names)]
16195 enum GeneratedField {
16196 }
16197 impl<'de> serde::Deserialize<'de> for GeneratedField {
16198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16199 where
16200 D: serde::Deserializer<'de>,
16201 {
16202 struct GeneratedVisitor;
16203
16204 impl serde::de::Visitor<'_> for GeneratedVisitor {
16205 type Value = GeneratedField;
16206
16207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16208 write!(formatter, "expected one of: {:?}", &FIELDS)
16209 }
16210
16211 #[allow(unused_variables)]
16212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16213 where
16214 E: serde::de::Error,
16215 {
16216 Err(serde::de::Error::unknown_field(value, FIELDS))
16217 }
16218 }
16219 deserializer.deserialize_identifier(GeneratedVisitor)
16220 }
16221 }
16222 struct GeneratedVisitor;
16223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16224 type Value = ResumeResponse;
16225
16226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16227 formatter.write_str("struct meta.ResumeResponse")
16228 }
16229
16230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
16231 where
16232 V: serde::de::MapAccess<'de>,
16233 {
16234 while map_.next_key::<GeneratedField>()?.is_some() {
16235 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16236 }
16237 Ok(ResumeResponse {
16238 })
16239 }
16240 }
16241 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
16242 }
16243}
16244impl serde::Serialize for SetSessionParamRequest {
16245 #[allow(deprecated)]
16246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16247 where
16248 S: serde::Serializer,
16249 {
16250 use serde::ser::SerializeStruct;
16251 let mut len = 0;
16252 if !self.param.is_empty() {
16253 len += 1;
16254 }
16255 if self.value.is_some() {
16256 len += 1;
16257 }
16258 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
16259 if !self.param.is_empty() {
16260 struct_ser.serialize_field("param", &self.param)?;
16261 }
16262 if let Some(v) = self.value.as_ref() {
16263 struct_ser.serialize_field("value", v)?;
16264 }
16265 struct_ser.end()
16266 }
16267}
16268impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
16269 #[allow(deprecated)]
16270 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16271 where
16272 D: serde::Deserializer<'de>,
16273 {
16274 const FIELDS: &[&str] = &[
16275 "param",
16276 "value",
16277 ];
16278
16279 #[allow(clippy::enum_variant_names)]
16280 enum GeneratedField {
16281 Param,
16282 Value,
16283 }
16284 impl<'de> serde::Deserialize<'de> for GeneratedField {
16285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16286 where
16287 D: serde::Deserializer<'de>,
16288 {
16289 struct GeneratedVisitor;
16290
16291 impl serde::de::Visitor<'_> for GeneratedVisitor {
16292 type Value = GeneratedField;
16293
16294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16295 write!(formatter, "expected one of: {:?}", &FIELDS)
16296 }
16297
16298 #[allow(unused_variables)]
16299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16300 where
16301 E: serde::de::Error,
16302 {
16303 match value {
16304 "param" => Ok(GeneratedField::Param),
16305 "value" => Ok(GeneratedField::Value),
16306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16307 }
16308 }
16309 }
16310 deserializer.deserialize_identifier(GeneratedVisitor)
16311 }
16312 }
16313 struct GeneratedVisitor;
16314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16315 type Value = SetSessionParamRequest;
16316
16317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16318 formatter.write_str("struct meta.SetSessionParamRequest")
16319 }
16320
16321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
16322 where
16323 V: serde::de::MapAccess<'de>,
16324 {
16325 let mut param__ = None;
16326 let mut value__ = None;
16327 while let Some(k) = map_.next_key()? {
16328 match k {
16329 GeneratedField::Param => {
16330 if param__.is_some() {
16331 return Err(serde::de::Error::duplicate_field("param"));
16332 }
16333 param__ = Some(map_.next_value()?);
16334 }
16335 GeneratedField::Value => {
16336 if value__.is_some() {
16337 return Err(serde::de::Error::duplicate_field("value"));
16338 }
16339 value__ = map_.next_value()?;
16340 }
16341 }
16342 }
16343 Ok(SetSessionParamRequest {
16344 param: param__.unwrap_or_default(),
16345 value: value__,
16346 })
16347 }
16348 }
16349 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
16350 }
16351}
16352impl serde::Serialize for SetSessionParamResponse {
16353 #[allow(deprecated)]
16354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16355 where
16356 S: serde::Serializer,
16357 {
16358 use serde::ser::SerializeStruct;
16359 let mut len = 0;
16360 if !self.param.is_empty() {
16361 len += 1;
16362 }
16363 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
16364 if !self.param.is_empty() {
16365 struct_ser.serialize_field("param", &self.param)?;
16366 }
16367 struct_ser.end()
16368 }
16369}
16370impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
16371 #[allow(deprecated)]
16372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16373 where
16374 D: serde::Deserializer<'de>,
16375 {
16376 const FIELDS: &[&str] = &[
16377 "param",
16378 ];
16379
16380 #[allow(clippy::enum_variant_names)]
16381 enum GeneratedField {
16382 Param,
16383 }
16384 impl<'de> serde::Deserialize<'de> for GeneratedField {
16385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16386 where
16387 D: serde::Deserializer<'de>,
16388 {
16389 struct GeneratedVisitor;
16390
16391 impl serde::de::Visitor<'_> for GeneratedVisitor {
16392 type Value = GeneratedField;
16393
16394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16395 write!(formatter, "expected one of: {:?}", &FIELDS)
16396 }
16397
16398 #[allow(unused_variables)]
16399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16400 where
16401 E: serde::de::Error,
16402 {
16403 match value {
16404 "param" => Ok(GeneratedField::Param),
16405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16406 }
16407 }
16408 }
16409 deserializer.deserialize_identifier(GeneratedVisitor)
16410 }
16411 }
16412 struct GeneratedVisitor;
16413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16414 type Value = SetSessionParamResponse;
16415
16416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16417 formatter.write_str("struct meta.SetSessionParamResponse")
16418 }
16419
16420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16421 where
16422 V: serde::de::MapAccess<'de>,
16423 {
16424 let mut param__ = None;
16425 while let Some(k) = map_.next_key()? {
16426 match k {
16427 GeneratedField::Param => {
16428 if param__.is_some() {
16429 return Err(serde::de::Error::duplicate_field("param"));
16430 }
16431 param__ = Some(map_.next_value()?);
16432 }
16433 }
16434 }
16435 Ok(SetSessionParamResponse {
16436 param: param__.unwrap_or_default(),
16437 })
16438 }
16439 }
16440 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16441 }
16442}
16443impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16444 #[allow(deprecated)]
16445 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16446 where
16447 S: serde::Serializer,
16448 {
16449 use serde::ser::SerializeStruct;
16450 let mut len = 0;
16451 if self.job_id != 0 {
16452 len += 1;
16453 }
16454 if self.aligned {
16455 len += 1;
16456 }
16457 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16458 if self.job_id != 0 {
16459 struct_ser.serialize_field("jobId", &self.job_id)?;
16460 }
16461 if self.aligned {
16462 struct_ser.serialize_field("aligned", &self.aligned)?;
16463 }
16464 struct_ser.end()
16465 }
16466}
16467impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16468 #[allow(deprecated)]
16469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16470 where
16471 D: serde::Deserializer<'de>,
16472 {
16473 const FIELDS: &[&str] = &[
16474 "job_id",
16475 "jobId",
16476 "aligned",
16477 ];
16478
16479 #[allow(clippy::enum_variant_names)]
16480 enum GeneratedField {
16481 JobId,
16482 Aligned,
16483 }
16484 impl<'de> serde::Deserialize<'de> for GeneratedField {
16485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16486 where
16487 D: serde::Deserializer<'de>,
16488 {
16489 struct GeneratedVisitor;
16490
16491 impl serde::de::Visitor<'_> for GeneratedVisitor {
16492 type Value = GeneratedField;
16493
16494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16495 write!(formatter, "expected one of: {:?}", &FIELDS)
16496 }
16497
16498 #[allow(unused_variables)]
16499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16500 where
16501 E: serde::de::Error,
16502 {
16503 match value {
16504 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16505 "aligned" => Ok(GeneratedField::Aligned),
16506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16507 }
16508 }
16509 }
16510 deserializer.deserialize_identifier(GeneratedVisitor)
16511 }
16512 }
16513 struct GeneratedVisitor;
16514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16515 type Value = SetSyncLogStoreAlignedRequest;
16516
16517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16518 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16519 }
16520
16521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16522 where
16523 V: serde::de::MapAccess<'de>,
16524 {
16525 let mut job_id__ = None;
16526 let mut aligned__ = None;
16527 while let Some(k) = map_.next_key()? {
16528 match k {
16529 GeneratedField::JobId => {
16530 if job_id__.is_some() {
16531 return Err(serde::de::Error::duplicate_field("jobId"));
16532 }
16533 job_id__ =
16534 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16535 ;
16536 }
16537 GeneratedField::Aligned => {
16538 if aligned__.is_some() {
16539 return Err(serde::de::Error::duplicate_field("aligned"));
16540 }
16541 aligned__ = Some(map_.next_value()?);
16542 }
16543 }
16544 }
16545 Ok(SetSyncLogStoreAlignedRequest {
16546 job_id: job_id__.unwrap_or_default(),
16547 aligned: aligned__.unwrap_or_default(),
16548 })
16549 }
16550 }
16551 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16552 }
16553}
16554impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16555 #[allow(deprecated)]
16556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16557 where
16558 S: serde::Serializer,
16559 {
16560 use serde::ser::SerializeStruct;
16561 let len = 0;
16562 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16563 struct_ser.end()
16564 }
16565}
16566impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16567 #[allow(deprecated)]
16568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16569 where
16570 D: serde::Deserializer<'de>,
16571 {
16572 const FIELDS: &[&str] = &[
16573 ];
16574
16575 #[allow(clippy::enum_variant_names)]
16576 enum GeneratedField {
16577 }
16578 impl<'de> serde::Deserialize<'de> for GeneratedField {
16579 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16580 where
16581 D: serde::Deserializer<'de>,
16582 {
16583 struct GeneratedVisitor;
16584
16585 impl serde::de::Visitor<'_> for GeneratedVisitor {
16586 type Value = GeneratedField;
16587
16588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16589 write!(formatter, "expected one of: {:?}", &FIELDS)
16590 }
16591
16592 #[allow(unused_variables)]
16593 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16594 where
16595 E: serde::de::Error,
16596 {
16597 Err(serde::de::Error::unknown_field(value, FIELDS))
16598 }
16599 }
16600 deserializer.deserialize_identifier(GeneratedVisitor)
16601 }
16602 }
16603 struct GeneratedVisitor;
16604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16605 type Value = SetSyncLogStoreAlignedResponse;
16606
16607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16608 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
16609 }
16610
16611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
16612 where
16613 V: serde::de::MapAccess<'de>,
16614 {
16615 while map_.next_key::<GeneratedField>()?.is_some() {
16616 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16617 }
16618 Ok(SetSyncLogStoreAlignedResponse {
16619 })
16620 }
16621 }
16622 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
16623 }
16624}
16625impl serde::Serialize for SetSystemParamRequest {
16626 #[allow(deprecated)]
16627 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16628 where
16629 S: serde::Serializer,
16630 {
16631 use serde::ser::SerializeStruct;
16632 let mut len = 0;
16633 if !self.param.is_empty() {
16634 len += 1;
16635 }
16636 if self.value.is_some() {
16637 len += 1;
16638 }
16639 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
16640 if !self.param.is_empty() {
16641 struct_ser.serialize_field("param", &self.param)?;
16642 }
16643 if let Some(v) = self.value.as_ref() {
16644 struct_ser.serialize_field("value", v)?;
16645 }
16646 struct_ser.end()
16647 }
16648}
16649impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
16650 #[allow(deprecated)]
16651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16652 where
16653 D: serde::Deserializer<'de>,
16654 {
16655 const FIELDS: &[&str] = &[
16656 "param",
16657 "value",
16658 ];
16659
16660 #[allow(clippy::enum_variant_names)]
16661 enum GeneratedField {
16662 Param,
16663 Value,
16664 }
16665 impl<'de> serde::Deserialize<'de> for GeneratedField {
16666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16667 where
16668 D: serde::Deserializer<'de>,
16669 {
16670 struct GeneratedVisitor;
16671
16672 impl serde::de::Visitor<'_> for GeneratedVisitor {
16673 type Value = GeneratedField;
16674
16675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16676 write!(formatter, "expected one of: {:?}", &FIELDS)
16677 }
16678
16679 #[allow(unused_variables)]
16680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16681 where
16682 E: serde::de::Error,
16683 {
16684 match value {
16685 "param" => Ok(GeneratedField::Param),
16686 "value" => Ok(GeneratedField::Value),
16687 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16688 }
16689 }
16690 }
16691 deserializer.deserialize_identifier(GeneratedVisitor)
16692 }
16693 }
16694 struct GeneratedVisitor;
16695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16696 type Value = SetSystemParamRequest;
16697
16698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16699 formatter.write_str("struct meta.SetSystemParamRequest")
16700 }
16701
16702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
16703 where
16704 V: serde::de::MapAccess<'de>,
16705 {
16706 let mut param__ = None;
16707 let mut value__ = None;
16708 while let Some(k) = map_.next_key()? {
16709 match k {
16710 GeneratedField::Param => {
16711 if param__.is_some() {
16712 return Err(serde::de::Error::duplicate_field("param"));
16713 }
16714 param__ = Some(map_.next_value()?);
16715 }
16716 GeneratedField::Value => {
16717 if value__.is_some() {
16718 return Err(serde::de::Error::duplicate_field("value"));
16719 }
16720 value__ = map_.next_value()?;
16721 }
16722 }
16723 }
16724 Ok(SetSystemParamRequest {
16725 param: param__.unwrap_or_default(),
16726 value: value__,
16727 })
16728 }
16729 }
16730 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
16731 }
16732}
16733impl serde::Serialize for SetSystemParamResponse {
16734 #[allow(deprecated)]
16735 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16736 where
16737 S: serde::Serializer,
16738 {
16739 use serde::ser::SerializeStruct;
16740 let mut len = 0;
16741 if self.params.is_some() {
16742 len += 1;
16743 }
16744 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
16745 if let Some(v) = self.params.as_ref() {
16746 struct_ser.serialize_field("params", v)?;
16747 }
16748 struct_ser.end()
16749 }
16750}
16751impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
16752 #[allow(deprecated)]
16753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16754 where
16755 D: serde::Deserializer<'de>,
16756 {
16757 const FIELDS: &[&str] = &[
16758 "params",
16759 ];
16760
16761 #[allow(clippy::enum_variant_names)]
16762 enum GeneratedField {
16763 Params,
16764 }
16765 impl<'de> serde::Deserialize<'de> for GeneratedField {
16766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16767 where
16768 D: serde::Deserializer<'de>,
16769 {
16770 struct GeneratedVisitor;
16771
16772 impl serde::de::Visitor<'_> for GeneratedVisitor {
16773 type Value = GeneratedField;
16774
16775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16776 write!(formatter, "expected one of: {:?}", &FIELDS)
16777 }
16778
16779 #[allow(unused_variables)]
16780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16781 where
16782 E: serde::de::Error,
16783 {
16784 match value {
16785 "params" => Ok(GeneratedField::Params),
16786 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16787 }
16788 }
16789 }
16790 deserializer.deserialize_identifier(GeneratedVisitor)
16791 }
16792 }
16793 struct GeneratedVisitor;
16794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16795 type Value = SetSystemParamResponse;
16796
16797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16798 formatter.write_str("struct meta.SetSystemParamResponse")
16799 }
16800
16801 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
16802 where
16803 V: serde::de::MapAccess<'de>,
16804 {
16805 let mut params__ = None;
16806 while let Some(k) = map_.next_key()? {
16807 match k {
16808 GeneratedField::Params => {
16809 if params__.is_some() {
16810 return Err(serde::de::Error::duplicate_field("params"));
16811 }
16812 params__ = map_.next_value()?;
16813 }
16814 }
16815 }
16816 Ok(SetSystemParamResponse {
16817 params: params__,
16818 })
16819 }
16820 }
16821 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
16822 }
16823}
16824impl serde::Serialize for SubscribeRequest {
16825 #[allow(deprecated)]
16826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16827 where
16828 S: serde::Serializer,
16829 {
16830 use serde::ser::SerializeStruct;
16831 let mut len = 0;
16832 if self.subscribe_type != 0 {
16833 len += 1;
16834 }
16835 if self.host.is_some() {
16836 len += 1;
16837 }
16838 if self.worker_id != 0 {
16839 len += 1;
16840 }
16841 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
16842 if self.subscribe_type != 0 {
16843 let v = SubscribeType::try_from(self.subscribe_type)
16844 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
16845 struct_ser.serialize_field("subscribeType", &v)?;
16846 }
16847 if let Some(v) = self.host.as_ref() {
16848 struct_ser.serialize_field("host", v)?;
16849 }
16850 if self.worker_id != 0 {
16851 struct_ser.serialize_field("workerId", &self.worker_id)?;
16852 }
16853 struct_ser.end()
16854 }
16855}
16856impl<'de> serde::Deserialize<'de> for SubscribeRequest {
16857 #[allow(deprecated)]
16858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16859 where
16860 D: serde::Deserializer<'de>,
16861 {
16862 const FIELDS: &[&str] = &[
16863 "subscribe_type",
16864 "subscribeType",
16865 "host",
16866 "worker_id",
16867 "workerId",
16868 ];
16869
16870 #[allow(clippy::enum_variant_names)]
16871 enum GeneratedField {
16872 SubscribeType,
16873 Host,
16874 WorkerId,
16875 }
16876 impl<'de> serde::Deserialize<'de> for GeneratedField {
16877 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16878 where
16879 D: serde::Deserializer<'de>,
16880 {
16881 struct GeneratedVisitor;
16882
16883 impl serde::de::Visitor<'_> for GeneratedVisitor {
16884 type Value = GeneratedField;
16885
16886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16887 write!(formatter, "expected one of: {:?}", &FIELDS)
16888 }
16889
16890 #[allow(unused_variables)]
16891 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16892 where
16893 E: serde::de::Error,
16894 {
16895 match value {
16896 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
16897 "host" => Ok(GeneratedField::Host),
16898 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
16899 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16900 }
16901 }
16902 }
16903 deserializer.deserialize_identifier(GeneratedVisitor)
16904 }
16905 }
16906 struct GeneratedVisitor;
16907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16908 type Value = SubscribeRequest;
16909
16910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16911 formatter.write_str("struct meta.SubscribeRequest")
16912 }
16913
16914 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
16915 where
16916 V: serde::de::MapAccess<'de>,
16917 {
16918 let mut subscribe_type__ = None;
16919 let mut host__ = None;
16920 let mut worker_id__ = None;
16921 while let Some(k) = map_.next_key()? {
16922 match k {
16923 GeneratedField::SubscribeType => {
16924 if subscribe_type__.is_some() {
16925 return Err(serde::de::Error::duplicate_field("subscribeType"));
16926 }
16927 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
16928 }
16929 GeneratedField::Host => {
16930 if host__.is_some() {
16931 return Err(serde::de::Error::duplicate_field("host"));
16932 }
16933 host__ = map_.next_value()?;
16934 }
16935 GeneratedField::WorkerId => {
16936 if worker_id__.is_some() {
16937 return Err(serde::de::Error::duplicate_field("workerId"));
16938 }
16939 worker_id__ =
16940 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16941 ;
16942 }
16943 }
16944 }
16945 Ok(SubscribeRequest {
16946 subscribe_type: subscribe_type__.unwrap_or_default(),
16947 host: host__,
16948 worker_id: worker_id__.unwrap_or_default(),
16949 })
16950 }
16951 }
16952 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
16953 }
16954}
16955impl serde::Serialize for SubscribeResponse {
16956 #[allow(deprecated)]
16957 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16958 where
16959 S: serde::Serializer,
16960 {
16961 use serde::ser::SerializeStruct;
16962 let mut len = 0;
16963 if self.status.is_some() {
16964 len += 1;
16965 }
16966 if self.operation != 0 {
16967 len += 1;
16968 }
16969 if self.version != 0 {
16970 len += 1;
16971 }
16972 if self.info.is_some() {
16973 len += 1;
16974 }
16975 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
16976 if let Some(v) = self.status.as_ref() {
16977 struct_ser.serialize_field("status", v)?;
16978 }
16979 if self.operation != 0 {
16980 let v = subscribe_response::Operation::try_from(self.operation)
16981 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
16982 struct_ser.serialize_field("operation", &v)?;
16983 }
16984 if self.version != 0 {
16985 #[allow(clippy::needless_borrow)]
16986 #[allow(clippy::needless_borrows_for_generic_args)]
16987 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
16988 }
16989 if let Some(v) = self.info.as_ref() {
16990 match v {
16991 subscribe_response::Info::Database(v) => {
16992 struct_ser.serialize_field("database", v)?;
16993 }
16994 subscribe_response::Info::Schema(v) => {
16995 struct_ser.serialize_field("schema", v)?;
16996 }
16997 subscribe_response::Info::Function(v) => {
16998 struct_ser.serialize_field("function", v)?;
16999 }
17000 subscribe_response::Info::User(v) => {
17001 struct_ser.serialize_field("user", v)?;
17002 }
17003 subscribe_response::Info::SessionParam(v) => {
17004 struct_ser.serialize_field("sessionParam", v)?;
17005 }
17006 subscribe_response::Info::Node(v) => {
17007 struct_ser.serialize_field("node", v)?;
17008 }
17009 subscribe_response::Info::HummockVersionDeltas(v) => {
17010 struct_ser.serialize_field("hummockVersionDeltas", v)?;
17011 }
17012 subscribe_response::Info::Snapshot(v) => {
17013 struct_ser.serialize_field("snapshot", v)?;
17014 }
17015 subscribe_response::Info::MetaBackupManifestId(v) => {
17016 struct_ser.serialize_field("metaBackupManifestId", v)?;
17017 }
17018 subscribe_response::Info::SystemParams(v) => {
17019 struct_ser.serialize_field("systemParams", v)?;
17020 }
17021 subscribe_response::Info::HummockWriteLimits(v) => {
17022 struct_ser.serialize_field("hummockWriteLimits", v)?;
17023 }
17024 subscribe_response::Info::ObjectGroup(v) => {
17025 struct_ser.serialize_field("objectGroup", v)?;
17026 }
17027 subscribe_response::Info::Connection(v) => {
17028 struct_ser.serialize_field("connection", v)?;
17029 }
17030 subscribe_response::Info::HummockStats(v) => {
17031 struct_ser.serialize_field("hummockStats", v)?;
17032 }
17033 subscribe_response::Info::Recovery(v) => {
17034 struct_ser.serialize_field("recovery", v)?;
17035 }
17036 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
17037 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
17038 }
17039 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
17040 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
17041 }
17042 subscribe_response::Info::Secret(v) => {
17043 struct_ser.serialize_field("secret", v)?;
17044 }
17045 subscribe_response::Info::ClusterResource(v) => {
17046 struct_ser.serialize_field("clusterResource", v)?;
17047 }
17048 }
17049 }
17050 struct_ser.end()
17051 }
17052}
17053impl<'de> serde::Deserialize<'de> for SubscribeResponse {
17054 #[allow(deprecated)]
17055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17056 where
17057 D: serde::Deserializer<'de>,
17058 {
17059 const FIELDS: &[&str] = &[
17060 "status",
17061 "operation",
17062 "version",
17063 "database",
17064 "schema",
17065 "function",
17066 "user",
17067 "session_param",
17068 "sessionParam",
17069 "node",
17070 "hummock_version_deltas",
17071 "hummockVersionDeltas",
17072 "snapshot",
17073 "meta_backup_manifest_id",
17074 "metaBackupManifestId",
17075 "system_params",
17076 "systemParams",
17077 "hummock_write_limits",
17078 "hummockWriteLimits",
17079 "object_group",
17080 "objectGroup",
17081 "connection",
17082 "hummock_stats",
17083 "hummockStats",
17084 "recovery",
17085 "streaming_worker_slot_mapping",
17086 "streamingWorkerSlotMapping",
17087 "serving_worker_slot_mappings",
17088 "servingWorkerSlotMappings",
17089 "secret",
17090 "cluster_resource",
17091 "clusterResource",
17092 ];
17093
17094 #[allow(clippy::enum_variant_names)]
17095 enum GeneratedField {
17096 Status,
17097 Operation,
17098 Version,
17099 Database,
17100 Schema,
17101 Function,
17102 User,
17103 SessionParam,
17104 Node,
17105 HummockVersionDeltas,
17106 Snapshot,
17107 MetaBackupManifestId,
17108 SystemParams,
17109 HummockWriteLimits,
17110 ObjectGroup,
17111 Connection,
17112 HummockStats,
17113 Recovery,
17114 StreamingWorkerSlotMapping,
17115 ServingWorkerSlotMappings,
17116 Secret,
17117 ClusterResource,
17118 }
17119 impl<'de> serde::Deserialize<'de> for GeneratedField {
17120 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17121 where
17122 D: serde::Deserializer<'de>,
17123 {
17124 struct GeneratedVisitor;
17125
17126 impl serde::de::Visitor<'_> for GeneratedVisitor {
17127 type Value = GeneratedField;
17128
17129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17130 write!(formatter, "expected one of: {:?}", &FIELDS)
17131 }
17132
17133 #[allow(unused_variables)]
17134 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17135 where
17136 E: serde::de::Error,
17137 {
17138 match value {
17139 "status" => Ok(GeneratedField::Status),
17140 "operation" => Ok(GeneratedField::Operation),
17141 "version" => Ok(GeneratedField::Version),
17142 "database" => Ok(GeneratedField::Database),
17143 "schema" => Ok(GeneratedField::Schema),
17144 "function" => Ok(GeneratedField::Function),
17145 "user" => Ok(GeneratedField::User),
17146 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
17147 "node" => Ok(GeneratedField::Node),
17148 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
17149 "snapshot" => Ok(GeneratedField::Snapshot),
17150 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
17151 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
17152 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
17153 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
17154 "connection" => Ok(GeneratedField::Connection),
17155 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
17156 "recovery" => Ok(GeneratedField::Recovery),
17157 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
17158 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
17159 "secret" => Ok(GeneratedField::Secret),
17160 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
17161 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17162 }
17163 }
17164 }
17165 deserializer.deserialize_identifier(GeneratedVisitor)
17166 }
17167 }
17168 struct GeneratedVisitor;
17169 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17170 type Value = SubscribeResponse;
17171
17172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17173 formatter.write_str("struct meta.SubscribeResponse")
17174 }
17175
17176 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
17177 where
17178 V: serde::de::MapAccess<'de>,
17179 {
17180 let mut status__ = None;
17181 let mut operation__ = None;
17182 let mut version__ = None;
17183 let mut info__ = None;
17184 while let Some(k) = map_.next_key()? {
17185 match k {
17186 GeneratedField::Status => {
17187 if status__.is_some() {
17188 return Err(serde::de::Error::duplicate_field("status"));
17189 }
17190 status__ = map_.next_value()?;
17191 }
17192 GeneratedField::Operation => {
17193 if operation__.is_some() {
17194 return Err(serde::de::Error::duplicate_field("operation"));
17195 }
17196 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
17197 }
17198 GeneratedField::Version => {
17199 if version__.is_some() {
17200 return Err(serde::de::Error::duplicate_field("version"));
17201 }
17202 version__ =
17203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17204 ;
17205 }
17206 GeneratedField::Database => {
17207 if info__.is_some() {
17208 return Err(serde::de::Error::duplicate_field("database"));
17209 }
17210 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
17211;
17212 }
17213 GeneratedField::Schema => {
17214 if info__.is_some() {
17215 return Err(serde::de::Error::duplicate_field("schema"));
17216 }
17217 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
17218;
17219 }
17220 GeneratedField::Function => {
17221 if info__.is_some() {
17222 return Err(serde::de::Error::duplicate_field("function"));
17223 }
17224 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
17225;
17226 }
17227 GeneratedField::User => {
17228 if info__.is_some() {
17229 return Err(serde::de::Error::duplicate_field("user"));
17230 }
17231 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
17232;
17233 }
17234 GeneratedField::SessionParam => {
17235 if info__.is_some() {
17236 return Err(serde::de::Error::duplicate_field("sessionParam"));
17237 }
17238 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
17239;
17240 }
17241 GeneratedField::Node => {
17242 if info__.is_some() {
17243 return Err(serde::de::Error::duplicate_field("node"));
17244 }
17245 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
17246;
17247 }
17248 GeneratedField::HummockVersionDeltas => {
17249 if info__.is_some() {
17250 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
17251 }
17252 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
17253;
17254 }
17255 GeneratedField::Snapshot => {
17256 if info__.is_some() {
17257 return Err(serde::de::Error::duplicate_field("snapshot"));
17258 }
17259 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
17260;
17261 }
17262 GeneratedField::MetaBackupManifestId => {
17263 if info__.is_some() {
17264 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
17265 }
17266 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
17267;
17268 }
17269 GeneratedField::SystemParams => {
17270 if info__.is_some() {
17271 return Err(serde::de::Error::duplicate_field("systemParams"));
17272 }
17273 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
17274;
17275 }
17276 GeneratedField::HummockWriteLimits => {
17277 if info__.is_some() {
17278 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
17279 }
17280 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
17281;
17282 }
17283 GeneratedField::ObjectGroup => {
17284 if info__.is_some() {
17285 return Err(serde::de::Error::duplicate_field("objectGroup"));
17286 }
17287 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
17288;
17289 }
17290 GeneratedField::Connection => {
17291 if info__.is_some() {
17292 return Err(serde::de::Error::duplicate_field("connection"));
17293 }
17294 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
17295;
17296 }
17297 GeneratedField::HummockStats => {
17298 if info__.is_some() {
17299 return Err(serde::de::Error::duplicate_field("hummockStats"));
17300 }
17301 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
17302;
17303 }
17304 GeneratedField::Recovery => {
17305 if info__.is_some() {
17306 return Err(serde::de::Error::duplicate_field("recovery"));
17307 }
17308 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
17309;
17310 }
17311 GeneratedField::StreamingWorkerSlotMapping => {
17312 if info__.is_some() {
17313 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
17314 }
17315 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
17316;
17317 }
17318 GeneratedField::ServingWorkerSlotMappings => {
17319 if info__.is_some() {
17320 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
17321 }
17322 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
17323;
17324 }
17325 GeneratedField::Secret => {
17326 if info__.is_some() {
17327 return Err(serde::de::Error::duplicate_field("secret"));
17328 }
17329 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
17330;
17331 }
17332 GeneratedField::ClusterResource => {
17333 if info__.is_some() {
17334 return Err(serde::de::Error::duplicate_field("clusterResource"));
17335 }
17336 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
17337;
17338 }
17339 }
17340 }
17341 Ok(SubscribeResponse {
17342 status: status__,
17343 operation: operation__.unwrap_or_default(),
17344 version: version__.unwrap_or_default(),
17345 info: info__,
17346 })
17347 }
17348 }
17349 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
17350 }
17351}
17352impl serde::Serialize for subscribe_response::Operation {
17353 #[allow(deprecated)]
17354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17355 where
17356 S: serde::Serializer,
17357 {
17358 let variant = match self {
17359 Self::Unspecified => "UNSPECIFIED",
17360 Self::Add => "ADD",
17361 Self::Delete => "DELETE",
17362 Self::Update => "UPDATE",
17363 Self::Snapshot => "SNAPSHOT",
17364 };
17365 serializer.serialize_str(variant)
17366 }
17367}
17368impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
17369 #[allow(deprecated)]
17370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17371 where
17372 D: serde::Deserializer<'de>,
17373 {
17374 const FIELDS: &[&str] = &[
17375 "UNSPECIFIED",
17376 "ADD",
17377 "DELETE",
17378 "UPDATE",
17379 "SNAPSHOT",
17380 ];
17381
17382 struct GeneratedVisitor;
17383
17384 impl serde::de::Visitor<'_> for GeneratedVisitor {
17385 type Value = subscribe_response::Operation;
17386
17387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17388 write!(formatter, "expected one of: {:?}", &FIELDS)
17389 }
17390
17391 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17392 where
17393 E: serde::de::Error,
17394 {
17395 i32::try_from(v)
17396 .ok()
17397 .and_then(|x| x.try_into().ok())
17398 .ok_or_else(|| {
17399 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17400 })
17401 }
17402
17403 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17404 where
17405 E: serde::de::Error,
17406 {
17407 i32::try_from(v)
17408 .ok()
17409 .and_then(|x| x.try_into().ok())
17410 .ok_or_else(|| {
17411 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17412 })
17413 }
17414
17415 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17416 where
17417 E: serde::de::Error,
17418 {
17419 match value {
17420 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17421 "ADD" => Ok(subscribe_response::Operation::Add),
17422 "DELETE" => Ok(subscribe_response::Operation::Delete),
17423 "UPDATE" => Ok(subscribe_response::Operation::Update),
17424 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17425 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17426 }
17427 }
17428 }
17429 deserializer.deserialize_any(GeneratedVisitor)
17430 }
17431}
17432impl serde::Serialize for SubscribeType {
17433 #[allow(deprecated)]
17434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17435 where
17436 S: serde::Serializer,
17437 {
17438 let variant = match self {
17439 Self::Unspecified => "UNSPECIFIED",
17440 Self::Frontend => "FRONTEND",
17441 Self::Hummock => "HUMMOCK",
17442 Self::Compactor => "COMPACTOR",
17443 Self::Compute => "COMPUTE",
17444 };
17445 serializer.serialize_str(variant)
17446 }
17447}
17448impl<'de> serde::Deserialize<'de> for SubscribeType {
17449 #[allow(deprecated)]
17450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17451 where
17452 D: serde::Deserializer<'de>,
17453 {
17454 const FIELDS: &[&str] = &[
17455 "UNSPECIFIED",
17456 "FRONTEND",
17457 "HUMMOCK",
17458 "COMPACTOR",
17459 "COMPUTE",
17460 ];
17461
17462 struct GeneratedVisitor;
17463
17464 impl serde::de::Visitor<'_> for GeneratedVisitor {
17465 type Value = SubscribeType;
17466
17467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17468 write!(formatter, "expected one of: {:?}", &FIELDS)
17469 }
17470
17471 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17472 where
17473 E: serde::de::Error,
17474 {
17475 i32::try_from(v)
17476 .ok()
17477 .and_then(|x| x.try_into().ok())
17478 .ok_or_else(|| {
17479 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17480 })
17481 }
17482
17483 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17484 where
17485 E: serde::de::Error,
17486 {
17487 i32::try_from(v)
17488 .ok()
17489 .and_then(|x| x.try_into().ok())
17490 .ok_or_else(|| {
17491 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17492 })
17493 }
17494
17495 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17496 where
17497 E: serde::de::Error,
17498 {
17499 match value {
17500 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17501 "FRONTEND" => Ok(SubscribeType::Frontend),
17502 "HUMMOCK" => Ok(SubscribeType::Hummock),
17503 "COMPACTOR" => Ok(SubscribeType::Compactor),
17504 "COMPUTE" => Ok(SubscribeType::Compute),
17505 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17506 }
17507 }
17508 }
17509 deserializer.deserialize_any(GeneratedVisitor)
17510 }
17511}
17512impl serde::Serialize for SystemParams {
17513 #[allow(deprecated)]
17514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17515 where
17516 S: serde::Serializer,
17517 {
17518 use serde::ser::SerializeStruct;
17519 let mut len = 0;
17520 if self.barrier_interval_ms.is_some() {
17521 len += 1;
17522 }
17523 if self.checkpoint_frequency.is_some() {
17524 len += 1;
17525 }
17526 if self.sstable_size_mb.is_some() {
17527 len += 1;
17528 }
17529 if self.block_size_kb.is_some() {
17530 len += 1;
17531 }
17532 if self.bloom_false_positive.is_some() {
17533 len += 1;
17534 }
17535 if self.state_store.is_some() {
17536 len += 1;
17537 }
17538 if self.data_directory.is_some() {
17539 len += 1;
17540 }
17541 if self.backup_storage_url.is_some() {
17542 len += 1;
17543 }
17544 if self.backup_storage_directory.is_some() {
17545 len += 1;
17546 }
17547 if self.telemetry_enabled.is_some() {
17548 len += 1;
17549 }
17550 if self.parallel_compact_size_mb.is_some() {
17551 len += 1;
17552 }
17553 if self.max_concurrent_creating_streaming_jobs.is_some() {
17554 len += 1;
17555 }
17556 if self.pause_on_next_bootstrap.is_some() {
17557 len += 1;
17558 }
17559 if self.wasm_storage_url.is_some() {
17560 len += 1;
17561 }
17562 if self.enable_tracing.is_some() {
17563 len += 1;
17564 }
17565 if self.use_new_object_prefix_strategy.is_some() {
17566 len += 1;
17567 }
17568 if self.license_key.is_some() {
17569 len += 1;
17570 }
17571 if self.time_travel_retention_ms.is_some() {
17572 len += 1;
17573 }
17574 if self.adaptive_parallelism_strategy.is_some() {
17575 len += 1;
17576 }
17577 if self.per_database_isolation.is_some() {
17578 len += 1;
17579 }
17580 if self.enforce_secret.is_some() {
17581 len += 1;
17582 }
17583 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
17584 if let Some(v) = self.barrier_interval_ms.as_ref() {
17585 struct_ser.serialize_field("barrierIntervalMs", v)?;
17586 }
17587 if let Some(v) = self.checkpoint_frequency.as_ref() {
17588 #[allow(clippy::needless_borrow)]
17589 #[allow(clippy::needless_borrows_for_generic_args)]
17590 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
17591 }
17592 if let Some(v) = self.sstable_size_mb.as_ref() {
17593 struct_ser.serialize_field("sstableSizeMb", v)?;
17594 }
17595 if let Some(v) = self.block_size_kb.as_ref() {
17596 struct_ser.serialize_field("blockSizeKb", v)?;
17597 }
17598 if let Some(v) = self.bloom_false_positive.as_ref() {
17599 struct_ser.serialize_field("bloomFalsePositive", v)?;
17600 }
17601 if let Some(v) = self.state_store.as_ref() {
17602 struct_ser.serialize_field("stateStore", v)?;
17603 }
17604 if let Some(v) = self.data_directory.as_ref() {
17605 struct_ser.serialize_field("dataDirectory", v)?;
17606 }
17607 if let Some(v) = self.backup_storage_url.as_ref() {
17608 struct_ser.serialize_field("backupStorageUrl", v)?;
17609 }
17610 if let Some(v) = self.backup_storage_directory.as_ref() {
17611 struct_ser.serialize_field("backupStorageDirectory", v)?;
17612 }
17613 if let Some(v) = self.telemetry_enabled.as_ref() {
17614 struct_ser.serialize_field("telemetryEnabled", v)?;
17615 }
17616 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
17617 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
17618 }
17619 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
17620 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
17621 }
17622 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
17623 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
17624 }
17625 if let Some(v) = self.wasm_storage_url.as_ref() {
17626 struct_ser.serialize_field("wasmStorageUrl", v)?;
17627 }
17628 if let Some(v) = self.enable_tracing.as_ref() {
17629 struct_ser.serialize_field("enableTracing", v)?;
17630 }
17631 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
17632 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
17633 }
17634 if let Some(v) = self.license_key.as_ref() {
17635 struct_ser.serialize_field("licenseKey", v)?;
17636 }
17637 if let Some(v) = self.time_travel_retention_ms.as_ref() {
17638 #[allow(clippy::needless_borrow)]
17639 #[allow(clippy::needless_borrows_for_generic_args)]
17640 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
17641 }
17642 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
17643 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
17644 }
17645 if let Some(v) = self.per_database_isolation.as_ref() {
17646 struct_ser.serialize_field("perDatabaseIsolation", v)?;
17647 }
17648 if let Some(v) = self.enforce_secret.as_ref() {
17649 struct_ser.serialize_field("enforceSecret", v)?;
17650 }
17651 struct_ser.end()
17652 }
17653}
17654impl<'de> serde::Deserialize<'de> for SystemParams {
17655 #[allow(deprecated)]
17656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17657 where
17658 D: serde::Deserializer<'de>,
17659 {
17660 const FIELDS: &[&str] = &[
17661 "barrier_interval_ms",
17662 "barrierIntervalMs",
17663 "checkpoint_frequency",
17664 "checkpointFrequency",
17665 "sstable_size_mb",
17666 "sstableSizeMb",
17667 "block_size_kb",
17668 "blockSizeKb",
17669 "bloom_false_positive",
17670 "bloomFalsePositive",
17671 "state_store",
17672 "stateStore",
17673 "data_directory",
17674 "dataDirectory",
17675 "backup_storage_url",
17676 "backupStorageUrl",
17677 "backup_storage_directory",
17678 "backupStorageDirectory",
17679 "telemetry_enabled",
17680 "telemetryEnabled",
17681 "parallel_compact_size_mb",
17682 "parallelCompactSizeMb",
17683 "max_concurrent_creating_streaming_jobs",
17684 "maxConcurrentCreatingStreamingJobs",
17685 "pause_on_next_bootstrap",
17686 "pauseOnNextBootstrap",
17687 "wasm_storage_url",
17688 "wasmStorageUrl",
17689 "enable_tracing",
17690 "enableTracing",
17691 "use_new_object_prefix_strategy",
17692 "useNewObjectPrefixStrategy",
17693 "license_key",
17694 "licenseKey",
17695 "time_travel_retention_ms",
17696 "timeTravelRetentionMs",
17697 "adaptive_parallelism_strategy",
17698 "adaptiveParallelismStrategy",
17699 "per_database_isolation",
17700 "perDatabaseIsolation",
17701 "enforce_secret",
17702 "enforceSecret",
17703 ];
17704
17705 #[allow(clippy::enum_variant_names)]
17706 enum GeneratedField {
17707 BarrierIntervalMs,
17708 CheckpointFrequency,
17709 SstableSizeMb,
17710 BlockSizeKb,
17711 BloomFalsePositive,
17712 StateStore,
17713 DataDirectory,
17714 BackupStorageUrl,
17715 BackupStorageDirectory,
17716 TelemetryEnabled,
17717 ParallelCompactSizeMb,
17718 MaxConcurrentCreatingStreamingJobs,
17719 PauseOnNextBootstrap,
17720 WasmStorageUrl,
17721 EnableTracing,
17722 UseNewObjectPrefixStrategy,
17723 LicenseKey,
17724 TimeTravelRetentionMs,
17725 AdaptiveParallelismStrategy,
17726 PerDatabaseIsolation,
17727 EnforceSecret,
17728 }
17729 impl<'de> serde::Deserialize<'de> for GeneratedField {
17730 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17731 where
17732 D: serde::Deserializer<'de>,
17733 {
17734 struct GeneratedVisitor;
17735
17736 impl serde::de::Visitor<'_> for GeneratedVisitor {
17737 type Value = GeneratedField;
17738
17739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17740 write!(formatter, "expected one of: {:?}", &FIELDS)
17741 }
17742
17743 #[allow(unused_variables)]
17744 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17745 where
17746 E: serde::de::Error,
17747 {
17748 match value {
17749 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
17750 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
17751 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
17752 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
17753 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
17754 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
17755 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
17756 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
17757 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
17758 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
17759 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
17760 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
17761 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
17762 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
17763 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
17764 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
17765 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
17766 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
17767 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
17768 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
17769 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
17770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17771 }
17772 }
17773 }
17774 deserializer.deserialize_identifier(GeneratedVisitor)
17775 }
17776 }
17777 struct GeneratedVisitor;
17778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17779 type Value = SystemParams;
17780
17781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17782 formatter.write_str("struct meta.SystemParams")
17783 }
17784
17785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
17786 where
17787 V: serde::de::MapAccess<'de>,
17788 {
17789 let mut barrier_interval_ms__ = None;
17790 let mut checkpoint_frequency__ = None;
17791 let mut sstable_size_mb__ = None;
17792 let mut block_size_kb__ = None;
17793 let mut bloom_false_positive__ = None;
17794 let mut state_store__ = None;
17795 let mut data_directory__ = None;
17796 let mut backup_storage_url__ = None;
17797 let mut backup_storage_directory__ = None;
17798 let mut telemetry_enabled__ = None;
17799 let mut parallel_compact_size_mb__ = None;
17800 let mut max_concurrent_creating_streaming_jobs__ = None;
17801 let mut pause_on_next_bootstrap__ = None;
17802 let mut wasm_storage_url__ = None;
17803 let mut enable_tracing__ = None;
17804 let mut use_new_object_prefix_strategy__ = None;
17805 let mut license_key__ = None;
17806 let mut time_travel_retention_ms__ = None;
17807 let mut adaptive_parallelism_strategy__ = None;
17808 let mut per_database_isolation__ = None;
17809 let mut enforce_secret__ = None;
17810 while let Some(k) = map_.next_key()? {
17811 match k {
17812 GeneratedField::BarrierIntervalMs => {
17813 if barrier_interval_ms__.is_some() {
17814 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
17815 }
17816 barrier_interval_ms__ =
17817 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17818 ;
17819 }
17820 GeneratedField::CheckpointFrequency => {
17821 if checkpoint_frequency__.is_some() {
17822 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
17823 }
17824 checkpoint_frequency__ =
17825 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17826 ;
17827 }
17828 GeneratedField::SstableSizeMb => {
17829 if sstable_size_mb__.is_some() {
17830 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
17831 }
17832 sstable_size_mb__ =
17833 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17834 ;
17835 }
17836 GeneratedField::BlockSizeKb => {
17837 if block_size_kb__.is_some() {
17838 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
17839 }
17840 block_size_kb__ =
17841 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17842 ;
17843 }
17844 GeneratedField::BloomFalsePositive => {
17845 if bloom_false_positive__.is_some() {
17846 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
17847 }
17848 bloom_false_positive__ =
17849 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17850 ;
17851 }
17852 GeneratedField::StateStore => {
17853 if state_store__.is_some() {
17854 return Err(serde::de::Error::duplicate_field("stateStore"));
17855 }
17856 state_store__ = map_.next_value()?;
17857 }
17858 GeneratedField::DataDirectory => {
17859 if data_directory__.is_some() {
17860 return Err(serde::de::Error::duplicate_field("dataDirectory"));
17861 }
17862 data_directory__ = map_.next_value()?;
17863 }
17864 GeneratedField::BackupStorageUrl => {
17865 if backup_storage_url__.is_some() {
17866 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
17867 }
17868 backup_storage_url__ = map_.next_value()?;
17869 }
17870 GeneratedField::BackupStorageDirectory => {
17871 if backup_storage_directory__.is_some() {
17872 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
17873 }
17874 backup_storage_directory__ = map_.next_value()?;
17875 }
17876 GeneratedField::TelemetryEnabled => {
17877 if telemetry_enabled__.is_some() {
17878 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
17879 }
17880 telemetry_enabled__ = map_.next_value()?;
17881 }
17882 GeneratedField::ParallelCompactSizeMb => {
17883 if parallel_compact_size_mb__.is_some() {
17884 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
17885 }
17886 parallel_compact_size_mb__ =
17887 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17888 ;
17889 }
17890 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
17891 if max_concurrent_creating_streaming_jobs__.is_some() {
17892 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
17893 }
17894 max_concurrent_creating_streaming_jobs__ =
17895 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17896 ;
17897 }
17898 GeneratedField::PauseOnNextBootstrap => {
17899 if pause_on_next_bootstrap__.is_some() {
17900 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
17901 }
17902 pause_on_next_bootstrap__ = map_.next_value()?;
17903 }
17904 GeneratedField::WasmStorageUrl => {
17905 if wasm_storage_url__.is_some() {
17906 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
17907 }
17908 wasm_storage_url__ = map_.next_value()?;
17909 }
17910 GeneratedField::EnableTracing => {
17911 if enable_tracing__.is_some() {
17912 return Err(serde::de::Error::duplicate_field("enableTracing"));
17913 }
17914 enable_tracing__ = map_.next_value()?;
17915 }
17916 GeneratedField::UseNewObjectPrefixStrategy => {
17917 if use_new_object_prefix_strategy__.is_some() {
17918 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
17919 }
17920 use_new_object_prefix_strategy__ = map_.next_value()?;
17921 }
17922 GeneratedField::LicenseKey => {
17923 if license_key__.is_some() {
17924 return Err(serde::de::Error::duplicate_field("licenseKey"));
17925 }
17926 license_key__ = map_.next_value()?;
17927 }
17928 GeneratedField::TimeTravelRetentionMs => {
17929 if time_travel_retention_ms__.is_some() {
17930 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
17931 }
17932 time_travel_retention_ms__ =
17933 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17934 ;
17935 }
17936 GeneratedField::AdaptiveParallelismStrategy => {
17937 if adaptive_parallelism_strategy__.is_some() {
17938 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
17939 }
17940 adaptive_parallelism_strategy__ = map_.next_value()?;
17941 }
17942 GeneratedField::PerDatabaseIsolation => {
17943 if per_database_isolation__.is_some() {
17944 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
17945 }
17946 per_database_isolation__ = map_.next_value()?;
17947 }
17948 GeneratedField::EnforceSecret => {
17949 if enforce_secret__.is_some() {
17950 return Err(serde::de::Error::duplicate_field("enforceSecret"));
17951 }
17952 enforce_secret__ = map_.next_value()?;
17953 }
17954 }
17955 }
17956 Ok(SystemParams {
17957 barrier_interval_ms: barrier_interval_ms__,
17958 checkpoint_frequency: checkpoint_frequency__,
17959 sstable_size_mb: sstable_size_mb__,
17960 block_size_kb: block_size_kb__,
17961 bloom_false_positive: bloom_false_positive__,
17962 state_store: state_store__,
17963 data_directory: data_directory__,
17964 backup_storage_url: backup_storage_url__,
17965 backup_storage_directory: backup_storage_directory__,
17966 telemetry_enabled: telemetry_enabled__,
17967 parallel_compact_size_mb: parallel_compact_size_mb__,
17968 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
17969 pause_on_next_bootstrap: pause_on_next_bootstrap__,
17970 wasm_storage_url: wasm_storage_url__,
17971 enable_tracing: enable_tracing__,
17972 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
17973 license_key: license_key__,
17974 time_travel_retention_ms: time_travel_retention_ms__,
17975 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
17976 per_database_isolation: per_database_isolation__,
17977 enforce_secret: enforce_secret__,
17978 })
17979 }
17980 }
17981 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
17982 }
17983}
17984impl serde::Serialize for TableFragments {
17985 #[allow(deprecated)]
17986 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17987 where
17988 S: serde::Serializer,
17989 {
17990 use serde::ser::SerializeStruct;
17991 let mut len = 0;
17992 if self.table_id != 0 {
17993 len += 1;
17994 }
17995 if self.state != 0 {
17996 len += 1;
17997 }
17998 if !self.fragments.is_empty() {
17999 len += 1;
18000 }
18001 if !self.actor_status.is_empty() {
18002 len += 1;
18003 }
18004 if self.ctx.is_some() {
18005 len += 1;
18006 }
18007 if self.parallelism.is_some() {
18008 len += 1;
18009 }
18010 if self.max_parallelism.is_some() {
18011 len += 1;
18012 }
18013 if !self.node_label.is_empty() {
18014 len += 1;
18015 }
18016 if self.backfill_done {
18017 len += 1;
18018 }
18019 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
18020 if self.table_id != 0 {
18021 struct_ser.serialize_field("tableId", &self.table_id)?;
18022 }
18023 if self.state != 0 {
18024 let v = table_fragments::State::try_from(self.state)
18025 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
18026 struct_ser.serialize_field("state", &v)?;
18027 }
18028 if !self.fragments.is_empty() {
18029 struct_ser.serialize_field("fragments", &self.fragments)?;
18030 }
18031 if !self.actor_status.is_empty() {
18032 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
18033 }
18034 if let Some(v) = self.ctx.as_ref() {
18035 struct_ser.serialize_field("ctx", v)?;
18036 }
18037 if let Some(v) = self.parallelism.as_ref() {
18038 struct_ser.serialize_field("parallelism", v)?;
18039 }
18040 if let Some(v) = self.max_parallelism.as_ref() {
18041 struct_ser.serialize_field("maxParallelism", v)?;
18042 }
18043 if !self.node_label.is_empty() {
18044 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18045 }
18046 if self.backfill_done {
18047 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
18048 }
18049 struct_ser.end()
18050 }
18051}
18052impl<'de> serde::Deserialize<'de> for TableFragments {
18053 #[allow(deprecated)]
18054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18055 where
18056 D: serde::Deserializer<'de>,
18057 {
18058 const FIELDS: &[&str] = &[
18059 "table_id",
18060 "tableId",
18061 "state",
18062 "fragments",
18063 "actor_status",
18064 "actorStatus",
18065 "ctx",
18066 "parallelism",
18067 "max_parallelism",
18068 "maxParallelism",
18069 "node_label",
18070 "nodeLabel",
18071 "backfill_done",
18072 "backfillDone",
18073 ];
18074
18075 #[allow(clippy::enum_variant_names)]
18076 enum GeneratedField {
18077 TableId,
18078 State,
18079 Fragments,
18080 ActorStatus,
18081 Ctx,
18082 Parallelism,
18083 MaxParallelism,
18084 NodeLabel,
18085 BackfillDone,
18086 }
18087 impl<'de> serde::Deserialize<'de> for GeneratedField {
18088 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18089 where
18090 D: serde::Deserializer<'de>,
18091 {
18092 struct GeneratedVisitor;
18093
18094 impl serde::de::Visitor<'_> for GeneratedVisitor {
18095 type Value = GeneratedField;
18096
18097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18098 write!(formatter, "expected one of: {:?}", &FIELDS)
18099 }
18100
18101 #[allow(unused_variables)]
18102 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18103 where
18104 E: serde::de::Error,
18105 {
18106 match value {
18107 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18108 "state" => Ok(GeneratedField::State),
18109 "fragments" => Ok(GeneratedField::Fragments),
18110 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
18111 "ctx" => Ok(GeneratedField::Ctx),
18112 "parallelism" => Ok(GeneratedField::Parallelism),
18113 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
18114 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18115 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
18116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18117 }
18118 }
18119 }
18120 deserializer.deserialize_identifier(GeneratedVisitor)
18121 }
18122 }
18123 struct GeneratedVisitor;
18124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18125 type Value = TableFragments;
18126
18127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18128 formatter.write_str("struct meta.TableFragments")
18129 }
18130
18131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
18132 where
18133 V: serde::de::MapAccess<'de>,
18134 {
18135 let mut table_id__ = None;
18136 let mut state__ = None;
18137 let mut fragments__ = None;
18138 let mut actor_status__ = None;
18139 let mut ctx__ = None;
18140 let mut parallelism__ = None;
18141 let mut max_parallelism__ = None;
18142 let mut node_label__ = None;
18143 let mut backfill_done__ = None;
18144 while let Some(k) = map_.next_key()? {
18145 match k {
18146 GeneratedField::TableId => {
18147 if table_id__.is_some() {
18148 return Err(serde::de::Error::duplicate_field("tableId"));
18149 }
18150 table_id__ =
18151 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18152 ;
18153 }
18154 GeneratedField::State => {
18155 if state__.is_some() {
18156 return Err(serde::de::Error::duplicate_field("state"));
18157 }
18158 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
18159 }
18160 GeneratedField::Fragments => {
18161 if fragments__.is_some() {
18162 return Err(serde::de::Error::duplicate_field("fragments"));
18163 }
18164 fragments__ = Some(
18165 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18166 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18167 );
18168 }
18169 GeneratedField::ActorStatus => {
18170 if actor_status__.is_some() {
18171 return Err(serde::de::Error::duplicate_field("actorStatus"));
18172 }
18173 actor_status__ = Some(
18174 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18175 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18176 );
18177 }
18178 GeneratedField::Ctx => {
18179 if ctx__.is_some() {
18180 return Err(serde::de::Error::duplicate_field("ctx"));
18181 }
18182 ctx__ = map_.next_value()?;
18183 }
18184 GeneratedField::Parallelism => {
18185 if parallelism__.is_some() {
18186 return Err(serde::de::Error::duplicate_field("parallelism"));
18187 }
18188 parallelism__ = map_.next_value()?;
18189 }
18190 GeneratedField::MaxParallelism => {
18191 if max_parallelism__.is_some() {
18192 return Err(serde::de::Error::duplicate_field("maxParallelism"));
18193 }
18194 max_parallelism__ =
18195 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18196 ;
18197 }
18198 GeneratedField::NodeLabel => {
18199 if node_label__.is_some() {
18200 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18201 }
18202 node_label__ = Some(map_.next_value()?);
18203 }
18204 GeneratedField::BackfillDone => {
18205 if backfill_done__.is_some() {
18206 return Err(serde::de::Error::duplicate_field("backfillDone"));
18207 }
18208 backfill_done__ = Some(map_.next_value()?);
18209 }
18210 }
18211 }
18212 Ok(TableFragments {
18213 table_id: table_id__.unwrap_or_default(),
18214 state: state__.unwrap_or_default(),
18215 fragments: fragments__.unwrap_or_default(),
18216 actor_status: actor_status__.unwrap_or_default(),
18217 ctx: ctx__,
18218 parallelism: parallelism__,
18219 max_parallelism: max_parallelism__,
18220 node_label: node_label__.unwrap_or_default(),
18221 backfill_done: backfill_done__.unwrap_or_default(),
18222 })
18223 }
18224 }
18225 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
18226 }
18227}
18228impl serde::Serialize for table_fragments::ActorStatus {
18229 #[allow(deprecated)]
18230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18231 where
18232 S: serde::Serializer,
18233 {
18234 use serde::ser::SerializeStruct;
18235 let mut len = 0;
18236 if self.location.is_some() {
18237 len += 1;
18238 }
18239 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
18240 if let Some(v) = self.location.as_ref() {
18241 struct_ser.serialize_field("location", v)?;
18242 }
18243 struct_ser.end()
18244 }
18245}
18246impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
18247 #[allow(deprecated)]
18248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18249 where
18250 D: serde::Deserializer<'de>,
18251 {
18252 const FIELDS: &[&str] = &[
18253 "location",
18254 ];
18255
18256 #[allow(clippy::enum_variant_names)]
18257 enum GeneratedField {
18258 Location,
18259 }
18260 impl<'de> serde::Deserialize<'de> for GeneratedField {
18261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18262 where
18263 D: serde::Deserializer<'de>,
18264 {
18265 struct GeneratedVisitor;
18266
18267 impl serde::de::Visitor<'_> for GeneratedVisitor {
18268 type Value = GeneratedField;
18269
18270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18271 write!(formatter, "expected one of: {:?}", &FIELDS)
18272 }
18273
18274 #[allow(unused_variables)]
18275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18276 where
18277 E: serde::de::Error,
18278 {
18279 match value {
18280 "location" => Ok(GeneratedField::Location),
18281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18282 }
18283 }
18284 }
18285 deserializer.deserialize_identifier(GeneratedVisitor)
18286 }
18287 }
18288 struct GeneratedVisitor;
18289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18290 type Value = table_fragments::ActorStatus;
18291
18292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18293 formatter.write_str("struct meta.TableFragments.ActorStatus")
18294 }
18295
18296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
18297 where
18298 V: serde::de::MapAccess<'de>,
18299 {
18300 let mut location__ = None;
18301 while let Some(k) = map_.next_key()? {
18302 match k {
18303 GeneratedField::Location => {
18304 if location__.is_some() {
18305 return Err(serde::de::Error::duplicate_field("location"));
18306 }
18307 location__ = map_.next_value()?;
18308 }
18309 }
18310 }
18311 Ok(table_fragments::ActorStatus {
18312 location: location__,
18313 })
18314 }
18315 }
18316 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
18317 }
18318}
18319impl serde::Serialize for table_fragments::Fragment {
18320 #[allow(deprecated)]
18321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18322 where
18323 S: serde::Serializer,
18324 {
18325 use serde::ser::SerializeStruct;
18326 let mut len = 0;
18327 if self.fragment_id != 0 {
18328 len += 1;
18329 }
18330 if self.fragment_type_mask != 0 {
18331 len += 1;
18332 }
18333 if self.distribution_type != 0 {
18334 len += 1;
18335 }
18336 if !self.actors.is_empty() {
18337 len += 1;
18338 }
18339 if !self.state_table_ids.is_empty() {
18340 len += 1;
18341 }
18342 if !self.upstream_fragment_ids.is_empty() {
18343 len += 1;
18344 }
18345 if self.maybe_vnode_count.is_some() {
18346 len += 1;
18347 }
18348 if self.nodes.is_some() {
18349 len += 1;
18350 }
18351 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
18352 if self.fragment_id != 0 {
18353 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
18354 }
18355 if self.fragment_type_mask != 0 {
18356 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
18357 }
18358 if self.distribution_type != 0 {
18359 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
18360 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
18361 struct_ser.serialize_field("distributionType", &v)?;
18362 }
18363 if !self.actors.is_empty() {
18364 struct_ser.serialize_field("actors", &self.actors)?;
18365 }
18366 if !self.state_table_ids.is_empty() {
18367 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
18368 }
18369 if !self.upstream_fragment_ids.is_empty() {
18370 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
18371 }
18372 if let Some(v) = self.maybe_vnode_count.as_ref() {
18373 struct_ser.serialize_field("maybeVnodeCount", v)?;
18374 }
18375 if let Some(v) = self.nodes.as_ref() {
18376 struct_ser.serialize_field("nodes", v)?;
18377 }
18378 struct_ser.end()
18379 }
18380}
18381impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
18382 #[allow(deprecated)]
18383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18384 where
18385 D: serde::Deserializer<'de>,
18386 {
18387 const FIELDS: &[&str] = &[
18388 "fragment_id",
18389 "fragmentId",
18390 "fragment_type_mask",
18391 "fragmentTypeMask",
18392 "distribution_type",
18393 "distributionType",
18394 "actors",
18395 "state_table_ids",
18396 "stateTableIds",
18397 "upstream_fragment_ids",
18398 "upstreamFragmentIds",
18399 "maybe_vnode_count",
18400 "maybeVnodeCount",
18401 "nodes",
18402 ];
18403
18404 #[allow(clippy::enum_variant_names)]
18405 enum GeneratedField {
18406 FragmentId,
18407 FragmentTypeMask,
18408 DistributionType,
18409 Actors,
18410 StateTableIds,
18411 UpstreamFragmentIds,
18412 MaybeVnodeCount,
18413 Nodes,
18414 }
18415 impl<'de> serde::Deserialize<'de> for GeneratedField {
18416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18417 where
18418 D: serde::Deserializer<'de>,
18419 {
18420 struct GeneratedVisitor;
18421
18422 impl serde::de::Visitor<'_> for GeneratedVisitor {
18423 type Value = GeneratedField;
18424
18425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18426 write!(formatter, "expected one of: {:?}", &FIELDS)
18427 }
18428
18429 #[allow(unused_variables)]
18430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18431 where
18432 E: serde::de::Error,
18433 {
18434 match value {
18435 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
18436 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
18437 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
18438 "actors" => Ok(GeneratedField::Actors),
18439 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
18440 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
18441 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
18442 "nodes" => Ok(GeneratedField::Nodes),
18443 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18444 }
18445 }
18446 }
18447 deserializer.deserialize_identifier(GeneratedVisitor)
18448 }
18449 }
18450 struct GeneratedVisitor;
18451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18452 type Value = table_fragments::Fragment;
18453
18454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18455 formatter.write_str("struct meta.TableFragments.Fragment")
18456 }
18457
18458 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
18459 where
18460 V: serde::de::MapAccess<'de>,
18461 {
18462 let mut fragment_id__ = None;
18463 let mut fragment_type_mask__ = None;
18464 let mut distribution_type__ = None;
18465 let mut actors__ = None;
18466 let mut state_table_ids__ = None;
18467 let mut upstream_fragment_ids__ = None;
18468 let mut maybe_vnode_count__ = None;
18469 let mut nodes__ = None;
18470 while let Some(k) = map_.next_key()? {
18471 match k {
18472 GeneratedField::FragmentId => {
18473 if fragment_id__.is_some() {
18474 return Err(serde::de::Error::duplicate_field("fragmentId"));
18475 }
18476 fragment_id__ =
18477 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18478 ;
18479 }
18480 GeneratedField::FragmentTypeMask => {
18481 if fragment_type_mask__.is_some() {
18482 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
18483 }
18484 fragment_type_mask__ =
18485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18486 ;
18487 }
18488 GeneratedField::DistributionType => {
18489 if distribution_type__.is_some() {
18490 return Err(serde::de::Error::duplicate_field("distributionType"));
18491 }
18492 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
18493 }
18494 GeneratedField::Actors => {
18495 if actors__.is_some() {
18496 return Err(serde::de::Error::duplicate_field("actors"));
18497 }
18498 actors__ = Some(map_.next_value()?);
18499 }
18500 GeneratedField::StateTableIds => {
18501 if state_table_ids__.is_some() {
18502 return Err(serde::de::Error::duplicate_field("stateTableIds"));
18503 }
18504 state_table_ids__ =
18505 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18506 .into_iter().map(|x| x.0).collect())
18507 ;
18508 }
18509 GeneratedField::UpstreamFragmentIds => {
18510 if upstream_fragment_ids__.is_some() {
18511 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
18512 }
18513 upstream_fragment_ids__ =
18514 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18515 .into_iter().map(|x| x.0).collect())
18516 ;
18517 }
18518 GeneratedField::MaybeVnodeCount => {
18519 if maybe_vnode_count__.is_some() {
18520 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
18521 }
18522 maybe_vnode_count__ =
18523 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18524 ;
18525 }
18526 GeneratedField::Nodes => {
18527 if nodes__.is_some() {
18528 return Err(serde::de::Error::duplicate_field("nodes"));
18529 }
18530 nodes__ = map_.next_value()?;
18531 }
18532 }
18533 }
18534 Ok(table_fragments::Fragment {
18535 fragment_id: fragment_id__.unwrap_or_default(),
18536 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
18537 distribution_type: distribution_type__.unwrap_or_default(),
18538 actors: actors__.unwrap_or_default(),
18539 state_table_ids: state_table_ids__.unwrap_or_default(),
18540 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
18541 maybe_vnode_count: maybe_vnode_count__,
18542 nodes: nodes__,
18543 })
18544 }
18545 }
18546 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
18547 }
18548}
18549impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
18550 #[allow(deprecated)]
18551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18552 where
18553 S: serde::Serializer,
18554 {
18555 let variant = match self {
18556 Self::Unspecified => "UNSPECIFIED",
18557 Self::Single => "SINGLE",
18558 Self::Hash => "HASH",
18559 };
18560 serializer.serialize_str(variant)
18561 }
18562}
18563impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
18564 #[allow(deprecated)]
18565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18566 where
18567 D: serde::Deserializer<'de>,
18568 {
18569 const FIELDS: &[&str] = &[
18570 "UNSPECIFIED",
18571 "SINGLE",
18572 "HASH",
18573 ];
18574
18575 struct GeneratedVisitor;
18576
18577 impl serde::de::Visitor<'_> for GeneratedVisitor {
18578 type Value = table_fragments::fragment::FragmentDistributionType;
18579
18580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18581 write!(formatter, "expected one of: {:?}", &FIELDS)
18582 }
18583
18584 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18585 where
18586 E: serde::de::Error,
18587 {
18588 i32::try_from(v)
18589 .ok()
18590 .and_then(|x| x.try_into().ok())
18591 .ok_or_else(|| {
18592 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18593 })
18594 }
18595
18596 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18597 where
18598 E: serde::de::Error,
18599 {
18600 i32::try_from(v)
18601 .ok()
18602 .and_then(|x| x.try_into().ok())
18603 .ok_or_else(|| {
18604 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18605 })
18606 }
18607
18608 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18609 where
18610 E: serde::de::Error,
18611 {
18612 match value {
18613 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
18614 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
18615 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
18616 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18617 }
18618 }
18619 }
18620 deserializer.deserialize_any(GeneratedVisitor)
18621 }
18622}
18623impl serde::Serialize for table_fragments::State {
18624 #[allow(deprecated)]
18625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18626 where
18627 S: serde::Serializer,
18628 {
18629 let variant = match self {
18630 Self::Unspecified => "UNSPECIFIED",
18631 Self::Initial => "INITIAL",
18632 Self::Creating => "CREATING",
18633 Self::Created => "CREATED",
18634 };
18635 serializer.serialize_str(variant)
18636 }
18637}
18638impl<'de> serde::Deserialize<'de> for table_fragments::State {
18639 #[allow(deprecated)]
18640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18641 where
18642 D: serde::Deserializer<'de>,
18643 {
18644 const FIELDS: &[&str] = &[
18645 "UNSPECIFIED",
18646 "INITIAL",
18647 "CREATING",
18648 "CREATED",
18649 ];
18650
18651 struct GeneratedVisitor;
18652
18653 impl serde::de::Visitor<'_> for GeneratedVisitor {
18654 type Value = table_fragments::State;
18655
18656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18657 write!(formatter, "expected one of: {:?}", &FIELDS)
18658 }
18659
18660 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18661 where
18662 E: serde::de::Error,
18663 {
18664 i32::try_from(v)
18665 .ok()
18666 .and_then(|x| x.try_into().ok())
18667 .ok_or_else(|| {
18668 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18669 })
18670 }
18671
18672 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18673 where
18674 E: serde::de::Error,
18675 {
18676 i32::try_from(v)
18677 .ok()
18678 .and_then(|x| x.try_into().ok())
18679 .ok_or_else(|| {
18680 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18681 })
18682 }
18683
18684 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18685 where
18686 E: serde::de::Error,
18687 {
18688 match value {
18689 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
18690 "INITIAL" => Ok(table_fragments::State::Initial),
18691 "CREATING" => Ok(table_fragments::State::Creating),
18692 "CREATED" => Ok(table_fragments::State::Created),
18693 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18694 }
18695 }
18696 }
18697 deserializer.deserialize_any(GeneratedVisitor)
18698 }
18699}
18700impl serde::Serialize for TableParallelism {
18701 #[allow(deprecated)]
18702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18703 where
18704 S: serde::Serializer,
18705 {
18706 use serde::ser::SerializeStruct;
18707 let mut len = 0;
18708 if self.parallelism.is_some() {
18709 len += 1;
18710 }
18711 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
18712 if let Some(v) = self.parallelism.as_ref() {
18713 match v {
18714 table_parallelism::Parallelism::Fixed(v) => {
18715 struct_ser.serialize_field("fixed", v)?;
18716 }
18717 table_parallelism::Parallelism::Auto(v) => {
18718 struct_ser.serialize_field("auto", v)?;
18719 }
18720 table_parallelism::Parallelism::Custom(v) => {
18721 struct_ser.serialize_field("custom", v)?;
18722 }
18723 table_parallelism::Parallelism::Adaptive(v) => {
18724 struct_ser.serialize_field("adaptive", v)?;
18725 }
18726 }
18727 }
18728 struct_ser.end()
18729 }
18730}
18731impl<'de> serde::Deserialize<'de> for TableParallelism {
18732 #[allow(deprecated)]
18733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18734 where
18735 D: serde::Deserializer<'de>,
18736 {
18737 const FIELDS: &[&str] = &[
18738 "fixed",
18739 "auto",
18740 "custom",
18741 "adaptive",
18742 ];
18743
18744 #[allow(clippy::enum_variant_names)]
18745 enum GeneratedField {
18746 Fixed,
18747 Auto,
18748 Custom,
18749 Adaptive,
18750 }
18751 impl<'de> serde::Deserialize<'de> for GeneratedField {
18752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18753 where
18754 D: serde::Deserializer<'de>,
18755 {
18756 struct GeneratedVisitor;
18757
18758 impl serde::de::Visitor<'_> for GeneratedVisitor {
18759 type Value = GeneratedField;
18760
18761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18762 write!(formatter, "expected one of: {:?}", &FIELDS)
18763 }
18764
18765 #[allow(unused_variables)]
18766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18767 where
18768 E: serde::de::Error,
18769 {
18770 match value {
18771 "fixed" => Ok(GeneratedField::Fixed),
18772 "auto" => Ok(GeneratedField::Auto),
18773 "custom" => Ok(GeneratedField::Custom),
18774 "adaptive" => Ok(GeneratedField::Adaptive),
18775 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18776 }
18777 }
18778 }
18779 deserializer.deserialize_identifier(GeneratedVisitor)
18780 }
18781 }
18782 struct GeneratedVisitor;
18783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18784 type Value = TableParallelism;
18785
18786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18787 formatter.write_str("struct meta.TableParallelism")
18788 }
18789
18790 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
18791 where
18792 V: serde::de::MapAccess<'de>,
18793 {
18794 let mut parallelism__ = None;
18795 while let Some(k) = map_.next_key()? {
18796 match k {
18797 GeneratedField::Fixed => {
18798 if parallelism__.is_some() {
18799 return Err(serde::de::Error::duplicate_field("fixed"));
18800 }
18801 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
18802;
18803 }
18804 GeneratedField::Auto => {
18805 if parallelism__.is_some() {
18806 return Err(serde::de::Error::duplicate_field("auto"));
18807 }
18808 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
18809;
18810 }
18811 GeneratedField::Custom => {
18812 if parallelism__.is_some() {
18813 return Err(serde::de::Error::duplicate_field("custom"));
18814 }
18815 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
18816;
18817 }
18818 GeneratedField::Adaptive => {
18819 if parallelism__.is_some() {
18820 return Err(serde::de::Error::duplicate_field("adaptive"));
18821 }
18822 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
18823;
18824 }
18825 }
18826 }
18827 Ok(TableParallelism {
18828 parallelism: parallelism__,
18829 })
18830 }
18831 }
18832 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
18833 }
18834}
18835impl serde::Serialize for table_parallelism::AdaptiveParallelism {
18836 #[allow(deprecated)]
18837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18838 where
18839 S: serde::Serializer,
18840 {
18841 use serde::ser::SerializeStruct;
18842 let len = 0;
18843 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
18844 struct_ser.end()
18845 }
18846}
18847impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
18848 #[allow(deprecated)]
18849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18850 where
18851 D: serde::Deserializer<'de>,
18852 {
18853 const FIELDS: &[&str] = &[
18854 ];
18855
18856 #[allow(clippy::enum_variant_names)]
18857 enum GeneratedField {
18858 }
18859 impl<'de> serde::Deserialize<'de> for GeneratedField {
18860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18861 where
18862 D: serde::Deserializer<'de>,
18863 {
18864 struct GeneratedVisitor;
18865
18866 impl serde::de::Visitor<'_> for GeneratedVisitor {
18867 type Value = GeneratedField;
18868
18869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18870 write!(formatter, "expected one of: {:?}", &FIELDS)
18871 }
18872
18873 #[allow(unused_variables)]
18874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18875 where
18876 E: serde::de::Error,
18877 {
18878 Err(serde::de::Error::unknown_field(value, FIELDS))
18879 }
18880 }
18881 deserializer.deserialize_identifier(GeneratedVisitor)
18882 }
18883 }
18884 struct GeneratedVisitor;
18885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18886 type Value = table_parallelism::AdaptiveParallelism;
18887
18888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18889 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
18890 }
18891
18892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
18893 where
18894 V: serde::de::MapAccess<'de>,
18895 {
18896 while map_.next_key::<GeneratedField>()?.is_some() {
18897 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18898 }
18899 Ok(table_parallelism::AdaptiveParallelism {
18900 })
18901 }
18902 }
18903 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
18904 }
18905}
18906impl serde::Serialize for table_parallelism::AutoParallelism {
18907 #[allow(deprecated)]
18908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18909 where
18910 S: serde::Serializer,
18911 {
18912 use serde::ser::SerializeStruct;
18913 let len = 0;
18914 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
18915 struct_ser.end()
18916 }
18917}
18918impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
18919 #[allow(deprecated)]
18920 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18921 where
18922 D: serde::Deserializer<'de>,
18923 {
18924 const FIELDS: &[&str] = &[
18925 ];
18926
18927 #[allow(clippy::enum_variant_names)]
18928 enum GeneratedField {
18929 }
18930 impl<'de> serde::Deserialize<'de> for GeneratedField {
18931 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18932 where
18933 D: serde::Deserializer<'de>,
18934 {
18935 struct GeneratedVisitor;
18936
18937 impl serde::de::Visitor<'_> for GeneratedVisitor {
18938 type Value = GeneratedField;
18939
18940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18941 write!(formatter, "expected one of: {:?}", &FIELDS)
18942 }
18943
18944 #[allow(unused_variables)]
18945 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18946 where
18947 E: serde::de::Error,
18948 {
18949 Err(serde::de::Error::unknown_field(value, FIELDS))
18950 }
18951 }
18952 deserializer.deserialize_identifier(GeneratedVisitor)
18953 }
18954 }
18955 struct GeneratedVisitor;
18956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18957 type Value = table_parallelism::AutoParallelism;
18958
18959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18960 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
18961 }
18962
18963 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
18964 where
18965 V: serde::de::MapAccess<'de>,
18966 {
18967 while map_.next_key::<GeneratedField>()?.is_some() {
18968 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18969 }
18970 Ok(table_parallelism::AutoParallelism {
18971 })
18972 }
18973 }
18974 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
18975 }
18976}
18977impl serde::Serialize for table_parallelism::CustomParallelism {
18978 #[allow(deprecated)]
18979 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18980 where
18981 S: serde::Serializer,
18982 {
18983 use serde::ser::SerializeStruct;
18984 let len = 0;
18985 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
18986 struct_ser.end()
18987 }
18988}
18989impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
18990 #[allow(deprecated)]
18991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18992 where
18993 D: serde::Deserializer<'de>,
18994 {
18995 const FIELDS: &[&str] = &[
18996 ];
18997
18998 #[allow(clippy::enum_variant_names)]
18999 enum GeneratedField {
19000 }
19001 impl<'de> serde::Deserialize<'de> for GeneratedField {
19002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19003 where
19004 D: serde::Deserializer<'de>,
19005 {
19006 struct GeneratedVisitor;
19007
19008 impl serde::de::Visitor<'_> for GeneratedVisitor {
19009 type Value = GeneratedField;
19010
19011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19012 write!(formatter, "expected one of: {:?}", &FIELDS)
19013 }
19014
19015 #[allow(unused_variables)]
19016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19017 where
19018 E: serde::de::Error,
19019 {
19020 Err(serde::de::Error::unknown_field(value, FIELDS))
19021 }
19022 }
19023 deserializer.deserialize_identifier(GeneratedVisitor)
19024 }
19025 }
19026 struct GeneratedVisitor;
19027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19028 type Value = table_parallelism::CustomParallelism;
19029
19030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19031 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
19032 }
19033
19034 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
19035 where
19036 V: serde::de::MapAccess<'de>,
19037 {
19038 while map_.next_key::<GeneratedField>()?.is_some() {
19039 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19040 }
19041 Ok(table_parallelism::CustomParallelism {
19042 })
19043 }
19044 }
19045 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
19046 }
19047}
19048impl serde::Serialize for table_parallelism::FixedParallelism {
19049 #[allow(deprecated)]
19050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19051 where
19052 S: serde::Serializer,
19053 {
19054 use serde::ser::SerializeStruct;
19055 let mut len = 0;
19056 if self.parallelism != 0 {
19057 len += 1;
19058 }
19059 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
19060 if self.parallelism != 0 {
19061 struct_ser.serialize_field("parallelism", &self.parallelism)?;
19062 }
19063 struct_ser.end()
19064 }
19065}
19066impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
19067 #[allow(deprecated)]
19068 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19069 where
19070 D: serde::Deserializer<'de>,
19071 {
19072 const FIELDS: &[&str] = &[
19073 "parallelism",
19074 ];
19075
19076 #[allow(clippy::enum_variant_names)]
19077 enum GeneratedField {
19078 Parallelism,
19079 }
19080 impl<'de> serde::Deserialize<'de> for GeneratedField {
19081 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19082 where
19083 D: serde::Deserializer<'de>,
19084 {
19085 struct GeneratedVisitor;
19086
19087 impl serde::de::Visitor<'_> for GeneratedVisitor {
19088 type Value = GeneratedField;
19089
19090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19091 write!(formatter, "expected one of: {:?}", &FIELDS)
19092 }
19093
19094 #[allow(unused_variables)]
19095 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19096 where
19097 E: serde::de::Error,
19098 {
19099 match value {
19100 "parallelism" => Ok(GeneratedField::Parallelism),
19101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19102 }
19103 }
19104 }
19105 deserializer.deserialize_identifier(GeneratedVisitor)
19106 }
19107 }
19108 struct GeneratedVisitor;
19109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19110 type Value = table_parallelism::FixedParallelism;
19111
19112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19113 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
19114 }
19115
19116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
19117 where
19118 V: serde::de::MapAccess<'de>,
19119 {
19120 let mut parallelism__ = None;
19121 while let Some(k) = map_.next_key()? {
19122 match k {
19123 GeneratedField::Parallelism => {
19124 if parallelism__.is_some() {
19125 return Err(serde::de::Error::duplicate_field("parallelism"));
19126 }
19127 parallelism__ =
19128 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19129 ;
19130 }
19131 }
19132 }
19133 Ok(table_parallelism::FixedParallelism {
19134 parallelism: parallelism__.unwrap_or_default(),
19135 })
19136 }
19137 }
19138 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
19139 }
19140}
19141impl serde::Serialize for TelemetryInfoResponse {
19142 #[allow(deprecated)]
19143 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19144 where
19145 S: serde::Serializer,
19146 {
19147 use serde::ser::SerializeStruct;
19148 let mut len = 0;
19149 if self.tracking_id.is_some() {
19150 len += 1;
19151 }
19152 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
19153 if let Some(v) = self.tracking_id.as_ref() {
19154 struct_ser.serialize_field("trackingId", v)?;
19155 }
19156 struct_ser.end()
19157 }
19158}
19159impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
19160 #[allow(deprecated)]
19161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19162 where
19163 D: serde::Deserializer<'de>,
19164 {
19165 const FIELDS: &[&str] = &[
19166 "tracking_id",
19167 "trackingId",
19168 ];
19169
19170 #[allow(clippy::enum_variant_names)]
19171 enum GeneratedField {
19172 TrackingId,
19173 }
19174 impl<'de> serde::Deserialize<'de> for GeneratedField {
19175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19176 where
19177 D: serde::Deserializer<'de>,
19178 {
19179 struct GeneratedVisitor;
19180
19181 impl serde::de::Visitor<'_> for GeneratedVisitor {
19182 type Value = GeneratedField;
19183
19184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19185 write!(formatter, "expected one of: {:?}", &FIELDS)
19186 }
19187
19188 #[allow(unused_variables)]
19189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19190 where
19191 E: serde::de::Error,
19192 {
19193 match value {
19194 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
19195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19196 }
19197 }
19198 }
19199 deserializer.deserialize_identifier(GeneratedVisitor)
19200 }
19201 }
19202 struct GeneratedVisitor;
19203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19204 type Value = TelemetryInfoResponse;
19205
19206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19207 formatter.write_str("struct meta.TelemetryInfoResponse")
19208 }
19209
19210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
19211 where
19212 V: serde::de::MapAccess<'de>,
19213 {
19214 let mut tracking_id__ = None;
19215 while let Some(k) = map_.next_key()? {
19216 match k {
19217 GeneratedField::TrackingId => {
19218 if tracking_id__.is_some() {
19219 return Err(serde::de::Error::duplicate_field("trackingId"));
19220 }
19221 tracking_id__ = map_.next_value()?;
19222 }
19223 }
19224 }
19225 Ok(TelemetryInfoResponse {
19226 tracking_id: tracking_id__,
19227 })
19228 }
19229 }
19230 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
19231 }
19232}
19233impl serde::Serialize for ThrottleTarget {
19234 #[allow(deprecated)]
19235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19236 where
19237 S: serde::Serializer,
19238 {
19239 let variant = match self {
19240 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
19241 Self::Source => "SOURCE",
19242 Self::Mv => "MV",
19243 Self::Table => "TABLE",
19244 Self::Sink => "SINK",
19245 Self::Fragment => "FRAGMENT",
19246 };
19247 serializer.serialize_str(variant)
19248 }
19249}
19250impl<'de> serde::Deserialize<'de> for ThrottleTarget {
19251 #[allow(deprecated)]
19252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19253 where
19254 D: serde::Deserializer<'de>,
19255 {
19256 const FIELDS: &[&str] = &[
19257 "THROTTLE_TARGET_UNSPECIFIED",
19258 "SOURCE",
19259 "MV",
19260 "TABLE",
19261 "SINK",
19262 "FRAGMENT",
19263 ];
19264
19265 struct GeneratedVisitor;
19266
19267 impl serde::de::Visitor<'_> for GeneratedVisitor {
19268 type Value = ThrottleTarget;
19269
19270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19271 write!(formatter, "expected one of: {:?}", &FIELDS)
19272 }
19273
19274 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19275 where
19276 E: serde::de::Error,
19277 {
19278 i32::try_from(v)
19279 .ok()
19280 .and_then(|x| x.try_into().ok())
19281 .ok_or_else(|| {
19282 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19283 })
19284 }
19285
19286 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19287 where
19288 E: serde::de::Error,
19289 {
19290 i32::try_from(v)
19291 .ok()
19292 .and_then(|x| x.try_into().ok())
19293 .ok_or_else(|| {
19294 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19295 })
19296 }
19297
19298 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19299 where
19300 E: serde::de::Error,
19301 {
19302 match value {
19303 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
19304 "SOURCE" => Ok(ThrottleTarget::Source),
19305 "MV" => Ok(ThrottleTarget::Mv),
19306 "TABLE" => Ok(ThrottleTarget::Table),
19307 "SINK" => Ok(ThrottleTarget::Sink),
19308 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
19309 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19310 }
19311 }
19312 }
19313 deserializer.deserialize_any(GeneratedVisitor)
19314 }
19315}
19316impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
19317 #[allow(deprecated)]
19318 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19319 where
19320 S: serde::Serializer,
19321 {
19322 use serde::ser::SerializeStruct;
19323 let mut len = 0;
19324 if self.id != 0 {
19325 len += 1;
19326 }
19327 if !self.node_label.is_empty() {
19328 len += 1;
19329 }
19330 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
19331 if self.id != 0 {
19332 struct_ser.serialize_field("id", &self.id)?;
19333 }
19334 if !self.node_label.is_empty() {
19335 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
19336 }
19337 struct_ser.end()
19338 }
19339}
19340impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
19341 #[allow(deprecated)]
19342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19343 where
19344 D: serde::Deserializer<'de>,
19345 {
19346 const FIELDS: &[&str] = &[
19347 "id",
19348 "node_label",
19349 "nodeLabel",
19350 ];
19351
19352 #[allow(clippy::enum_variant_names)]
19353 enum GeneratedField {
19354 Id,
19355 NodeLabel,
19356 }
19357 impl<'de> serde::Deserialize<'de> for GeneratedField {
19358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19359 where
19360 D: serde::Deserializer<'de>,
19361 {
19362 struct GeneratedVisitor;
19363
19364 impl serde::de::Visitor<'_> for GeneratedVisitor {
19365 type Value = GeneratedField;
19366
19367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19368 write!(formatter, "expected one of: {:?}", &FIELDS)
19369 }
19370
19371 #[allow(unused_variables)]
19372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19373 where
19374 E: serde::de::Error,
19375 {
19376 match value {
19377 "id" => Ok(GeneratedField::Id),
19378 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
19379 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19380 }
19381 }
19382 }
19383 deserializer.deserialize_identifier(GeneratedVisitor)
19384 }
19385 }
19386 struct GeneratedVisitor;
19387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19388 type Value = UpdateStreamingJobNodeLabelsRequest;
19389
19390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19391 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
19392 }
19393
19394 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
19395 where
19396 V: serde::de::MapAccess<'de>,
19397 {
19398 let mut id__ = None;
19399 let mut node_label__ = None;
19400 while let Some(k) = map_.next_key()? {
19401 match k {
19402 GeneratedField::Id => {
19403 if id__.is_some() {
19404 return Err(serde::de::Error::duplicate_field("id"));
19405 }
19406 id__ =
19407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19408 ;
19409 }
19410 GeneratedField::NodeLabel => {
19411 if node_label__.is_some() {
19412 return Err(serde::de::Error::duplicate_field("nodeLabel"));
19413 }
19414 node_label__ = Some(map_.next_value()?);
19415 }
19416 }
19417 }
19418 Ok(UpdateStreamingJobNodeLabelsRequest {
19419 id: id__.unwrap_or_default(),
19420 node_label: node_label__.unwrap_or_default(),
19421 })
19422 }
19423 }
19424 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
19425 }
19426}
19427impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
19428 #[allow(deprecated)]
19429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19430 where
19431 S: serde::Serializer,
19432 {
19433 use serde::ser::SerializeStruct;
19434 let len = 0;
19435 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
19436 struct_ser.end()
19437 }
19438}
19439impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
19440 #[allow(deprecated)]
19441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19442 where
19443 D: serde::Deserializer<'de>,
19444 {
19445 const FIELDS: &[&str] = &[
19446 ];
19447
19448 #[allow(clippy::enum_variant_names)]
19449 enum GeneratedField {
19450 }
19451 impl<'de> serde::Deserialize<'de> for GeneratedField {
19452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19453 where
19454 D: serde::Deserializer<'de>,
19455 {
19456 struct GeneratedVisitor;
19457
19458 impl serde::de::Visitor<'_> for GeneratedVisitor {
19459 type Value = GeneratedField;
19460
19461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19462 write!(formatter, "expected one of: {:?}", &FIELDS)
19463 }
19464
19465 #[allow(unused_variables)]
19466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19467 where
19468 E: serde::de::Error,
19469 {
19470 Err(serde::de::Error::unknown_field(value, FIELDS))
19471 }
19472 }
19473 deserializer.deserialize_identifier(GeneratedVisitor)
19474 }
19475 }
19476 struct GeneratedVisitor;
19477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19478 type Value = UpdateStreamingJobNodeLabelsResponse;
19479
19480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19481 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
19482 }
19483
19484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
19485 where
19486 V: serde::de::MapAccess<'de>,
19487 {
19488 while map_.next_key::<GeneratedField>()?.is_some() {
19489 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19490 }
19491 Ok(UpdateStreamingJobNodeLabelsResponse {
19492 })
19493 }
19494 }
19495 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
19496 }
19497}
19498impl serde::Serialize for WorkerReschedule {
19499 #[allow(deprecated)]
19500 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19501 where
19502 S: serde::Serializer,
19503 {
19504 use serde::ser::SerializeStruct;
19505 let mut len = 0;
19506 if !self.worker_actor_diff.is_empty() {
19507 len += 1;
19508 }
19509 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
19510 if !self.worker_actor_diff.is_empty() {
19511 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
19512 }
19513 struct_ser.end()
19514 }
19515}
19516impl<'de> serde::Deserialize<'de> for WorkerReschedule {
19517 #[allow(deprecated)]
19518 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19519 where
19520 D: serde::Deserializer<'de>,
19521 {
19522 const FIELDS: &[&str] = &[
19523 "worker_actor_diff",
19524 "workerActorDiff",
19525 ];
19526
19527 #[allow(clippy::enum_variant_names)]
19528 enum GeneratedField {
19529 WorkerActorDiff,
19530 }
19531 impl<'de> serde::Deserialize<'de> for GeneratedField {
19532 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19533 where
19534 D: serde::Deserializer<'de>,
19535 {
19536 struct GeneratedVisitor;
19537
19538 impl serde::de::Visitor<'_> for GeneratedVisitor {
19539 type Value = GeneratedField;
19540
19541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19542 write!(formatter, "expected one of: {:?}", &FIELDS)
19543 }
19544
19545 #[allow(unused_variables)]
19546 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19547 where
19548 E: serde::de::Error,
19549 {
19550 match value {
19551 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
19552 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19553 }
19554 }
19555 }
19556 deserializer.deserialize_identifier(GeneratedVisitor)
19557 }
19558 }
19559 struct GeneratedVisitor;
19560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19561 type Value = WorkerReschedule;
19562
19563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19564 formatter.write_str("struct meta.WorkerReschedule")
19565 }
19566
19567 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
19568 where
19569 V: serde::de::MapAccess<'de>,
19570 {
19571 let mut worker_actor_diff__ = None;
19572 while let Some(k) = map_.next_key()? {
19573 match k {
19574 GeneratedField::WorkerActorDiff => {
19575 if worker_actor_diff__.is_some() {
19576 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
19577 }
19578 worker_actor_diff__ = Some(
19579 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
19580 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
19581 );
19582 }
19583 }
19584 }
19585 Ok(WorkerReschedule {
19586 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
19587 })
19588 }
19589 }
19590 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
19591 }
19592}