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 ListIcebergTablesRequest {
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.ListIcebergTablesRequest", len)?;
10527 struct_ser.end()
10528 }
10529}
10530impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
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 = ListIcebergTablesRequest;
10570
10571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10572 formatter.write_str("struct meta.ListIcebergTablesRequest")
10573 }
10574
10575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, 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(ListIcebergTablesRequest {
10583 })
10584 }
10585 }
10586 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
10587 }
10588}
10589impl serde::Serialize for ListIcebergTablesResponse {
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.iceberg_tables.is_empty() {
10598 len += 1;
10599 }
10600 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
10601 if !self.iceberg_tables.is_empty() {
10602 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
10603 }
10604 struct_ser.end()
10605 }
10606}
10607impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
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 "iceberg_tables",
10615 "icebergTables",
10616 ];
10617
10618 #[allow(clippy::enum_variant_names)]
10619 enum GeneratedField {
10620 IcebergTables,
10621 }
10622 impl<'de> serde::Deserialize<'de> for GeneratedField {
10623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10624 where
10625 D: serde::Deserializer<'de>,
10626 {
10627 struct GeneratedVisitor;
10628
10629 impl serde::de::Visitor<'_> for GeneratedVisitor {
10630 type Value = GeneratedField;
10631
10632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10633 write!(formatter, "expected one of: {:?}", &FIELDS)
10634 }
10635
10636 #[allow(unused_variables)]
10637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10638 where
10639 E: serde::de::Error,
10640 {
10641 match value {
10642 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
10643 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10644 }
10645 }
10646 }
10647 deserializer.deserialize_identifier(GeneratedVisitor)
10648 }
10649 }
10650 struct GeneratedVisitor;
10651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10652 type Value = ListIcebergTablesResponse;
10653
10654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10655 formatter.write_str("struct meta.ListIcebergTablesResponse")
10656 }
10657
10658 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
10659 where
10660 V: serde::de::MapAccess<'de>,
10661 {
10662 let mut iceberg_tables__ = None;
10663 while let Some(k) = map_.next_key()? {
10664 match k {
10665 GeneratedField::IcebergTables => {
10666 if iceberg_tables__.is_some() {
10667 return Err(serde::de::Error::duplicate_field("icebergTables"));
10668 }
10669 iceberg_tables__ = Some(map_.next_value()?);
10670 }
10671 }
10672 }
10673 Ok(ListIcebergTablesResponse {
10674 iceberg_tables: iceberg_tables__.unwrap_or_default(),
10675 })
10676 }
10677 }
10678 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
10679 }
10680}
10681impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
10682 #[allow(deprecated)]
10683 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10684 where
10685 S: serde::Serializer,
10686 {
10687 use serde::ser::SerializeStruct;
10688 let mut len = 0;
10689 if !self.catalog_name.is_empty() {
10690 len += 1;
10691 }
10692 if !self.table_namespace.is_empty() {
10693 len += 1;
10694 }
10695 if !self.table_name.is_empty() {
10696 len += 1;
10697 }
10698 if self.metadata_location.is_some() {
10699 len += 1;
10700 }
10701 if self.previous_metadata_location.is_some() {
10702 len += 1;
10703 }
10704 if self.iceberg_type.is_some() {
10705 len += 1;
10706 }
10707 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
10708 if !self.catalog_name.is_empty() {
10709 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
10710 }
10711 if !self.table_namespace.is_empty() {
10712 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
10713 }
10714 if !self.table_name.is_empty() {
10715 struct_ser.serialize_field("tableName", &self.table_name)?;
10716 }
10717 if let Some(v) = self.metadata_location.as_ref() {
10718 struct_ser.serialize_field("metadataLocation", v)?;
10719 }
10720 if let Some(v) = self.previous_metadata_location.as_ref() {
10721 struct_ser.serialize_field("previousMetadataLocation", v)?;
10722 }
10723 if let Some(v) = self.iceberg_type.as_ref() {
10724 struct_ser.serialize_field("icebergType", v)?;
10725 }
10726 struct_ser.end()
10727 }
10728}
10729impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
10730 #[allow(deprecated)]
10731 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10732 where
10733 D: serde::Deserializer<'de>,
10734 {
10735 const FIELDS: &[&str] = &[
10736 "catalog_name",
10737 "catalogName",
10738 "table_namespace",
10739 "tableNamespace",
10740 "table_name",
10741 "tableName",
10742 "metadata_location",
10743 "metadataLocation",
10744 "previous_metadata_location",
10745 "previousMetadataLocation",
10746 "iceberg_type",
10747 "icebergType",
10748 ];
10749
10750 #[allow(clippy::enum_variant_names)]
10751 enum GeneratedField {
10752 CatalogName,
10753 TableNamespace,
10754 TableName,
10755 MetadataLocation,
10756 PreviousMetadataLocation,
10757 IcebergType,
10758 }
10759 impl<'de> serde::Deserialize<'de> for GeneratedField {
10760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10761 where
10762 D: serde::Deserializer<'de>,
10763 {
10764 struct GeneratedVisitor;
10765
10766 impl serde::de::Visitor<'_> for GeneratedVisitor {
10767 type Value = GeneratedField;
10768
10769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10770 write!(formatter, "expected one of: {:?}", &FIELDS)
10771 }
10772
10773 #[allow(unused_variables)]
10774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10775 where
10776 E: serde::de::Error,
10777 {
10778 match value {
10779 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
10780 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
10781 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10782 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
10783 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
10784 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
10785 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10786 }
10787 }
10788 }
10789 deserializer.deserialize_identifier(GeneratedVisitor)
10790 }
10791 }
10792 struct GeneratedVisitor;
10793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10794 type Value = list_iceberg_tables_response::IcebergTable;
10795
10796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10797 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
10798 }
10799
10800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
10801 where
10802 V: serde::de::MapAccess<'de>,
10803 {
10804 let mut catalog_name__ = None;
10805 let mut table_namespace__ = None;
10806 let mut table_name__ = None;
10807 let mut metadata_location__ = None;
10808 let mut previous_metadata_location__ = None;
10809 let mut iceberg_type__ = None;
10810 while let Some(k) = map_.next_key()? {
10811 match k {
10812 GeneratedField::CatalogName => {
10813 if catalog_name__.is_some() {
10814 return Err(serde::de::Error::duplicate_field("catalogName"));
10815 }
10816 catalog_name__ = Some(map_.next_value()?);
10817 }
10818 GeneratedField::TableNamespace => {
10819 if table_namespace__.is_some() {
10820 return Err(serde::de::Error::duplicate_field("tableNamespace"));
10821 }
10822 table_namespace__ = Some(map_.next_value()?);
10823 }
10824 GeneratedField::TableName => {
10825 if table_name__.is_some() {
10826 return Err(serde::de::Error::duplicate_field("tableName"));
10827 }
10828 table_name__ = Some(map_.next_value()?);
10829 }
10830 GeneratedField::MetadataLocation => {
10831 if metadata_location__.is_some() {
10832 return Err(serde::de::Error::duplicate_field("metadataLocation"));
10833 }
10834 metadata_location__ = map_.next_value()?;
10835 }
10836 GeneratedField::PreviousMetadataLocation => {
10837 if previous_metadata_location__.is_some() {
10838 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
10839 }
10840 previous_metadata_location__ = map_.next_value()?;
10841 }
10842 GeneratedField::IcebergType => {
10843 if iceberg_type__.is_some() {
10844 return Err(serde::de::Error::duplicate_field("icebergType"));
10845 }
10846 iceberg_type__ = map_.next_value()?;
10847 }
10848 }
10849 }
10850 Ok(list_iceberg_tables_response::IcebergTable {
10851 catalog_name: catalog_name__.unwrap_or_default(),
10852 table_namespace: table_namespace__.unwrap_or_default(),
10853 table_name: table_name__.unwrap_or_default(),
10854 metadata_location: metadata_location__,
10855 previous_metadata_location: previous_metadata_location__,
10856 iceberg_type: iceberg_type__,
10857 })
10858 }
10859 }
10860 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
10861 }
10862}
10863impl serde::Serialize for ListRateLimitsRequest {
10864 #[allow(deprecated)]
10865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10866 where
10867 S: serde::Serializer,
10868 {
10869 use serde::ser::SerializeStruct;
10870 let len = 0;
10871 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10872 struct_ser.end()
10873 }
10874}
10875impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10876 #[allow(deprecated)]
10877 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10878 where
10879 D: serde::Deserializer<'de>,
10880 {
10881 const FIELDS: &[&str] = &[
10882 ];
10883
10884 #[allow(clippy::enum_variant_names)]
10885 enum GeneratedField {
10886 }
10887 impl<'de> serde::Deserialize<'de> for GeneratedField {
10888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10889 where
10890 D: serde::Deserializer<'de>,
10891 {
10892 struct GeneratedVisitor;
10893
10894 impl serde::de::Visitor<'_> for GeneratedVisitor {
10895 type Value = GeneratedField;
10896
10897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10898 write!(formatter, "expected one of: {:?}", &FIELDS)
10899 }
10900
10901 #[allow(unused_variables)]
10902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10903 where
10904 E: serde::de::Error,
10905 {
10906 Err(serde::de::Error::unknown_field(value, FIELDS))
10907 }
10908 }
10909 deserializer.deserialize_identifier(GeneratedVisitor)
10910 }
10911 }
10912 struct GeneratedVisitor;
10913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10914 type Value = ListRateLimitsRequest;
10915
10916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10917 formatter.write_str("struct meta.ListRateLimitsRequest")
10918 }
10919
10920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10921 where
10922 V: serde::de::MapAccess<'de>,
10923 {
10924 while map_.next_key::<GeneratedField>()?.is_some() {
10925 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10926 }
10927 Ok(ListRateLimitsRequest {
10928 })
10929 }
10930 }
10931 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10932 }
10933}
10934impl serde::Serialize for ListRateLimitsResponse {
10935 #[allow(deprecated)]
10936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10937 where
10938 S: serde::Serializer,
10939 {
10940 use serde::ser::SerializeStruct;
10941 let mut len = 0;
10942 if !self.rate_limits.is_empty() {
10943 len += 1;
10944 }
10945 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10946 if !self.rate_limits.is_empty() {
10947 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10948 }
10949 struct_ser.end()
10950 }
10951}
10952impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10953 #[allow(deprecated)]
10954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10955 where
10956 D: serde::Deserializer<'de>,
10957 {
10958 const FIELDS: &[&str] = &[
10959 "rate_limits",
10960 "rateLimits",
10961 ];
10962
10963 #[allow(clippy::enum_variant_names)]
10964 enum GeneratedField {
10965 RateLimits,
10966 }
10967 impl<'de> serde::Deserialize<'de> for GeneratedField {
10968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10969 where
10970 D: serde::Deserializer<'de>,
10971 {
10972 struct GeneratedVisitor;
10973
10974 impl serde::de::Visitor<'_> for GeneratedVisitor {
10975 type Value = GeneratedField;
10976
10977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10978 write!(formatter, "expected one of: {:?}", &FIELDS)
10979 }
10980
10981 #[allow(unused_variables)]
10982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10983 where
10984 E: serde::de::Error,
10985 {
10986 match value {
10987 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10989 }
10990 }
10991 }
10992 deserializer.deserialize_identifier(GeneratedVisitor)
10993 }
10994 }
10995 struct GeneratedVisitor;
10996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10997 type Value = ListRateLimitsResponse;
10998
10999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11000 formatter.write_str("struct meta.ListRateLimitsResponse")
11001 }
11002
11003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
11004 where
11005 V: serde::de::MapAccess<'de>,
11006 {
11007 let mut rate_limits__ = None;
11008 while let Some(k) = map_.next_key()? {
11009 match k {
11010 GeneratedField::RateLimits => {
11011 if rate_limits__.is_some() {
11012 return Err(serde::de::Error::duplicate_field("rateLimits"));
11013 }
11014 rate_limits__ = Some(map_.next_value()?);
11015 }
11016 }
11017 }
11018 Ok(ListRateLimitsResponse {
11019 rate_limits: rate_limits__.unwrap_or_default(),
11020 })
11021 }
11022 }
11023 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
11024 }
11025}
11026impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
11027 #[allow(deprecated)]
11028 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11029 where
11030 S: serde::Serializer,
11031 {
11032 use serde::ser::SerializeStruct;
11033 let mut len = 0;
11034 if self.fragment_id != 0 {
11035 len += 1;
11036 }
11037 if self.job_id != 0 {
11038 len += 1;
11039 }
11040 if self.fragment_type_mask != 0 {
11041 len += 1;
11042 }
11043 if self.rate_limit != 0 {
11044 len += 1;
11045 }
11046 if !self.node_name.is_empty() {
11047 len += 1;
11048 }
11049 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
11050 if self.fragment_id != 0 {
11051 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11052 }
11053 if self.job_id != 0 {
11054 struct_ser.serialize_field("jobId", &self.job_id)?;
11055 }
11056 if self.fragment_type_mask != 0 {
11057 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11058 }
11059 if self.rate_limit != 0 {
11060 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
11061 }
11062 if !self.node_name.is_empty() {
11063 struct_ser.serialize_field("nodeName", &self.node_name)?;
11064 }
11065 struct_ser.end()
11066 }
11067}
11068impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
11069 #[allow(deprecated)]
11070 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11071 where
11072 D: serde::Deserializer<'de>,
11073 {
11074 const FIELDS: &[&str] = &[
11075 "fragment_id",
11076 "fragmentId",
11077 "job_id",
11078 "jobId",
11079 "fragment_type_mask",
11080 "fragmentTypeMask",
11081 "rate_limit",
11082 "rateLimit",
11083 "node_name",
11084 "nodeName",
11085 ];
11086
11087 #[allow(clippy::enum_variant_names)]
11088 enum GeneratedField {
11089 FragmentId,
11090 JobId,
11091 FragmentTypeMask,
11092 RateLimit,
11093 NodeName,
11094 }
11095 impl<'de> serde::Deserialize<'de> for GeneratedField {
11096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11097 where
11098 D: serde::Deserializer<'de>,
11099 {
11100 struct GeneratedVisitor;
11101
11102 impl serde::de::Visitor<'_> for GeneratedVisitor {
11103 type Value = GeneratedField;
11104
11105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11106 write!(formatter, "expected one of: {:?}", &FIELDS)
11107 }
11108
11109 #[allow(unused_variables)]
11110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11111 where
11112 E: serde::de::Error,
11113 {
11114 match value {
11115 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11116 "jobId" | "job_id" => Ok(GeneratedField::JobId),
11117 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11118 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11119 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
11120 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11121 }
11122 }
11123 }
11124 deserializer.deserialize_identifier(GeneratedVisitor)
11125 }
11126 }
11127 struct GeneratedVisitor;
11128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11129 type Value = list_rate_limits_response::RateLimitInfo;
11130
11131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11132 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
11133 }
11134
11135 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
11136 where
11137 V: serde::de::MapAccess<'de>,
11138 {
11139 let mut fragment_id__ = None;
11140 let mut job_id__ = None;
11141 let mut fragment_type_mask__ = None;
11142 let mut rate_limit__ = None;
11143 let mut node_name__ = None;
11144 while let Some(k) = map_.next_key()? {
11145 match k {
11146 GeneratedField::FragmentId => {
11147 if fragment_id__.is_some() {
11148 return Err(serde::de::Error::duplicate_field("fragmentId"));
11149 }
11150 fragment_id__ =
11151 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11152 ;
11153 }
11154 GeneratedField::JobId => {
11155 if job_id__.is_some() {
11156 return Err(serde::de::Error::duplicate_field("jobId"));
11157 }
11158 job_id__ =
11159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11160 ;
11161 }
11162 GeneratedField::FragmentTypeMask => {
11163 if fragment_type_mask__.is_some() {
11164 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11165 }
11166 fragment_type_mask__ =
11167 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11168 ;
11169 }
11170 GeneratedField::RateLimit => {
11171 if rate_limit__.is_some() {
11172 return Err(serde::de::Error::duplicate_field("rateLimit"));
11173 }
11174 rate_limit__ =
11175 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11176 ;
11177 }
11178 GeneratedField::NodeName => {
11179 if node_name__.is_some() {
11180 return Err(serde::de::Error::duplicate_field("nodeName"));
11181 }
11182 node_name__ = Some(map_.next_value()?);
11183 }
11184 }
11185 }
11186 Ok(list_rate_limits_response::RateLimitInfo {
11187 fragment_id: fragment_id__.unwrap_or_default(),
11188 job_id: job_id__.unwrap_or_default(),
11189 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11190 rate_limit: rate_limit__.unwrap_or_default(),
11191 node_name: node_name__.unwrap_or_default(),
11192 })
11193 }
11194 }
11195 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
11196 }
11197}
11198impl serde::Serialize for ListRefreshTableStatesRequest {
11199 #[allow(deprecated)]
11200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11201 where
11202 S: serde::Serializer,
11203 {
11204 use serde::ser::SerializeStruct;
11205 let len = 0;
11206 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
11207 struct_ser.end()
11208 }
11209}
11210impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11211 #[allow(deprecated)]
11212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11213 where
11214 D: serde::Deserializer<'de>,
11215 {
11216 const FIELDS: &[&str] = &[
11217 ];
11218
11219 #[allow(clippy::enum_variant_names)]
11220 enum GeneratedField {
11221 }
11222 impl<'de> serde::Deserialize<'de> for GeneratedField {
11223 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11224 where
11225 D: serde::Deserializer<'de>,
11226 {
11227 struct GeneratedVisitor;
11228
11229 impl serde::de::Visitor<'_> for GeneratedVisitor {
11230 type Value = GeneratedField;
11231
11232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11233 write!(formatter, "expected one of: {:?}", &FIELDS)
11234 }
11235
11236 #[allow(unused_variables)]
11237 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11238 where
11239 E: serde::de::Error,
11240 {
11241 Err(serde::de::Error::unknown_field(value, FIELDS))
11242 }
11243 }
11244 deserializer.deserialize_identifier(GeneratedVisitor)
11245 }
11246 }
11247 struct GeneratedVisitor;
11248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11249 type Value = ListRefreshTableStatesRequest;
11250
11251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11252 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11253 }
11254
11255 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11256 where
11257 V: serde::de::MapAccess<'de>,
11258 {
11259 while map_.next_key::<GeneratedField>()?.is_some() {
11260 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11261 }
11262 Ok(ListRefreshTableStatesRequest {
11263 })
11264 }
11265 }
11266 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11267 }
11268}
11269impl serde::Serialize for ListRefreshTableStatesResponse {
11270 #[allow(deprecated)]
11271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11272 where
11273 S: serde::Serializer,
11274 {
11275 use serde::ser::SerializeStruct;
11276 let mut len = 0;
11277 if !self.states.is_empty() {
11278 len += 1;
11279 }
11280 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11281 if !self.states.is_empty() {
11282 struct_ser.serialize_field("states", &self.states)?;
11283 }
11284 struct_ser.end()
11285 }
11286}
11287impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11288 #[allow(deprecated)]
11289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11290 where
11291 D: serde::Deserializer<'de>,
11292 {
11293 const FIELDS: &[&str] = &[
11294 "states",
11295 ];
11296
11297 #[allow(clippy::enum_variant_names)]
11298 enum GeneratedField {
11299 States,
11300 }
11301 impl<'de> serde::Deserialize<'de> for GeneratedField {
11302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11303 where
11304 D: serde::Deserializer<'de>,
11305 {
11306 struct GeneratedVisitor;
11307
11308 impl serde::de::Visitor<'_> for GeneratedVisitor {
11309 type Value = GeneratedField;
11310
11311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11312 write!(formatter, "expected one of: {:?}", &FIELDS)
11313 }
11314
11315 #[allow(unused_variables)]
11316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11317 where
11318 E: serde::de::Error,
11319 {
11320 match value {
11321 "states" => Ok(GeneratedField::States),
11322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11323 }
11324 }
11325 }
11326 deserializer.deserialize_identifier(GeneratedVisitor)
11327 }
11328 }
11329 struct GeneratedVisitor;
11330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11331 type Value = ListRefreshTableStatesResponse;
11332
11333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11334 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11335 }
11336
11337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11338 where
11339 V: serde::de::MapAccess<'de>,
11340 {
11341 let mut states__ = None;
11342 while let Some(k) = map_.next_key()? {
11343 match k {
11344 GeneratedField::States => {
11345 if states__.is_some() {
11346 return Err(serde::de::Error::duplicate_field("states"));
11347 }
11348 states__ = Some(map_.next_value()?);
11349 }
11350 }
11351 }
11352 Ok(ListRefreshTableStatesResponse {
11353 states: states__.unwrap_or_default(),
11354 })
11355 }
11356 }
11357 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11358 }
11359}
11360impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11361 #[allow(deprecated)]
11362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11363 where
11364 S: serde::Serializer,
11365 {
11366 use serde::ser::SerializeStruct;
11367 let mut len = 0;
11368 if self.table_id != 0 {
11369 len += 1;
11370 }
11371 if !self.current_status.is_empty() {
11372 len += 1;
11373 }
11374 if self.last_trigger_time.is_some() {
11375 len += 1;
11376 }
11377 if self.trigger_interval_secs.is_some() {
11378 len += 1;
11379 }
11380 if self.last_success_time.is_some() {
11381 len += 1;
11382 }
11383 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11384 if self.table_id != 0 {
11385 struct_ser.serialize_field("tableId", &self.table_id)?;
11386 }
11387 if !self.current_status.is_empty() {
11388 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11389 }
11390 if let Some(v) = self.last_trigger_time.as_ref() {
11391 struct_ser.serialize_field("lastTriggerTime", v)?;
11392 }
11393 if let Some(v) = self.trigger_interval_secs.as_ref() {
11394 #[allow(clippy::needless_borrow)]
11395 #[allow(clippy::needless_borrows_for_generic_args)]
11396 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11397 }
11398 if let Some(v) = self.last_success_time.as_ref() {
11399 struct_ser.serialize_field("lastSuccessTime", v)?;
11400 }
11401 struct_ser.end()
11402 }
11403}
11404impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11405 #[allow(deprecated)]
11406 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11407 where
11408 D: serde::Deserializer<'de>,
11409 {
11410 const FIELDS: &[&str] = &[
11411 "table_id",
11412 "tableId",
11413 "current_status",
11414 "currentStatus",
11415 "last_trigger_time",
11416 "lastTriggerTime",
11417 "trigger_interval_secs",
11418 "triggerIntervalSecs",
11419 "last_success_time",
11420 "lastSuccessTime",
11421 ];
11422
11423 #[allow(clippy::enum_variant_names)]
11424 enum GeneratedField {
11425 TableId,
11426 CurrentStatus,
11427 LastTriggerTime,
11428 TriggerIntervalSecs,
11429 LastSuccessTime,
11430 }
11431 impl<'de> serde::Deserialize<'de> for GeneratedField {
11432 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11433 where
11434 D: serde::Deserializer<'de>,
11435 {
11436 struct GeneratedVisitor;
11437
11438 impl serde::de::Visitor<'_> for GeneratedVisitor {
11439 type Value = GeneratedField;
11440
11441 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11442 write!(formatter, "expected one of: {:?}", &FIELDS)
11443 }
11444
11445 #[allow(unused_variables)]
11446 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11447 where
11448 E: serde::de::Error,
11449 {
11450 match value {
11451 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11452 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11453 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11454 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11455 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11457 }
11458 }
11459 }
11460 deserializer.deserialize_identifier(GeneratedVisitor)
11461 }
11462 }
11463 struct GeneratedVisitor;
11464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11465 type Value = list_refresh_table_states_response::RefreshTableState;
11466
11467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11468 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11469 }
11470
11471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11472 where
11473 V: serde::de::MapAccess<'de>,
11474 {
11475 let mut table_id__ = None;
11476 let mut current_status__ = None;
11477 let mut last_trigger_time__ = None;
11478 let mut trigger_interval_secs__ = None;
11479 let mut last_success_time__ = None;
11480 while let Some(k) = map_.next_key()? {
11481 match k {
11482 GeneratedField::TableId => {
11483 if table_id__.is_some() {
11484 return Err(serde::de::Error::duplicate_field("tableId"));
11485 }
11486 table_id__ =
11487 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11488 ;
11489 }
11490 GeneratedField::CurrentStatus => {
11491 if current_status__.is_some() {
11492 return Err(serde::de::Error::duplicate_field("currentStatus"));
11493 }
11494 current_status__ = Some(map_.next_value()?);
11495 }
11496 GeneratedField::LastTriggerTime => {
11497 if last_trigger_time__.is_some() {
11498 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11499 }
11500 last_trigger_time__ = map_.next_value()?;
11501 }
11502 GeneratedField::TriggerIntervalSecs => {
11503 if trigger_interval_secs__.is_some() {
11504 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11505 }
11506 trigger_interval_secs__ =
11507 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11508 ;
11509 }
11510 GeneratedField::LastSuccessTime => {
11511 if last_success_time__.is_some() {
11512 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11513 }
11514 last_success_time__ = map_.next_value()?;
11515 }
11516 }
11517 }
11518 Ok(list_refresh_table_states_response::RefreshTableState {
11519 table_id: table_id__.unwrap_or_default(),
11520 current_status: current_status__.unwrap_or_default(),
11521 last_trigger_time: last_trigger_time__,
11522 trigger_interval_secs: trigger_interval_secs__,
11523 last_success_time: last_success_time__,
11524 })
11525 }
11526 }
11527 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11528 }
11529}
11530impl serde::Serialize for ListSinkLogStoreTablesRequest {
11531 #[allow(deprecated)]
11532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11533 where
11534 S: serde::Serializer,
11535 {
11536 use serde::ser::SerializeStruct;
11537 let len = 0;
11538 let struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesRequest", len)?;
11539 struct_ser.end()
11540 }
11541}
11542impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesRequest {
11543 #[allow(deprecated)]
11544 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11545 where
11546 D: serde::Deserializer<'de>,
11547 {
11548 const FIELDS: &[&str] = &[
11549 ];
11550
11551 #[allow(clippy::enum_variant_names)]
11552 enum GeneratedField {
11553 }
11554 impl<'de> serde::Deserialize<'de> for GeneratedField {
11555 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11556 where
11557 D: serde::Deserializer<'de>,
11558 {
11559 struct GeneratedVisitor;
11560
11561 impl serde::de::Visitor<'_> for GeneratedVisitor {
11562 type Value = GeneratedField;
11563
11564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11565 write!(formatter, "expected one of: {:?}", &FIELDS)
11566 }
11567
11568 #[allow(unused_variables)]
11569 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11570 where
11571 E: serde::de::Error,
11572 {
11573 Err(serde::de::Error::unknown_field(value, FIELDS))
11574 }
11575 }
11576 deserializer.deserialize_identifier(GeneratedVisitor)
11577 }
11578 }
11579 struct GeneratedVisitor;
11580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11581 type Value = ListSinkLogStoreTablesRequest;
11582
11583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11584 formatter.write_str("struct meta.ListSinkLogStoreTablesRequest")
11585 }
11586
11587 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesRequest, V::Error>
11588 where
11589 V: serde::de::MapAccess<'de>,
11590 {
11591 while map_.next_key::<GeneratedField>()?.is_some() {
11592 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11593 }
11594 Ok(ListSinkLogStoreTablesRequest {
11595 })
11596 }
11597 }
11598 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesRequest", FIELDS, GeneratedVisitor)
11599 }
11600}
11601impl serde::Serialize for ListSinkLogStoreTablesResponse {
11602 #[allow(deprecated)]
11603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11604 where
11605 S: serde::Serializer,
11606 {
11607 use serde::ser::SerializeStruct;
11608 let mut len = 0;
11609 if !self.tables.is_empty() {
11610 len += 1;
11611 }
11612 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse", len)?;
11613 if !self.tables.is_empty() {
11614 struct_ser.serialize_field("tables", &self.tables)?;
11615 }
11616 struct_ser.end()
11617 }
11618}
11619impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesResponse {
11620 #[allow(deprecated)]
11621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11622 where
11623 D: serde::Deserializer<'de>,
11624 {
11625 const FIELDS: &[&str] = &[
11626 "tables",
11627 ];
11628
11629 #[allow(clippy::enum_variant_names)]
11630 enum GeneratedField {
11631 Tables,
11632 }
11633 impl<'de> serde::Deserialize<'de> for GeneratedField {
11634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11635 where
11636 D: serde::Deserializer<'de>,
11637 {
11638 struct GeneratedVisitor;
11639
11640 impl serde::de::Visitor<'_> for GeneratedVisitor {
11641 type Value = GeneratedField;
11642
11643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11644 write!(formatter, "expected one of: {:?}", &FIELDS)
11645 }
11646
11647 #[allow(unused_variables)]
11648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11649 where
11650 E: serde::de::Error,
11651 {
11652 match value {
11653 "tables" => Ok(GeneratedField::Tables),
11654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11655 }
11656 }
11657 }
11658 deserializer.deserialize_identifier(GeneratedVisitor)
11659 }
11660 }
11661 struct GeneratedVisitor;
11662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11663 type Value = ListSinkLogStoreTablesResponse;
11664
11665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11666 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse")
11667 }
11668
11669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesResponse, V::Error>
11670 where
11671 V: serde::de::MapAccess<'de>,
11672 {
11673 let mut tables__ = None;
11674 while let Some(k) = map_.next_key()? {
11675 match k {
11676 GeneratedField::Tables => {
11677 if tables__.is_some() {
11678 return Err(serde::de::Error::duplicate_field("tables"));
11679 }
11680 tables__ = Some(map_.next_value()?);
11681 }
11682 }
11683 }
11684 Ok(ListSinkLogStoreTablesResponse {
11685 tables: tables__.unwrap_or_default(),
11686 })
11687 }
11688 }
11689 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse", FIELDS, GeneratedVisitor)
11690 }
11691}
11692impl serde::Serialize for list_sink_log_store_tables_response::SinkLogStoreTable {
11693 #[allow(deprecated)]
11694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11695 where
11696 S: serde::Serializer,
11697 {
11698 use serde::ser::SerializeStruct;
11699 let mut len = 0;
11700 if self.sink_id != 0 {
11701 len += 1;
11702 }
11703 if self.internal_table_id != 0 {
11704 len += 1;
11705 }
11706 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", len)?;
11707 if self.sink_id != 0 {
11708 struct_ser.serialize_field("sinkId", &self.sink_id)?;
11709 }
11710 if self.internal_table_id != 0 {
11711 struct_ser.serialize_field("internalTableId", &self.internal_table_id)?;
11712 }
11713 struct_ser.end()
11714 }
11715}
11716impl<'de> serde::Deserialize<'de> for list_sink_log_store_tables_response::SinkLogStoreTable {
11717 #[allow(deprecated)]
11718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11719 where
11720 D: serde::Deserializer<'de>,
11721 {
11722 const FIELDS: &[&str] = &[
11723 "sink_id",
11724 "sinkId",
11725 "internal_table_id",
11726 "internalTableId",
11727 ];
11728
11729 #[allow(clippy::enum_variant_names)]
11730 enum GeneratedField {
11731 SinkId,
11732 InternalTableId,
11733 }
11734 impl<'de> serde::Deserialize<'de> for GeneratedField {
11735 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11736 where
11737 D: serde::Deserializer<'de>,
11738 {
11739 struct GeneratedVisitor;
11740
11741 impl serde::de::Visitor<'_> for GeneratedVisitor {
11742 type Value = GeneratedField;
11743
11744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11745 write!(formatter, "expected one of: {:?}", &FIELDS)
11746 }
11747
11748 #[allow(unused_variables)]
11749 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11750 where
11751 E: serde::de::Error,
11752 {
11753 match value {
11754 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
11755 "internalTableId" | "internal_table_id" => Ok(GeneratedField::InternalTableId),
11756 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11757 }
11758 }
11759 }
11760 deserializer.deserialize_identifier(GeneratedVisitor)
11761 }
11762 }
11763 struct GeneratedVisitor;
11764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11765 type Value = list_sink_log_store_tables_response::SinkLogStoreTable;
11766
11767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11768 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable")
11769 }
11770
11771 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_sink_log_store_tables_response::SinkLogStoreTable, V::Error>
11772 where
11773 V: serde::de::MapAccess<'de>,
11774 {
11775 let mut sink_id__ = None;
11776 let mut internal_table_id__ = None;
11777 while let Some(k) = map_.next_key()? {
11778 match k {
11779 GeneratedField::SinkId => {
11780 if sink_id__.is_some() {
11781 return Err(serde::de::Error::duplicate_field("sinkId"));
11782 }
11783 sink_id__ =
11784 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11785 ;
11786 }
11787 GeneratedField::InternalTableId => {
11788 if internal_table_id__.is_some() {
11789 return Err(serde::de::Error::duplicate_field("internalTableId"));
11790 }
11791 internal_table_id__ =
11792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11793 ;
11794 }
11795 }
11796 }
11797 Ok(list_sink_log_store_tables_response::SinkLogStoreTable {
11798 sink_id: sink_id__.unwrap_or_default(),
11799 internal_table_id: internal_table_id__.unwrap_or_default(),
11800 })
11801 }
11802 }
11803 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", FIELDS, GeneratedVisitor)
11804 }
11805}
11806impl serde::Serialize for ListStreamingJobStatesRequest {
11807 #[allow(deprecated)]
11808 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11809 where
11810 S: serde::Serializer,
11811 {
11812 use serde::ser::SerializeStruct;
11813 let len = 0;
11814 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
11815 struct_ser.end()
11816 }
11817}
11818impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
11819 #[allow(deprecated)]
11820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11821 where
11822 D: serde::Deserializer<'de>,
11823 {
11824 const FIELDS: &[&str] = &[
11825 ];
11826
11827 #[allow(clippy::enum_variant_names)]
11828 enum GeneratedField {
11829 }
11830 impl<'de> serde::Deserialize<'de> for GeneratedField {
11831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11832 where
11833 D: serde::Deserializer<'de>,
11834 {
11835 struct GeneratedVisitor;
11836
11837 impl serde::de::Visitor<'_> for GeneratedVisitor {
11838 type Value = GeneratedField;
11839
11840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11841 write!(formatter, "expected one of: {:?}", &FIELDS)
11842 }
11843
11844 #[allow(unused_variables)]
11845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11846 where
11847 E: serde::de::Error,
11848 {
11849 Err(serde::de::Error::unknown_field(value, FIELDS))
11850 }
11851 }
11852 deserializer.deserialize_identifier(GeneratedVisitor)
11853 }
11854 }
11855 struct GeneratedVisitor;
11856 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11857 type Value = ListStreamingJobStatesRequest;
11858
11859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11860 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
11861 }
11862
11863 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
11864 where
11865 V: serde::de::MapAccess<'de>,
11866 {
11867 while map_.next_key::<GeneratedField>()?.is_some() {
11868 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11869 }
11870 Ok(ListStreamingJobStatesRequest {
11871 })
11872 }
11873 }
11874 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
11875 }
11876}
11877impl serde::Serialize for ListStreamingJobStatesResponse {
11878 #[allow(deprecated)]
11879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11880 where
11881 S: serde::Serializer,
11882 {
11883 use serde::ser::SerializeStruct;
11884 let mut len = 0;
11885 if !self.states.is_empty() {
11886 len += 1;
11887 }
11888 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
11889 if !self.states.is_empty() {
11890 struct_ser.serialize_field("states", &self.states)?;
11891 }
11892 struct_ser.end()
11893 }
11894}
11895impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
11896 #[allow(deprecated)]
11897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11898 where
11899 D: serde::Deserializer<'de>,
11900 {
11901 const FIELDS: &[&str] = &[
11902 "states",
11903 ];
11904
11905 #[allow(clippy::enum_variant_names)]
11906 enum GeneratedField {
11907 States,
11908 }
11909 impl<'de> serde::Deserialize<'de> for GeneratedField {
11910 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11911 where
11912 D: serde::Deserializer<'de>,
11913 {
11914 struct GeneratedVisitor;
11915
11916 impl serde::de::Visitor<'_> for GeneratedVisitor {
11917 type Value = GeneratedField;
11918
11919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11920 write!(formatter, "expected one of: {:?}", &FIELDS)
11921 }
11922
11923 #[allow(unused_variables)]
11924 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11925 where
11926 E: serde::de::Error,
11927 {
11928 match value {
11929 "states" => Ok(GeneratedField::States),
11930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11931 }
11932 }
11933 }
11934 deserializer.deserialize_identifier(GeneratedVisitor)
11935 }
11936 }
11937 struct GeneratedVisitor;
11938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11939 type Value = ListStreamingJobStatesResponse;
11940
11941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11942 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
11943 }
11944
11945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
11946 where
11947 V: serde::de::MapAccess<'de>,
11948 {
11949 let mut states__ = None;
11950 while let Some(k) = map_.next_key()? {
11951 match k {
11952 GeneratedField::States => {
11953 if states__.is_some() {
11954 return Err(serde::de::Error::duplicate_field("states"));
11955 }
11956 states__ = Some(map_.next_value()?);
11957 }
11958 }
11959 }
11960 Ok(ListStreamingJobStatesResponse {
11961 states: states__.unwrap_or_default(),
11962 })
11963 }
11964 }
11965 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
11966 }
11967}
11968impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
11969 #[allow(deprecated)]
11970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11971 where
11972 S: serde::Serializer,
11973 {
11974 use serde::ser::SerializeStruct;
11975 let mut len = 0;
11976 if self.table_id != 0 {
11977 len += 1;
11978 }
11979 if self.state != 0 {
11980 len += 1;
11981 }
11982 if self.parallelism.is_some() {
11983 len += 1;
11984 }
11985 if self.max_parallelism != 0 {
11986 len += 1;
11987 }
11988 if !self.name.is_empty() {
11989 len += 1;
11990 }
11991 if !self.resource_group.is_empty() {
11992 len += 1;
11993 }
11994 if !self.config_override.is_empty() {
11995 len += 1;
11996 }
11997 if self.database_id != 0 {
11998 len += 1;
11999 }
12000 if self.schema_id != 0 {
12001 len += 1;
12002 }
12003 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12004 if self.table_id != 0 {
12005 struct_ser.serialize_field("tableId", &self.table_id)?;
12006 }
12007 if self.state != 0 {
12008 let v = table_fragments::State::try_from(self.state)
12009 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12010 struct_ser.serialize_field("state", &v)?;
12011 }
12012 if let Some(v) = self.parallelism.as_ref() {
12013 struct_ser.serialize_field("parallelism", v)?;
12014 }
12015 if self.max_parallelism != 0 {
12016 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12017 }
12018 if !self.name.is_empty() {
12019 struct_ser.serialize_field("name", &self.name)?;
12020 }
12021 if !self.resource_group.is_empty() {
12022 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12023 }
12024 if !self.config_override.is_empty() {
12025 struct_ser.serialize_field("configOverride", &self.config_override)?;
12026 }
12027 if self.database_id != 0 {
12028 struct_ser.serialize_field("databaseId", &self.database_id)?;
12029 }
12030 if self.schema_id != 0 {
12031 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12032 }
12033 struct_ser.end()
12034 }
12035}
12036impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12037 #[allow(deprecated)]
12038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12039 where
12040 D: serde::Deserializer<'de>,
12041 {
12042 const FIELDS: &[&str] = &[
12043 "table_id",
12044 "tableId",
12045 "state",
12046 "parallelism",
12047 "max_parallelism",
12048 "maxParallelism",
12049 "name",
12050 "resource_group",
12051 "resourceGroup",
12052 "config_override",
12053 "configOverride",
12054 "database_id",
12055 "databaseId",
12056 "schema_id",
12057 "schemaId",
12058 ];
12059
12060 #[allow(clippy::enum_variant_names)]
12061 enum GeneratedField {
12062 TableId,
12063 State,
12064 Parallelism,
12065 MaxParallelism,
12066 Name,
12067 ResourceGroup,
12068 ConfigOverride,
12069 DatabaseId,
12070 SchemaId,
12071 }
12072 impl<'de> serde::Deserialize<'de> for GeneratedField {
12073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12074 where
12075 D: serde::Deserializer<'de>,
12076 {
12077 struct GeneratedVisitor;
12078
12079 impl serde::de::Visitor<'_> for GeneratedVisitor {
12080 type Value = GeneratedField;
12081
12082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12083 write!(formatter, "expected one of: {:?}", &FIELDS)
12084 }
12085
12086 #[allow(unused_variables)]
12087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12088 where
12089 E: serde::de::Error,
12090 {
12091 match value {
12092 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12093 "state" => Ok(GeneratedField::State),
12094 "parallelism" => Ok(GeneratedField::Parallelism),
12095 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12096 "name" => Ok(GeneratedField::Name),
12097 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12098 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12099 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12100 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12102 }
12103 }
12104 }
12105 deserializer.deserialize_identifier(GeneratedVisitor)
12106 }
12107 }
12108 struct GeneratedVisitor;
12109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12110 type Value = list_streaming_job_states_response::StreamingJobState;
12111
12112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12113 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12114 }
12115
12116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12117 where
12118 V: serde::de::MapAccess<'de>,
12119 {
12120 let mut table_id__ = None;
12121 let mut state__ = None;
12122 let mut parallelism__ = None;
12123 let mut max_parallelism__ = None;
12124 let mut name__ = None;
12125 let mut resource_group__ = None;
12126 let mut config_override__ = None;
12127 let mut database_id__ = None;
12128 let mut schema_id__ = None;
12129 while let Some(k) = map_.next_key()? {
12130 match k {
12131 GeneratedField::TableId => {
12132 if table_id__.is_some() {
12133 return Err(serde::de::Error::duplicate_field("tableId"));
12134 }
12135 table_id__ =
12136 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12137 ;
12138 }
12139 GeneratedField::State => {
12140 if state__.is_some() {
12141 return Err(serde::de::Error::duplicate_field("state"));
12142 }
12143 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12144 }
12145 GeneratedField::Parallelism => {
12146 if parallelism__.is_some() {
12147 return Err(serde::de::Error::duplicate_field("parallelism"));
12148 }
12149 parallelism__ = map_.next_value()?;
12150 }
12151 GeneratedField::MaxParallelism => {
12152 if max_parallelism__.is_some() {
12153 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12154 }
12155 max_parallelism__ =
12156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12157 ;
12158 }
12159 GeneratedField::Name => {
12160 if name__.is_some() {
12161 return Err(serde::de::Error::duplicate_field("name"));
12162 }
12163 name__ = Some(map_.next_value()?);
12164 }
12165 GeneratedField::ResourceGroup => {
12166 if resource_group__.is_some() {
12167 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12168 }
12169 resource_group__ = Some(map_.next_value()?);
12170 }
12171 GeneratedField::ConfigOverride => {
12172 if config_override__.is_some() {
12173 return Err(serde::de::Error::duplicate_field("configOverride"));
12174 }
12175 config_override__ = Some(map_.next_value()?);
12176 }
12177 GeneratedField::DatabaseId => {
12178 if database_id__.is_some() {
12179 return Err(serde::de::Error::duplicate_field("databaseId"));
12180 }
12181 database_id__ =
12182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12183 ;
12184 }
12185 GeneratedField::SchemaId => {
12186 if schema_id__.is_some() {
12187 return Err(serde::de::Error::duplicate_field("schemaId"));
12188 }
12189 schema_id__ =
12190 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12191 ;
12192 }
12193 }
12194 }
12195 Ok(list_streaming_job_states_response::StreamingJobState {
12196 table_id: table_id__.unwrap_or_default(),
12197 state: state__.unwrap_or_default(),
12198 parallelism: parallelism__,
12199 max_parallelism: max_parallelism__.unwrap_or_default(),
12200 name: name__.unwrap_or_default(),
12201 resource_group: resource_group__.unwrap_or_default(),
12202 config_override: config_override__.unwrap_or_default(),
12203 database_id: database_id__.unwrap_or_default(),
12204 schema_id: schema_id__.unwrap_or_default(),
12205 })
12206 }
12207 }
12208 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12209 }
12210}
12211impl serde::Serialize for ListTableFragmentsRequest {
12212 #[allow(deprecated)]
12213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12214 where
12215 S: serde::Serializer,
12216 {
12217 use serde::ser::SerializeStruct;
12218 let mut len = 0;
12219 if !self.table_ids.is_empty() {
12220 len += 1;
12221 }
12222 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12223 if !self.table_ids.is_empty() {
12224 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12225 }
12226 struct_ser.end()
12227 }
12228}
12229impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12230 #[allow(deprecated)]
12231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12232 where
12233 D: serde::Deserializer<'de>,
12234 {
12235 const FIELDS: &[&str] = &[
12236 "table_ids",
12237 "tableIds",
12238 ];
12239
12240 #[allow(clippy::enum_variant_names)]
12241 enum GeneratedField {
12242 TableIds,
12243 }
12244 impl<'de> serde::Deserialize<'de> for GeneratedField {
12245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12246 where
12247 D: serde::Deserializer<'de>,
12248 {
12249 struct GeneratedVisitor;
12250
12251 impl serde::de::Visitor<'_> for GeneratedVisitor {
12252 type Value = GeneratedField;
12253
12254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12255 write!(formatter, "expected one of: {:?}", &FIELDS)
12256 }
12257
12258 #[allow(unused_variables)]
12259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12260 where
12261 E: serde::de::Error,
12262 {
12263 match value {
12264 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12266 }
12267 }
12268 }
12269 deserializer.deserialize_identifier(GeneratedVisitor)
12270 }
12271 }
12272 struct GeneratedVisitor;
12273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12274 type Value = ListTableFragmentsRequest;
12275
12276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12277 formatter.write_str("struct meta.ListTableFragmentsRequest")
12278 }
12279
12280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12281 where
12282 V: serde::de::MapAccess<'de>,
12283 {
12284 let mut table_ids__ = None;
12285 while let Some(k) = map_.next_key()? {
12286 match k {
12287 GeneratedField::TableIds => {
12288 if table_ids__.is_some() {
12289 return Err(serde::de::Error::duplicate_field("tableIds"));
12290 }
12291 table_ids__ =
12292 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12293 .into_iter().map(|x| x.0).collect())
12294 ;
12295 }
12296 }
12297 }
12298 Ok(ListTableFragmentsRequest {
12299 table_ids: table_ids__.unwrap_or_default(),
12300 })
12301 }
12302 }
12303 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12304 }
12305}
12306impl serde::Serialize for ListTableFragmentsResponse {
12307 #[allow(deprecated)]
12308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12309 where
12310 S: serde::Serializer,
12311 {
12312 use serde::ser::SerializeStruct;
12313 let mut len = 0;
12314 if !self.table_fragments.is_empty() {
12315 len += 1;
12316 }
12317 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12318 if !self.table_fragments.is_empty() {
12319 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12320 }
12321 struct_ser.end()
12322 }
12323}
12324impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12325 #[allow(deprecated)]
12326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12327 where
12328 D: serde::Deserializer<'de>,
12329 {
12330 const FIELDS: &[&str] = &[
12331 "table_fragments",
12332 "tableFragments",
12333 ];
12334
12335 #[allow(clippy::enum_variant_names)]
12336 enum GeneratedField {
12337 TableFragments,
12338 }
12339 impl<'de> serde::Deserialize<'de> for GeneratedField {
12340 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12341 where
12342 D: serde::Deserializer<'de>,
12343 {
12344 struct GeneratedVisitor;
12345
12346 impl serde::de::Visitor<'_> for GeneratedVisitor {
12347 type Value = GeneratedField;
12348
12349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12350 write!(formatter, "expected one of: {:?}", &FIELDS)
12351 }
12352
12353 #[allow(unused_variables)]
12354 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12355 where
12356 E: serde::de::Error,
12357 {
12358 match value {
12359 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
12360 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12361 }
12362 }
12363 }
12364 deserializer.deserialize_identifier(GeneratedVisitor)
12365 }
12366 }
12367 struct GeneratedVisitor;
12368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12369 type Value = ListTableFragmentsResponse;
12370
12371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12372 formatter.write_str("struct meta.ListTableFragmentsResponse")
12373 }
12374
12375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12376 where
12377 V: serde::de::MapAccess<'de>,
12378 {
12379 let mut table_fragments__ = None;
12380 while let Some(k) = map_.next_key()? {
12381 match k {
12382 GeneratedField::TableFragments => {
12383 if table_fragments__.is_some() {
12384 return Err(serde::de::Error::duplicate_field("tableFragments"));
12385 }
12386 table_fragments__ = Some(
12387 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12388 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12389 );
12390 }
12391 }
12392 }
12393 Ok(ListTableFragmentsResponse {
12394 table_fragments: table_fragments__.unwrap_or_default(),
12395 })
12396 }
12397 }
12398 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
12399 }
12400}
12401impl serde::Serialize for list_table_fragments_response::ActorInfo {
12402 #[allow(deprecated)]
12403 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12404 where
12405 S: serde::Serializer,
12406 {
12407 use serde::ser::SerializeStruct;
12408 let mut len = 0;
12409 if self.id != 0 {
12410 len += 1;
12411 }
12412 if self.node.is_some() {
12413 len += 1;
12414 }
12415 if !self.dispatcher.is_empty() {
12416 len += 1;
12417 }
12418 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
12419 if self.id != 0 {
12420 struct_ser.serialize_field("id", &self.id)?;
12421 }
12422 if let Some(v) = self.node.as_ref() {
12423 struct_ser.serialize_field("node", v)?;
12424 }
12425 if !self.dispatcher.is_empty() {
12426 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12427 }
12428 struct_ser.end()
12429 }
12430}
12431impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
12432 #[allow(deprecated)]
12433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12434 where
12435 D: serde::Deserializer<'de>,
12436 {
12437 const FIELDS: &[&str] = &[
12438 "id",
12439 "node",
12440 "dispatcher",
12441 ];
12442
12443 #[allow(clippy::enum_variant_names)]
12444 enum GeneratedField {
12445 Id,
12446 Node,
12447 Dispatcher,
12448 }
12449 impl<'de> serde::Deserialize<'de> for GeneratedField {
12450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12451 where
12452 D: serde::Deserializer<'de>,
12453 {
12454 struct GeneratedVisitor;
12455
12456 impl serde::de::Visitor<'_> for GeneratedVisitor {
12457 type Value = GeneratedField;
12458
12459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12460 write!(formatter, "expected one of: {:?}", &FIELDS)
12461 }
12462
12463 #[allow(unused_variables)]
12464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12465 where
12466 E: serde::de::Error,
12467 {
12468 match value {
12469 "id" => Ok(GeneratedField::Id),
12470 "node" => Ok(GeneratedField::Node),
12471 "dispatcher" => Ok(GeneratedField::Dispatcher),
12472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12473 }
12474 }
12475 }
12476 deserializer.deserialize_identifier(GeneratedVisitor)
12477 }
12478 }
12479 struct GeneratedVisitor;
12480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12481 type Value = list_table_fragments_response::ActorInfo;
12482
12483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12484 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
12485 }
12486
12487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12488 where
12489 V: serde::de::MapAccess<'de>,
12490 {
12491 let mut id__ = None;
12492 let mut node__ = None;
12493 let mut dispatcher__ = None;
12494 while let Some(k) = map_.next_key()? {
12495 match k {
12496 GeneratedField::Id => {
12497 if id__.is_some() {
12498 return Err(serde::de::Error::duplicate_field("id"));
12499 }
12500 id__ =
12501 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12502 ;
12503 }
12504 GeneratedField::Node => {
12505 if node__.is_some() {
12506 return Err(serde::de::Error::duplicate_field("node"));
12507 }
12508 node__ = map_.next_value()?;
12509 }
12510 GeneratedField::Dispatcher => {
12511 if dispatcher__.is_some() {
12512 return Err(serde::de::Error::duplicate_field("dispatcher"));
12513 }
12514 dispatcher__ = Some(map_.next_value()?);
12515 }
12516 }
12517 }
12518 Ok(list_table_fragments_response::ActorInfo {
12519 id: id__.unwrap_or_default(),
12520 node: node__,
12521 dispatcher: dispatcher__.unwrap_or_default(),
12522 })
12523 }
12524 }
12525 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12526 }
12527}
12528impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12529 #[allow(deprecated)]
12530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12531 where
12532 S: serde::Serializer,
12533 {
12534 use serde::ser::SerializeStruct;
12535 let mut len = 0;
12536 if self.id != 0 {
12537 len += 1;
12538 }
12539 if !self.actors.is_empty() {
12540 len += 1;
12541 }
12542 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12543 if self.id != 0 {
12544 struct_ser.serialize_field("id", &self.id)?;
12545 }
12546 if !self.actors.is_empty() {
12547 struct_ser.serialize_field("actors", &self.actors)?;
12548 }
12549 struct_ser.end()
12550 }
12551}
12552impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12553 #[allow(deprecated)]
12554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12555 where
12556 D: serde::Deserializer<'de>,
12557 {
12558 const FIELDS: &[&str] = &[
12559 "id",
12560 "actors",
12561 ];
12562
12563 #[allow(clippy::enum_variant_names)]
12564 enum GeneratedField {
12565 Id,
12566 Actors,
12567 }
12568 impl<'de> serde::Deserialize<'de> for GeneratedField {
12569 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12570 where
12571 D: serde::Deserializer<'de>,
12572 {
12573 struct GeneratedVisitor;
12574
12575 impl serde::de::Visitor<'_> for GeneratedVisitor {
12576 type Value = GeneratedField;
12577
12578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12579 write!(formatter, "expected one of: {:?}", &FIELDS)
12580 }
12581
12582 #[allow(unused_variables)]
12583 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12584 where
12585 E: serde::de::Error,
12586 {
12587 match value {
12588 "id" => Ok(GeneratedField::Id),
12589 "actors" => Ok(GeneratedField::Actors),
12590 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12591 }
12592 }
12593 }
12594 deserializer.deserialize_identifier(GeneratedVisitor)
12595 }
12596 }
12597 struct GeneratedVisitor;
12598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12599 type Value = list_table_fragments_response::FragmentInfo;
12600
12601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12602 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
12603 }
12604
12605 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
12606 where
12607 V: serde::de::MapAccess<'de>,
12608 {
12609 let mut id__ = None;
12610 let mut actors__ = None;
12611 while let Some(k) = map_.next_key()? {
12612 match k {
12613 GeneratedField::Id => {
12614 if id__.is_some() {
12615 return Err(serde::de::Error::duplicate_field("id"));
12616 }
12617 id__ =
12618 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12619 ;
12620 }
12621 GeneratedField::Actors => {
12622 if actors__.is_some() {
12623 return Err(serde::de::Error::duplicate_field("actors"));
12624 }
12625 actors__ = Some(map_.next_value()?);
12626 }
12627 }
12628 }
12629 Ok(list_table_fragments_response::FragmentInfo {
12630 id: id__.unwrap_or_default(),
12631 actors: actors__.unwrap_or_default(),
12632 })
12633 }
12634 }
12635 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
12636 }
12637}
12638impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
12639 #[allow(deprecated)]
12640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12641 where
12642 S: serde::Serializer,
12643 {
12644 use serde::ser::SerializeStruct;
12645 let mut len = 0;
12646 if !self.fragments.is_empty() {
12647 len += 1;
12648 }
12649 if self.ctx.is_some() {
12650 len += 1;
12651 }
12652 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
12653 if !self.fragments.is_empty() {
12654 struct_ser.serialize_field("fragments", &self.fragments)?;
12655 }
12656 if let Some(v) = self.ctx.as_ref() {
12657 struct_ser.serialize_field("ctx", v)?;
12658 }
12659 struct_ser.end()
12660 }
12661}
12662impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
12663 #[allow(deprecated)]
12664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12665 where
12666 D: serde::Deserializer<'de>,
12667 {
12668 const FIELDS: &[&str] = &[
12669 "fragments",
12670 "ctx",
12671 ];
12672
12673 #[allow(clippy::enum_variant_names)]
12674 enum GeneratedField {
12675 Fragments,
12676 Ctx,
12677 }
12678 impl<'de> serde::Deserialize<'de> for GeneratedField {
12679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12680 where
12681 D: serde::Deserializer<'de>,
12682 {
12683 struct GeneratedVisitor;
12684
12685 impl serde::de::Visitor<'_> for GeneratedVisitor {
12686 type Value = GeneratedField;
12687
12688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12689 write!(formatter, "expected one of: {:?}", &FIELDS)
12690 }
12691
12692 #[allow(unused_variables)]
12693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12694 where
12695 E: serde::de::Error,
12696 {
12697 match value {
12698 "fragments" => Ok(GeneratedField::Fragments),
12699 "ctx" => Ok(GeneratedField::Ctx),
12700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12701 }
12702 }
12703 }
12704 deserializer.deserialize_identifier(GeneratedVisitor)
12705 }
12706 }
12707 struct GeneratedVisitor;
12708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12709 type Value = list_table_fragments_response::TableFragmentInfo;
12710
12711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12712 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
12713 }
12714
12715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
12716 where
12717 V: serde::de::MapAccess<'de>,
12718 {
12719 let mut fragments__ = None;
12720 let mut ctx__ = None;
12721 while let Some(k) = map_.next_key()? {
12722 match k {
12723 GeneratedField::Fragments => {
12724 if fragments__.is_some() {
12725 return Err(serde::de::Error::duplicate_field("fragments"));
12726 }
12727 fragments__ = Some(map_.next_value()?);
12728 }
12729 GeneratedField::Ctx => {
12730 if ctx__.is_some() {
12731 return Err(serde::de::Error::duplicate_field("ctx"));
12732 }
12733 ctx__ = map_.next_value()?;
12734 }
12735 }
12736 }
12737 Ok(list_table_fragments_response::TableFragmentInfo {
12738 fragments: fragments__.unwrap_or_default(),
12739 ctx: ctx__,
12740 })
12741 }
12742 }
12743 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
12744 }
12745}
12746impl serde::Serialize for ListUnmigratedTablesRequest {
12747 #[allow(deprecated)]
12748 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12749 where
12750 S: serde::Serializer,
12751 {
12752 use serde::ser::SerializeStruct;
12753 let len = 0;
12754 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
12755 struct_ser.end()
12756 }
12757}
12758impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
12759 #[allow(deprecated)]
12760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12761 where
12762 D: serde::Deserializer<'de>,
12763 {
12764 const FIELDS: &[&str] = &[
12765 ];
12766
12767 #[allow(clippy::enum_variant_names)]
12768 enum GeneratedField {
12769 }
12770 impl<'de> serde::Deserialize<'de> for GeneratedField {
12771 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12772 where
12773 D: serde::Deserializer<'de>,
12774 {
12775 struct GeneratedVisitor;
12776
12777 impl serde::de::Visitor<'_> for GeneratedVisitor {
12778 type Value = GeneratedField;
12779
12780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12781 write!(formatter, "expected one of: {:?}", &FIELDS)
12782 }
12783
12784 #[allow(unused_variables)]
12785 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12786 where
12787 E: serde::de::Error,
12788 {
12789 Err(serde::de::Error::unknown_field(value, FIELDS))
12790 }
12791 }
12792 deserializer.deserialize_identifier(GeneratedVisitor)
12793 }
12794 }
12795 struct GeneratedVisitor;
12796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12797 type Value = ListUnmigratedTablesRequest;
12798
12799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12800 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
12801 }
12802
12803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
12804 where
12805 V: serde::de::MapAccess<'de>,
12806 {
12807 while map_.next_key::<GeneratedField>()?.is_some() {
12808 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12809 }
12810 Ok(ListUnmigratedTablesRequest {
12811 })
12812 }
12813 }
12814 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
12815 }
12816}
12817impl serde::Serialize for ListUnmigratedTablesResponse {
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.tables.is_empty() {
12826 len += 1;
12827 }
12828 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
12829 if !self.tables.is_empty() {
12830 struct_ser.serialize_field("tables", &self.tables)?;
12831 }
12832 struct_ser.end()
12833 }
12834}
12835impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
12836 #[allow(deprecated)]
12837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12838 where
12839 D: serde::Deserializer<'de>,
12840 {
12841 const FIELDS: &[&str] = &[
12842 "tables",
12843 ];
12844
12845 #[allow(clippy::enum_variant_names)]
12846 enum GeneratedField {
12847 Tables,
12848 }
12849 impl<'de> serde::Deserialize<'de> for GeneratedField {
12850 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12851 where
12852 D: serde::Deserializer<'de>,
12853 {
12854 struct GeneratedVisitor;
12855
12856 impl serde::de::Visitor<'_> for GeneratedVisitor {
12857 type Value = GeneratedField;
12858
12859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12860 write!(formatter, "expected one of: {:?}", &FIELDS)
12861 }
12862
12863 #[allow(unused_variables)]
12864 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12865 where
12866 E: serde::de::Error,
12867 {
12868 match value {
12869 "tables" => Ok(GeneratedField::Tables),
12870 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12871 }
12872 }
12873 }
12874 deserializer.deserialize_identifier(GeneratedVisitor)
12875 }
12876 }
12877 struct GeneratedVisitor;
12878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12879 type Value = ListUnmigratedTablesResponse;
12880
12881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12882 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
12883 }
12884
12885 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
12886 where
12887 V: serde::de::MapAccess<'de>,
12888 {
12889 let mut tables__ = None;
12890 while let Some(k) = map_.next_key()? {
12891 match k {
12892 GeneratedField::Tables => {
12893 if tables__.is_some() {
12894 return Err(serde::de::Error::duplicate_field("tables"));
12895 }
12896 tables__ = Some(map_.next_value()?);
12897 }
12898 }
12899 }
12900 Ok(ListUnmigratedTablesResponse {
12901 tables: tables__.unwrap_or_default(),
12902 })
12903 }
12904 }
12905 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
12906 }
12907}
12908impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
12909 #[allow(deprecated)]
12910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12911 where
12912 S: serde::Serializer,
12913 {
12914 use serde::ser::SerializeStruct;
12915 let mut len = 0;
12916 if self.table_id != 0 {
12917 len += 1;
12918 }
12919 if !self.table_name.is_empty() {
12920 len += 1;
12921 }
12922 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
12923 if self.table_id != 0 {
12924 struct_ser.serialize_field("tableId", &self.table_id)?;
12925 }
12926 if !self.table_name.is_empty() {
12927 struct_ser.serialize_field("tableName", &self.table_name)?;
12928 }
12929 struct_ser.end()
12930 }
12931}
12932impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
12933 #[allow(deprecated)]
12934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12935 where
12936 D: serde::Deserializer<'de>,
12937 {
12938 const FIELDS: &[&str] = &[
12939 "table_id",
12940 "tableId",
12941 "table_name",
12942 "tableName",
12943 ];
12944
12945 #[allow(clippy::enum_variant_names)]
12946 enum GeneratedField {
12947 TableId,
12948 TableName,
12949 }
12950 impl<'de> serde::Deserialize<'de> for GeneratedField {
12951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12952 where
12953 D: serde::Deserializer<'de>,
12954 {
12955 struct GeneratedVisitor;
12956
12957 impl serde::de::Visitor<'_> for GeneratedVisitor {
12958 type Value = GeneratedField;
12959
12960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12961 write!(formatter, "expected one of: {:?}", &FIELDS)
12962 }
12963
12964 #[allow(unused_variables)]
12965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12966 where
12967 E: serde::de::Error,
12968 {
12969 match value {
12970 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12971 "tableName" | "table_name" => Ok(GeneratedField::TableName),
12972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12973 }
12974 }
12975 }
12976 deserializer.deserialize_identifier(GeneratedVisitor)
12977 }
12978 }
12979 struct GeneratedVisitor;
12980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12981 type Value = list_unmigrated_tables_response::UnmigratedTable;
12982
12983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12984 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
12985 }
12986
12987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
12988 where
12989 V: serde::de::MapAccess<'de>,
12990 {
12991 let mut table_id__ = None;
12992 let mut table_name__ = None;
12993 while let Some(k) = map_.next_key()? {
12994 match k {
12995 GeneratedField::TableId => {
12996 if table_id__.is_some() {
12997 return Err(serde::de::Error::duplicate_field("tableId"));
12998 }
12999 table_id__ =
13000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13001 ;
13002 }
13003 GeneratedField::TableName => {
13004 if table_name__.is_some() {
13005 return Err(serde::de::Error::duplicate_field("tableName"));
13006 }
13007 table_name__ = Some(map_.next_value()?);
13008 }
13009 }
13010 }
13011 Ok(list_unmigrated_tables_response::UnmigratedTable {
13012 table_id: table_id__.unwrap_or_default(),
13013 table_name: table_name__.unwrap_or_default(),
13014 })
13015 }
13016 }
13017 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13018 }
13019}
13020impl serde::Serialize for MembersRequest {
13021 #[allow(deprecated)]
13022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13023 where
13024 S: serde::Serializer,
13025 {
13026 use serde::ser::SerializeStruct;
13027 let len = 0;
13028 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13029 struct_ser.end()
13030 }
13031}
13032impl<'de> serde::Deserialize<'de> for MembersRequest {
13033 #[allow(deprecated)]
13034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13035 where
13036 D: serde::Deserializer<'de>,
13037 {
13038 const FIELDS: &[&str] = &[
13039 ];
13040
13041 #[allow(clippy::enum_variant_names)]
13042 enum GeneratedField {
13043 }
13044 impl<'de> serde::Deserialize<'de> for GeneratedField {
13045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13046 where
13047 D: serde::Deserializer<'de>,
13048 {
13049 struct GeneratedVisitor;
13050
13051 impl serde::de::Visitor<'_> for GeneratedVisitor {
13052 type Value = GeneratedField;
13053
13054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13055 write!(formatter, "expected one of: {:?}", &FIELDS)
13056 }
13057
13058 #[allow(unused_variables)]
13059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13060 where
13061 E: serde::de::Error,
13062 {
13063 Err(serde::de::Error::unknown_field(value, FIELDS))
13064 }
13065 }
13066 deserializer.deserialize_identifier(GeneratedVisitor)
13067 }
13068 }
13069 struct GeneratedVisitor;
13070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13071 type Value = MembersRequest;
13072
13073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13074 formatter.write_str("struct meta.MembersRequest")
13075 }
13076
13077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13078 where
13079 V: serde::de::MapAccess<'de>,
13080 {
13081 while map_.next_key::<GeneratedField>()?.is_some() {
13082 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13083 }
13084 Ok(MembersRequest {
13085 })
13086 }
13087 }
13088 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13089 }
13090}
13091impl serde::Serialize for MembersResponse {
13092 #[allow(deprecated)]
13093 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13094 where
13095 S: serde::Serializer,
13096 {
13097 use serde::ser::SerializeStruct;
13098 let mut len = 0;
13099 if !self.members.is_empty() {
13100 len += 1;
13101 }
13102 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13103 if !self.members.is_empty() {
13104 struct_ser.serialize_field("members", &self.members)?;
13105 }
13106 struct_ser.end()
13107 }
13108}
13109impl<'de> serde::Deserialize<'de> for MembersResponse {
13110 #[allow(deprecated)]
13111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13112 where
13113 D: serde::Deserializer<'de>,
13114 {
13115 const FIELDS: &[&str] = &[
13116 "members",
13117 ];
13118
13119 #[allow(clippy::enum_variant_names)]
13120 enum GeneratedField {
13121 Members,
13122 }
13123 impl<'de> serde::Deserialize<'de> for GeneratedField {
13124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13125 where
13126 D: serde::Deserializer<'de>,
13127 {
13128 struct GeneratedVisitor;
13129
13130 impl serde::de::Visitor<'_> for GeneratedVisitor {
13131 type Value = GeneratedField;
13132
13133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13134 write!(formatter, "expected one of: {:?}", &FIELDS)
13135 }
13136
13137 #[allow(unused_variables)]
13138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13139 where
13140 E: serde::de::Error,
13141 {
13142 match value {
13143 "members" => Ok(GeneratedField::Members),
13144 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13145 }
13146 }
13147 }
13148 deserializer.deserialize_identifier(GeneratedVisitor)
13149 }
13150 }
13151 struct GeneratedVisitor;
13152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13153 type Value = MembersResponse;
13154
13155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13156 formatter.write_str("struct meta.MembersResponse")
13157 }
13158
13159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13160 where
13161 V: serde::de::MapAccess<'de>,
13162 {
13163 let mut members__ = None;
13164 while let Some(k) = map_.next_key()? {
13165 match k {
13166 GeneratedField::Members => {
13167 if members__.is_some() {
13168 return Err(serde::de::Error::duplicate_field("members"));
13169 }
13170 members__ = Some(map_.next_value()?);
13171 }
13172 }
13173 }
13174 Ok(MembersResponse {
13175 members: members__.unwrap_or_default(),
13176 })
13177 }
13178 }
13179 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13180 }
13181}
13182impl serde::Serialize for MetaMember {
13183 #[allow(deprecated)]
13184 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13185 where
13186 S: serde::Serializer,
13187 {
13188 use serde::ser::SerializeStruct;
13189 let mut len = 0;
13190 if self.address.is_some() {
13191 len += 1;
13192 }
13193 if self.is_leader {
13194 len += 1;
13195 }
13196 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13197 if let Some(v) = self.address.as_ref() {
13198 struct_ser.serialize_field("address", v)?;
13199 }
13200 if self.is_leader {
13201 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13202 }
13203 struct_ser.end()
13204 }
13205}
13206impl<'de> serde::Deserialize<'de> for MetaMember {
13207 #[allow(deprecated)]
13208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13209 where
13210 D: serde::Deserializer<'de>,
13211 {
13212 const FIELDS: &[&str] = &[
13213 "address",
13214 "is_leader",
13215 "isLeader",
13216 ];
13217
13218 #[allow(clippy::enum_variant_names)]
13219 enum GeneratedField {
13220 Address,
13221 IsLeader,
13222 }
13223 impl<'de> serde::Deserialize<'de> for GeneratedField {
13224 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13225 where
13226 D: serde::Deserializer<'de>,
13227 {
13228 struct GeneratedVisitor;
13229
13230 impl serde::de::Visitor<'_> for GeneratedVisitor {
13231 type Value = GeneratedField;
13232
13233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13234 write!(formatter, "expected one of: {:?}", &FIELDS)
13235 }
13236
13237 #[allow(unused_variables)]
13238 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13239 where
13240 E: serde::de::Error,
13241 {
13242 match value {
13243 "address" => Ok(GeneratedField::Address),
13244 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13246 }
13247 }
13248 }
13249 deserializer.deserialize_identifier(GeneratedVisitor)
13250 }
13251 }
13252 struct GeneratedVisitor;
13253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13254 type Value = MetaMember;
13255
13256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13257 formatter.write_str("struct meta.MetaMember")
13258 }
13259
13260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13261 where
13262 V: serde::de::MapAccess<'de>,
13263 {
13264 let mut address__ = None;
13265 let mut is_leader__ = None;
13266 while let Some(k) = map_.next_key()? {
13267 match k {
13268 GeneratedField::Address => {
13269 if address__.is_some() {
13270 return Err(serde::de::Error::duplicate_field("address"));
13271 }
13272 address__ = map_.next_value()?;
13273 }
13274 GeneratedField::IsLeader => {
13275 if is_leader__.is_some() {
13276 return Err(serde::de::Error::duplicate_field("isLeader"));
13277 }
13278 is_leader__ = Some(map_.next_value()?);
13279 }
13280 }
13281 }
13282 Ok(MetaMember {
13283 address: address__,
13284 is_leader: is_leader__.unwrap_or_default(),
13285 })
13286 }
13287 }
13288 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13289 }
13290}
13291impl serde::Serialize for MetaSnapshot {
13292 #[allow(deprecated)]
13293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13294 where
13295 S: serde::Serializer,
13296 {
13297 use serde::ser::SerializeStruct;
13298 let mut len = 0;
13299 if !self.databases.is_empty() {
13300 len += 1;
13301 }
13302 if !self.schemas.is_empty() {
13303 len += 1;
13304 }
13305 if !self.sources.is_empty() {
13306 len += 1;
13307 }
13308 if !self.sinks.is_empty() {
13309 len += 1;
13310 }
13311 if !self.tables.is_empty() {
13312 len += 1;
13313 }
13314 if !self.indexes.is_empty() {
13315 len += 1;
13316 }
13317 if !self.views.is_empty() {
13318 len += 1;
13319 }
13320 if !self.functions.is_empty() {
13321 len += 1;
13322 }
13323 if !self.connections.is_empty() {
13324 len += 1;
13325 }
13326 if !self.subscriptions.is_empty() {
13327 len += 1;
13328 }
13329 if !self.users.is_empty() {
13330 len += 1;
13331 }
13332 if self.session_params.is_some() {
13333 len += 1;
13334 }
13335 if !self.secrets.is_empty() {
13336 len += 1;
13337 }
13338 if self.cluster_resource.is_some() {
13339 len += 1;
13340 }
13341 if !self.nodes.is_empty() {
13342 len += 1;
13343 }
13344 if self.hummock_version.is_some() {
13345 len += 1;
13346 }
13347 if self.meta_backup_manifest_id.is_some() {
13348 len += 1;
13349 }
13350 if self.hummock_write_limits.is_some() {
13351 len += 1;
13352 }
13353 if !self.streaming_worker_slot_mappings.is_empty() {
13354 len += 1;
13355 }
13356 if !self.serving_worker_slot_mappings.is_empty() {
13357 len += 1;
13358 }
13359 if !self.object_dependencies.is_empty() {
13360 len += 1;
13361 }
13362 if self.version.is_some() {
13363 len += 1;
13364 }
13365 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13366 if !self.databases.is_empty() {
13367 struct_ser.serialize_field("databases", &self.databases)?;
13368 }
13369 if !self.schemas.is_empty() {
13370 struct_ser.serialize_field("schemas", &self.schemas)?;
13371 }
13372 if !self.sources.is_empty() {
13373 struct_ser.serialize_field("sources", &self.sources)?;
13374 }
13375 if !self.sinks.is_empty() {
13376 struct_ser.serialize_field("sinks", &self.sinks)?;
13377 }
13378 if !self.tables.is_empty() {
13379 struct_ser.serialize_field("tables", &self.tables)?;
13380 }
13381 if !self.indexes.is_empty() {
13382 struct_ser.serialize_field("indexes", &self.indexes)?;
13383 }
13384 if !self.views.is_empty() {
13385 struct_ser.serialize_field("views", &self.views)?;
13386 }
13387 if !self.functions.is_empty() {
13388 struct_ser.serialize_field("functions", &self.functions)?;
13389 }
13390 if !self.connections.is_empty() {
13391 struct_ser.serialize_field("connections", &self.connections)?;
13392 }
13393 if !self.subscriptions.is_empty() {
13394 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13395 }
13396 if !self.users.is_empty() {
13397 struct_ser.serialize_field("users", &self.users)?;
13398 }
13399 if let Some(v) = self.session_params.as_ref() {
13400 struct_ser.serialize_field("sessionParams", v)?;
13401 }
13402 if !self.secrets.is_empty() {
13403 struct_ser.serialize_field("secrets", &self.secrets)?;
13404 }
13405 if let Some(v) = self.cluster_resource.as_ref() {
13406 struct_ser.serialize_field("clusterResource", v)?;
13407 }
13408 if !self.nodes.is_empty() {
13409 struct_ser.serialize_field("nodes", &self.nodes)?;
13410 }
13411 if let Some(v) = self.hummock_version.as_ref() {
13412 struct_ser.serialize_field("hummockVersion", v)?;
13413 }
13414 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
13415 struct_ser.serialize_field("metaBackupManifestId", v)?;
13416 }
13417 if let Some(v) = self.hummock_write_limits.as_ref() {
13418 struct_ser.serialize_field("hummockWriteLimits", v)?;
13419 }
13420 if !self.streaming_worker_slot_mappings.is_empty() {
13421 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
13422 }
13423 if !self.serving_worker_slot_mappings.is_empty() {
13424 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
13425 }
13426 if !self.object_dependencies.is_empty() {
13427 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
13428 }
13429 if let Some(v) = self.version.as_ref() {
13430 struct_ser.serialize_field("version", v)?;
13431 }
13432 struct_ser.end()
13433 }
13434}
13435impl<'de> serde::Deserialize<'de> for MetaSnapshot {
13436 #[allow(deprecated)]
13437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13438 where
13439 D: serde::Deserializer<'de>,
13440 {
13441 const FIELDS: &[&str] = &[
13442 "databases",
13443 "schemas",
13444 "sources",
13445 "sinks",
13446 "tables",
13447 "indexes",
13448 "views",
13449 "functions",
13450 "connections",
13451 "subscriptions",
13452 "users",
13453 "session_params",
13454 "sessionParams",
13455 "secrets",
13456 "cluster_resource",
13457 "clusterResource",
13458 "nodes",
13459 "hummock_version",
13460 "hummockVersion",
13461 "meta_backup_manifest_id",
13462 "metaBackupManifestId",
13463 "hummock_write_limits",
13464 "hummockWriteLimits",
13465 "streaming_worker_slot_mappings",
13466 "streamingWorkerSlotMappings",
13467 "serving_worker_slot_mappings",
13468 "servingWorkerSlotMappings",
13469 "object_dependencies",
13470 "objectDependencies",
13471 "version",
13472 ];
13473
13474 #[allow(clippy::enum_variant_names)]
13475 enum GeneratedField {
13476 Databases,
13477 Schemas,
13478 Sources,
13479 Sinks,
13480 Tables,
13481 Indexes,
13482 Views,
13483 Functions,
13484 Connections,
13485 Subscriptions,
13486 Users,
13487 SessionParams,
13488 Secrets,
13489 ClusterResource,
13490 Nodes,
13491 HummockVersion,
13492 MetaBackupManifestId,
13493 HummockWriteLimits,
13494 StreamingWorkerSlotMappings,
13495 ServingWorkerSlotMappings,
13496 ObjectDependencies,
13497 Version,
13498 }
13499 impl<'de> serde::Deserialize<'de> for GeneratedField {
13500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13501 where
13502 D: serde::Deserializer<'de>,
13503 {
13504 struct GeneratedVisitor;
13505
13506 impl serde::de::Visitor<'_> for GeneratedVisitor {
13507 type Value = GeneratedField;
13508
13509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13510 write!(formatter, "expected one of: {:?}", &FIELDS)
13511 }
13512
13513 #[allow(unused_variables)]
13514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13515 where
13516 E: serde::de::Error,
13517 {
13518 match value {
13519 "databases" => Ok(GeneratedField::Databases),
13520 "schemas" => Ok(GeneratedField::Schemas),
13521 "sources" => Ok(GeneratedField::Sources),
13522 "sinks" => Ok(GeneratedField::Sinks),
13523 "tables" => Ok(GeneratedField::Tables),
13524 "indexes" => Ok(GeneratedField::Indexes),
13525 "views" => Ok(GeneratedField::Views),
13526 "functions" => Ok(GeneratedField::Functions),
13527 "connections" => Ok(GeneratedField::Connections),
13528 "subscriptions" => Ok(GeneratedField::Subscriptions),
13529 "users" => Ok(GeneratedField::Users),
13530 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13531 "secrets" => Ok(GeneratedField::Secrets),
13532 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13533 "nodes" => Ok(GeneratedField::Nodes),
13534 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13535 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13536 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13537 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13538 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13539 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
13540 "version" => Ok(GeneratedField::Version),
13541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13542 }
13543 }
13544 }
13545 deserializer.deserialize_identifier(GeneratedVisitor)
13546 }
13547 }
13548 struct GeneratedVisitor;
13549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13550 type Value = MetaSnapshot;
13551
13552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13553 formatter.write_str("struct meta.MetaSnapshot")
13554 }
13555
13556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13557 where
13558 V: serde::de::MapAccess<'de>,
13559 {
13560 let mut databases__ = None;
13561 let mut schemas__ = None;
13562 let mut sources__ = None;
13563 let mut sinks__ = None;
13564 let mut tables__ = None;
13565 let mut indexes__ = None;
13566 let mut views__ = None;
13567 let mut functions__ = None;
13568 let mut connections__ = None;
13569 let mut subscriptions__ = None;
13570 let mut users__ = None;
13571 let mut session_params__ = None;
13572 let mut secrets__ = None;
13573 let mut cluster_resource__ = None;
13574 let mut nodes__ = None;
13575 let mut hummock_version__ = None;
13576 let mut meta_backup_manifest_id__ = None;
13577 let mut hummock_write_limits__ = None;
13578 let mut streaming_worker_slot_mappings__ = None;
13579 let mut serving_worker_slot_mappings__ = None;
13580 let mut object_dependencies__ = None;
13581 let mut version__ = None;
13582 while let Some(k) = map_.next_key()? {
13583 match k {
13584 GeneratedField::Databases => {
13585 if databases__.is_some() {
13586 return Err(serde::de::Error::duplicate_field("databases"));
13587 }
13588 databases__ = Some(map_.next_value()?);
13589 }
13590 GeneratedField::Schemas => {
13591 if schemas__.is_some() {
13592 return Err(serde::de::Error::duplicate_field("schemas"));
13593 }
13594 schemas__ = Some(map_.next_value()?);
13595 }
13596 GeneratedField::Sources => {
13597 if sources__.is_some() {
13598 return Err(serde::de::Error::duplicate_field("sources"));
13599 }
13600 sources__ = Some(map_.next_value()?);
13601 }
13602 GeneratedField::Sinks => {
13603 if sinks__.is_some() {
13604 return Err(serde::de::Error::duplicate_field("sinks"));
13605 }
13606 sinks__ = Some(map_.next_value()?);
13607 }
13608 GeneratedField::Tables => {
13609 if tables__.is_some() {
13610 return Err(serde::de::Error::duplicate_field("tables"));
13611 }
13612 tables__ = Some(map_.next_value()?);
13613 }
13614 GeneratedField::Indexes => {
13615 if indexes__.is_some() {
13616 return Err(serde::de::Error::duplicate_field("indexes"));
13617 }
13618 indexes__ = Some(map_.next_value()?);
13619 }
13620 GeneratedField::Views => {
13621 if views__.is_some() {
13622 return Err(serde::de::Error::duplicate_field("views"));
13623 }
13624 views__ = Some(map_.next_value()?);
13625 }
13626 GeneratedField::Functions => {
13627 if functions__.is_some() {
13628 return Err(serde::de::Error::duplicate_field("functions"));
13629 }
13630 functions__ = Some(map_.next_value()?);
13631 }
13632 GeneratedField::Connections => {
13633 if connections__.is_some() {
13634 return Err(serde::de::Error::duplicate_field("connections"));
13635 }
13636 connections__ = Some(map_.next_value()?);
13637 }
13638 GeneratedField::Subscriptions => {
13639 if subscriptions__.is_some() {
13640 return Err(serde::de::Error::duplicate_field("subscriptions"));
13641 }
13642 subscriptions__ = Some(map_.next_value()?);
13643 }
13644 GeneratedField::Users => {
13645 if users__.is_some() {
13646 return Err(serde::de::Error::duplicate_field("users"));
13647 }
13648 users__ = Some(map_.next_value()?);
13649 }
13650 GeneratedField::SessionParams => {
13651 if session_params__.is_some() {
13652 return Err(serde::de::Error::duplicate_field("sessionParams"));
13653 }
13654 session_params__ = map_.next_value()?;
13655 }
13656 GeneratedField::Secrets => {
13657 if secrets__.is_some() {
13658 return Err(serde::de::Error::duplicate_field("secrets"));
13659 }
13660 secrets__ = Some(map_.next_value()?);
13661 }
13662 GeneratedField::ClusterResource => {
13663 if cluster_resource__.is_some() {
13664 return Err(serde::de::Error::duplicate_field("clusterResource"));
13665 }
13666 cluster_resource__ = map_.next_value()?;
13667 }
13668 GeneratedField::Nodes => {
13669 if nodes__.is_some() {
13670 return Err(serde::de::Error::duplicate_field("nodes"));
13671 }
13672 nodes__ = Some(map_.next_value()?);
13673 }
13674 GeneratedField::HummockVersion => {
13675 if hummock_version__.is_some() {
13676 return Err(serde::de::Error::duplicate_field("hummockVersion"));
13677 }
13678 hummock_version__ = map_.next_value()?;
13679 }
13680 GeneratedField::MetaBackupManifestId => {
13681 if meta_backup_manifest_id__.is_some() {
13682 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
13683 }
13684 meta_backup_manifest_id__ = map_.next_value()?;
13685 }
13686 GeneratedField::HummockWriteLimits => {
13687 if hummock_write_limits__.is_some() {
13688 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
13689 }
13690 hummock_write_limits__ = map_.next_value()?;
13691 }
13692 GeneratedField::StreamingWorkerSlotMappings => {
13693 if streaming_worker_slot_mappings__.is_some() {
13694 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
13695 }
13696 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
13697 }
13698 GeneratedField::ServingWorkerSlotMappings => {
13699 if serving_worker_slot_mappings__.is_some() {
13700 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
13701 }
13702 serving_worker_slot_mappings__ = Some(map_.next_value()?);
13703 }
13704 GeneratedField::ObjectDependencies => {
13705 if object_dependencies__.is_some() {
13706 return Err(serde::de::Error::duplicate_field("objectDependencies"));
13707 }
13708 object_dependencies__ = Some(map_.next_value()?);
13709 }
13710 GeneratedField::Version => {
13711 if version__.is_some() {
13712 return Err(serde::de::Error::duplicate_field("version"));
13713 }
13714 version__ = map_.next_value()?;
13715 }
13716 }
13717 }
13718 Ok(MetaSnapshot {
13719 databases: databases__.unwrap_or_default(),
13720 schemas: schemas__.unwrap_or_default(),
13721 sources: sources__.unwrap_or_default(),
13722 sinks: sinks__.unwrap_or_default(),
13723 tables: tables__.unwrap_or_default(),
13724 indexes: indexes__.unwrap_or_default(),
13725 views: views__.unwrap_or_default(),
13726 functions: functions__.unwrap_or_default(),
13727 connections: connections__.unwrap_or_default(),
13728 subscriptions: subscriptions__.unwrap_or_default(),
13729 users: users__.unwrap_or_default(),
13730 session_params: session_params__,
13731 secrets: secrets__.unwrap_or_default(),
13732 cluster_resource: cluster_resource__,
13733 nodes: nodes__.unwrap_or_default(),
13734 hummock_version: hummock_version__,
13735 meta_backup_manifest_id: meta_backup_manifest_id__,
13736 hummock_write_limits: hummock_write_limits__,
13737 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
13738 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
13739 object_dependencies: object_dependencies__.unwrap_or_default(),
13740 version: version__,
13741 })
13742 }
13743 }
13744 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
13745 }
13746}
13747impl serde::Serialize for meta_snapshot::SnapshotVersion {
13748 #[allow(deprecated)]
13749 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13750 where
13751 S: serde::Serializer,
13752 {
13753 use serde::ser::SerializeStruct;
13754 let mut len = 0;
13755 if self.catalog_version != 0 {
13756 len += 1;
13757 }
13758 if self.worker_node_version != 0 {
13759 len += 1;
13760 }
13761 if self.streaming_worker_slot_mapping_version != 0 {
13762 len += 1;
13763 }
13764 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
13765 if self.catalog_version != 0 {
13766 #[allow(clippy::needless_borrow)]
13767 #[allow(clippy::needless_borrows_for_generic_args)]
13768 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13769 }
13770 if self.worker_node_version != 0 {
13771 #[allow(clippy::needless_borrow)]
13772 #[allow(clippy::needless_borrows_for_generic_args)]
13773 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
13774 }
13775 if self.streaming_worker_slot_mapping_version != 0 {
13776 #[allow(clippy::needless_borrow)]
13777 #[allow(clippy::needless_borrows_for_generic_args)]
13778 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
13779 }
13780 struct_ser.end()
13781 }
13782}
13783impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
13784 #[allow(deprecated)]
13785 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13786 where
13787 D: serde::Deserializer<'de>,
13788 {
13789 const FIELDS: &[&str] = &[
13790 "catalog_version",
13791 "catalogVersion",
13792 "worker_node_version",
13793 "workerNodeVersion",
13794 "streaming_worker_slot_mapping_version",
13795 "streamingWorkerSlotMappingVersion",
13796 ];
13797
13798 #[allow(clippy::enum_variant_names)]
13799 enum GeneratedField {
13800 CatalogVersion,
13801 WorkerNodeVersion,
13802 StreamingWorkerSlotMappingVersion,
13803 }
13804 impl<'de> serde::Deserialize<'de> for GeneratedField {
13805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13806 where
13807 D: serde::Deserializer<'de>,
13808 {
13809 struct GeneratedVisitor;
13810
13811 impl serde::de::Visitor<'_> for GeneratedVisitor {
13812 type Value = GeneratedField;
13813
13814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13815 write!(formatter, "expected one of: {:?}", &FIELDS)
13816 }
13817
13818 #[allow(unused_variables)]
13819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13820 where
13821 E: serde::de::Error,
13822 {
13823 match value {
13824 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13825 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
13826 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
13827 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13828 }
13829 }
13830 }
13831 deserializer.deserialize_identifier(GeneratedVisitor)
13832 }
13833 }
13834 struct GeneratedVisitor;
13835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13836 type Value = meta_snapshot::SnapshotVersion;
13837
13838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13839 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
13840 }
13841
13842 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
13843 where
13844 V: serde::de::MapAccess<'de>,
13845 {
13846 let mut catalog_version__ = None;
13847 let mut worker_node_version__ = None;
13848 let mut streaming_worker_slot_mapping_version__ = None;
13849 while let Some(k) = map_.next_key()? {
13850 match k {
13851 GeneratedField::CatalogVersion => {
13852 if catalog_version__.is_some() {
13853 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13854 }
13855 catalog_version__ =
13856 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13857 ;
13858 }
13859 GeneratedField::WorkerNodeVersion => {
13860 if worker_node_version__.is_some() {
13861 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
13862 }
13863 worker_node_version__ =
13864 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13865 ;
13866 }
13867 GeneratedField::StreamingWorkerSlotMappingVersion => {
13868 if streaming_worker_slot_mapping_version__.is_some() {
13869 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
13870 }
13871 streaming_worker_slot_mapping_version__ =
13872 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13873 ;
13874 }
13875 }
13876 }
13877 Ok(meta_snapshot::SnapshotVersion {
13878 catalog_version: catalog_version__.unwrap_or_default(),
13879 worker_node_version: worker_node_version__.unwrap_or_default(),
13880 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
13881 })
13882 }
13883 }
13884 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
13885 }
13886}
13887impl serde::Serialize for MigrationPlan {
13888 #[allow(deprecated)]
13889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13890 where
13891 S: serde::Serializer,
13892 {
13893 use serde::ser::SerializeStruct;
13894 let mut len = 0;
13895 if !self.worker_slot_migration_plan.is_empty() {
13896 len += 1;
13897 }
13898 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
13899 if !self.worker_slot_migration_plan.is_empty() {
13900 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
13901 .map(|(k, v)| (k, v.to_string())).collect();
13902 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
13903 }
13904 struct_ser.end()
13905 }
13906}
13907impl<'de> serde::Deserialize<'de> for MigrationPlan {
13908 #[allow(deprecated)]
13909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13910 where
13911 D: serde::Deserializer<'de>,
13912 {
13913 const FIELDS: &[&str] = &[
13914 "worker_slot_migration_plan",
13915 "workerSlotMigrationPlan",
13916 ];
13917
13918 #[allow(clippy::enum_variant_names)]
13919 enum GeneratedField {
13920 WorkerSlotMigrationPlan,
13921 }
13922 impl<'de> serde::Deserialize<'de> for GeneratedField {
13923 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13924 where
13925 D: serde::Deserializer<'de>,
13926 {
13927 struct GeneratedVisitor;
13928
13929 impl serde::de::Visitor<'_> for GeneratedVisitor {
13930 type Value = GeneratedField;
13931
13932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13933 write!(formatter, "expected one of: {:?}", &FIELDS)
13934 }
13935
13936 #[allow(unused_variables)]
13937 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13938 where
13939 E: serde::de::Error,
13940 {
13941 match value {
13942 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
13943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13944 }
13945 }
13946 }
13947 deserializer.deserialize_identifier(GeneratedVisitor)
13948 }
13949 }
13950 struct GeneratedVisitor;
13951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13952 type Value = MigrationPlan;
13953
13954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13955 formatter.write_str("struct meta.MigrationPlan")
13956 }
13957
13958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
13959 where
13960 V: serde::de::MapAccess<'de>,
13961 {
13962 let mut worker_slot_migration_plan__ = None;
13963 while let Some(k) = map_.next_key()? {
13964 match k {
13965 GeneratedField::WorkerSlotMigrationPlan => {
13966 if worker_slot_migration_plan__.is_some() {
13967 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
13968 }
13969 worker_slot_migration_plan__ = Some(
13970 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
13971 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
13972 );
13973 }
13974 }
13975 }
13976 Ok(MigrationPlan {
13977 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
13978 })
13979 }
13980 }
13981 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
13982 }
13983}
13984impl serde::Serialize for Object {
13985 #[allow(deprecated)]
13986 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13987 where
13988 S: serde::Serializer,
13989 {
13990 use serde::ser::SerializeStruct;
13991 let mut len = 0;
13992 if self.object_info.is_some() {
13993 len += 1;
13994 }
13995 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
13996 if let Some(v) = self.object_info.as_ref() {
13997 match v {
13998 object::ObjectInfo::Database(v) => {
13999 struct_ser.serialize_field("database", v)?;
14000 }
14001 object::ObjectInfo::Schema(v) => {
14002 struct_ser.serialize_field("schema", v)?;
14003 }
14004 object::ObjectInfo::Table(v) => {
14005 struct_ser.serialize_field("table", v)?;
14006 }
14007 object::ObjectInfo::Index(v) => {
14008 struct_ser.serialize_field("index", v)?;
14009 }
14010 object::ObjectInfo::Source(v) => {
14011 struct_ser.serialize_field("source", v)?;
14012 }
14013 object::ObjectInfo::Sink(v) => {
14014 struct_ser.serialize_field("sink", v)?;
14015 }
14016 object::ObjectInfo::View(v) => {
14017 struct_ser.serialize_field("view", v)?;
14018 }
14019 object::ObjectInfo::Function(v) => {
14020 struct_ser.serialize_field("function", v)?;
14021 }
14022 object::ObjectInfo::Connection(v) => {
14023 struct_ser.serialize_field("connection", v)?;
14024 }
14025 object::ObjectInfo::Subscription(v) => {
14026 struct_ser.serialize_field("subscription", v)?;
14027 }
14028 object::ObjectInfo::Secret(v) => {
14029 struct_ser.serialize_field("secret", v)?;
14030 }
14031 }
14032 }
14033 struct_ser.end()
14034 }
14035}
14036impl<'de> serde::Deserialize<'de> for Object {
14037 #[allow(deprecated)]
14038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14039 where
14040 D: serde::Deserializer<'de>,
14041 {
14042 const FIELDS: &[&str] = &[
14043 "database",
14044 "schema",
14045 "table",
14046 "index",
14047 "source",
14048 "sink",
14049 "view",
14050 "function",
14051 "connection",
14052 "subscription",
14053 "secret",
14054 ];
14055
14056 #[allow(clippy::enum_variant_names)]
14057 enum GeneratedField {
14058 Database,
14059 Schema,
14060 Table,
14061 Index,
14062 Source,
14063 Sink,
14064 View,
14065 Function,
14066 Connection,
14067 Subscription,
14068 Secret,
14069 }
14070 impl<'de> serde::Deserialize<'de> for GeneratedField {
14071 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14072 where
14073 D: serde::Deserializer<'de>,
14074 {
14075 struct GeneratedVisitor;
14076
14077 impl serde::de::Visitor<'_> for GeneratedVisitor {
14078 type Value = GeneratedField;
14079
14080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14081 write!(formatter, "expected one of: {:?}", &FIELDS)
14082 }
14083
14084 #[allow(unused_variables)]
14085 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14086 where
14087 E: serde::de::Error,
14088 {
14089 match value {
14090 "database" => Ok(GeneratedField::Database),
14091 "schema" => Ok(GeneratedField::Schema),
14092 "table" => Ok(GeneratedField::Table),
14093 "index" => Ok(GeneratedField::Index),
14094 "source" => Ok(GeneratedField::Source),
14095 "sink" => Ok(GeneratedField::Sink),
14096 "view" => Ok(GeneratedField::View),
14097 "function" => Ok(GeneratedField::Function),
14098 "connection" => Ok(GeneratedField::Connection),
14099 "subscription" => Ok(GeneratedField::Subscription),
14100 "secret" => Ok(GeneratedField::Secret),
14101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14102 }
14103 }
14104 }
14105 deserializer.deserialize_identifier(GeneratedVisitor)
14106 }
14107 }
14108 struct GeneratedVisitor;
14109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14110 type Value = Object;
14111
14112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14113 formatter.write_str("struct meta.Object")
14114 }
14115
14116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14117 where
14118 V: serde::de::MapAccess<'de>,
14119 {
14120 let mut object_info__ = None;
14121 while let Some(k) = map_.next_key()? {
14122 match k {
14123 GeneratedField::Database => {
14124 if object_info__.is_some() {
14125 return Err(serde::de::Error::duplicate_field("database"));
14126 }
14127 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14128;
14129 }
14130 GeneratedField::Schema => {
14131 if object_info__.is_some() {
14132 return Err(serde::de::Error::duplicate_field("schema"));
14133 }
14134 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14135;
14136 }
14137 GeneratedField::Table => {
14138 if object_info__.is_some() {
14139 return Err(serde::de::Error::duplicate_field("table"));
14140 }
14141 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14142;
14143 }
14144 GeneratedField::Index => {
14145 if object_info__.is_some() {
14146 return Err(serde::de::Error::duplicate_field("index"));
14147 }
14148 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14149;
14150 }
14151 GeneratedField::Source => {
14152 if object_info__.is_some() {
14153 return Err(serde::de::Error::duplicate_field("source"));
14154 }
14155 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14156;
14157 }
14158 GeneratedField::Sink => {
14159 if object_info__.is_some() {
14160 return Err(serde::de::Error::duplicate_field("sink"));
14161 }
14162 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14163;
14164 }
14165 GeneratedField::View => {
14166 if object_info__.is_some() {
14167 return Err(serde::de::Error::duplicate_field("view"));
14168 }
14169 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14170;
14171 }
14172 GeneratedField::Function => {
14173 if object_info__.is_some() {
14174 return Err(serde::de::Error::duplicate_field("function"));
14175 }
14176 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14177;
14178 }
14179 GeneratedField::Connection => {
14180 if object_info__.is_some() {
14181 return Err(serde::de::Error::duplicate_field("connection"));
14182 }
14183 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14184;
14185 }
14186 GeneratedField::Subscription => {
14187 if object_info__.is_some() {
14188 return Err(serde::de::Error::duplicate_field("subscription"));
14189 }
14190 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14191;
14192 }
14193 GeneratedField::Secret => {
14194 if object_info__.is_some() {
14195 return Err(serde::de::Error::duplicate_field("secret"));
14196 }
14197 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14198;
14199 }
14200 }
14201 }
14202 Ok(Object {
14203 object_info: object_info__,
14204 })
14205 }
14206 }
14207 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14208 }
14209}
14210impl serde::Serialize for ObjectDependency {
14211 #[allow(deprecated)]
14212 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14213 where
14214 S: serde::Serializer,
14215 {
14216 use serde::ser::SerializeStruct;
14217 let mut len = 0;
14218 if self.object_id != 0 {
14219 len += 1;
14220 }
14221 if self.referenced_object_id != 0 {
14222 len += 1;
14223 }
14224 if self.referenced_object_type != 0 {
14225 len += 1;
14226 }
14227 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14228 if self.object_id != 0 {
14229 struct_ser.serialize_field("objectId", &self.object_id)?;
14230 }
14231 if self.referenced_object_id != 0 {
14232 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14233 }
14234 if self.referenced_object_type != 0 {
14235 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14236 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14237 struct_ser.serialize_field("referencedObjectType", &v)?;
14238 }
14239 struct_ser.end()
14240 }
14241}
14242impl<'de> serde::Deserialize<'de> for ObjectDependency {
14243 #[allow(deprecated)]
14244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14245 where
14246 D: serde::Deserializer<'de>,
14247 {
14248 const FIELDS: &[&str] = &[
14249 "object_id",
14250 "objectId",
14251 "referenced_object_id",
14252 "referencedObjectId",
14253 "referenced_object_type",
14254 "referencedObjectType",
14255 ];
14256
14257 #[allow(clippy::enum_variant_names)]
14258 enum GeneratedField {
14259 ObjectId,
14260 ReferencedObjectId,
14261 ReferencedObjectType,
14262 }
14263 impl<'de> serde::Deserialize<'de> for GeneratedField {
14264 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14265 where
14266 D: serde::Deserializer<'de>,
14267 {
14268 struct GeneratedVisitor;
14269
14270 impl serde::de::Visitor<'_> for GeneratedVisitor {
14271 type Value = GeneratedField;
14272
14273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14274 write!(formatter, "expected one of: {:?}", &FIELDS)
14275 }
14276
14277 #[allow(unused_variables)]
14278 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14279 where
14280 E: serde::de::Error,
14281 {
14282 match value {
14283 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14284 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14285 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14286 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14287 }
14288 }
14289 }
14290 deserializer.deserialize_identifier(GeneratedVisitor)
14291 }
14292 }
14293 struct GeneratedVisitor;
14294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14295 type Value = ObjectDependency;
14296
14297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14298 formatter.write_str("struct meta.ObjectDependency")
14299 }
14300
14301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14302 where
14303 V: serde::de::MapAccess<'de>,
14304 {
14305 let mut object_id__ = None;
14306 let mut referenced_object_id__ = None;
14307 let mut referenced_object_type__ = None;
14308 while let Some(k) = map_.next_key()? {
14309 match k {
14310 GeneratedField::ObjectId => {
14311 if object_id__.is_some() {
14312 return Err(serde::de::Error::duplicate_field("objectId"));
14313 }
14314 object_id__ =
14315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14316 ;
14317 }
14318 GeneratedField::ReferencedObjectId => {
14319 if referenced_object_id__.is_some() {
14320 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14321 }
14322 referenced_object_id__ =
14323 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14324 ;
14325 }
14326 GeneratedField::ReferencedObjectType => {
14327 if referenced_object_type__.is_some() {
14328 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14329 }
14330 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14331 }
14332 }
14333 }
14334 Ok(ObjectDependency {
14335 object_id: object_id__.unwrap_or_default(),
14336 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14337 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14338 })
14339 }
14340 }
14341 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14342 }
14343}
14344impl serde::Serialize for ObjectGroup {
14345 #[allow(deprecated)]
14346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14347 where
14348 S: serde::Serializer,
14349 {
14350 use serde::ser::SerializeStruct;
14351 let mut len = 0;
14352 if !self.objects.is_empty() {
14353 len += 1;
14354 }
14355 if !self.dependencies.is_empty() {
14356 len += 1;
14357 }
14358 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14359 if !self.objects.is_empty() {
14360 struct_ser.serialize_field("objects", &self.objects)?;
14361 }
14362 if !self.dependencies.is_empty() {
14363 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14364 }
14365 struct_ser.end()
14366 }
14367}
14368impl<'de> serde::Deserialize<'de> for ObjectGroup {
14369 #[allow(deprecated)]
14370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14371 where
14372 D: serde::Deserializer<'de>,
14373 {
14374 const FIELDS: &[&str] = &[
14375 "objects",
14376 "dependencies",
14377 ];
14378
14379 #[allow(clippy::enum_variant_names)]
14380 enum GeneratedField {
14381 Objects,
14382 Dependencies,
14383 }
14384 impl<'de> serde::Deserialize<'de> for GeneratedField {
14385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14386 where
14387 D: serde::Deserializer<'de>,
14388 {
14389 struct GeneratedVisitor;
14390
14391 impl serde::de::Visitor<'_> for GeneratedVisitor {
14392 type Value = GeneratedField;
14393
14394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14395 write!(formatter, "expected one of: {:?}", &FIELDS)
14396 }
14397
14398 #[allow(unused_variables)]
14399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14400 where
14401 E: serde::de::Error,
14402 {
14403 match value {
14404 "objects" => Ok(GeneratedField::Objects),
14405 "dependencies" => Ok(GeneratedField::Dependencies),
14406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14407 }
14408 }
14409 }
14410 deserializer.deserialize_identifier(GeneratedVisitor)
14411 }
14412 }
14413 struct GeneratedVisitor;
14414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14415 type Value = ObjectGroup;
14416
14417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14418 formatter.write_str("struct meta.ObjectGroup")
14419 }
14420
14421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
14422 where
14423 V: serde::de::MapAccess<'de>,
14424 {
14425 let mut objects__ = None;
14426 let mut dependencies__ = None;
14427 while let Some(k) = map_.next_key()? {
14428 match k {
14429 GeneratedField::Objects => {
14430 if objects__.is_some() {
14431 return Err(serde::de::Error::duplicate_field("objects"));
14432 }
14433 objects__ = Some(map_.next_value()?);
14434 }
14435 GeneratedField::Dependencies => {
14436 if dependencies__.is_some() {
14437 return Err(serde::de::Error::duplicate_field("dependencies"));
14438 }
14439 dependencies__ = Some(map_.next_value()?);
14440 }
14441 }
14442 }
14443 Ok(ObjectGroup {
14444 objects: objects__.unwrap_or_default(),
14445 dependencies: dependencies__.unwrap_or_default(),
14446 })
14447 }
14448 }
14449 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
14450 }
14451}
14452impl serde::Serialize for PauseRequest {
14453 #[allow(deprecated)]
14454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14455 where
14456 S: serde::Serializer,
14457 {
14458 use serde::ser::SerializeStruct;
14459 let len = 0;
14460 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
14461 struct_ser.end()
14462 }
14463}
14464impl<'de> serde::Deserialize<'de> for PauseRequest {
14465 #[allow(deprecated)]
14466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14467 where
14468 D: serde::Deserializer<'de>,
14469 {
14470 const FIELDS: &[&str] = &[
14471 ];
14472
14473 #[allow(clippy::enum_variant_names)]
14474 enum GeneratedField {
14475 }
14476 impl<'de> serde::Deserialize<'de> for GeneratedField {
14477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14478 where
14479 D: serde::Deserializer<'de>,
14480 {
14481 struct GeneratedVisitor;
14482
14483 impl serde::de::Visitor<'_> for GeneratedVisitor {
14484 type Value = GeneratedField;
14485
14486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14487 write!(formatter, "expected one of: {:?}", &FIELDS)
14488 }
14489
14490 #[allow(unused_variables)]
14491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14492 where
14493 E: serde::de::Error,
14494 {
14495 Err(serde::de::Error::unknown_field(value, FIELDS))
14496 }
14497 }
14498 deserializer.deserialize_identifier(GeneratedVisitor)
14499 }
14500 }
14501 struct GeneratedVisitor;
14502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14503 type Value = PauseRequest;
14504
14505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14506 formatter.write_str("struct meta.PauseRequest")
14507 }
14508
14509 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
14510 where
14511 V: serde::de::MapAccess<'de>,
14512 {
14513 while map_.next_key::<GeneratedField>()?.is_some() {
14514 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14515 }
14516 Ok(PauseRequest {
14517 })
14518 }
14519 }
14520 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
14521 }
14522}
14523impl serde::Serialize for PauseResponse {
14524 #[allow(deprecated)]
14525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14526 where
14527 S: serde::Serializer,
14528 {
14529 use serde::ser::SerializeStruct;
14530 let len = 0;
14531 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
14532 struct_ser.end()
14533 }
14534}
14535impl<'de> serde::Deserialize<'de> for PauseResponse {
14536 #[allow(deprecated)]
14537 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14538 where
14539 D: serde::Deserializer<'de>,
14540 {
14541 const FIELDS: &[&str] = &[
14542 ];
14543
14544 #[allow(clippy::enum_variant_names)]
14545 enum GeneratedField {
14546 }
14547 impl<'de> serde::Deserialize<'de> for GeneratedField {
14548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14549 where
14550 D: serde::Deserializer<'de>,
14551 {
14552 struct GeneratedVisitor;
14553
14554 impl serde::de::Visitor<'_> for GeneratedVisitor {
14555 type Value = GeneratedField;
14556
14557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14558 write!(formatter, "expected one of: {:?}", &FIELDS)
14559 }
14560
14561 #[allow(unused_variables)]
14562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14563 where
14564 E: serde::de::Error,
14565 {
14566 Err(serde::de::Error::unknown_field(value, FIELDS))
14567 }
14568 }
14569 deserializer.deserialize_identifier(GeneratedVisitor)
14570 }
14571 }
14572 struct GeneratedVisitor;
14573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14574 type Value = PauseResponse;
14575
14576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14577 formatter.write_str("struct meta.PauseResponse")
14578 }
14579
14580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
14581 where
14582 V: serde::de::MapAccess<'de>,
14583 {
14584 while map_.next_key::<GeneratedField>()?.is_some() {
14585 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14586 }
14587 Ok(PauseResponse {
14588 })
14589 }
14590 }
14591 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
14592 }
14593}
14594impl serde::Serialize for PropertyUpdateOptions {
14595 #[allow(deprecated)]
14596 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14597 where
14598 S: serde::Serializer,
14599 {
14600 use serde::ser::SerializeStruct;
14601 let mut len = 0;
14602 if self.reset_splits {
14603 len += 1;
14604 }
14605 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
14606 if self.reset_splits {
14607 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
14608 }
14609 struct_ser.end()
14610 }
14611}
14612impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
14613 #[allow(deprecated)]
14614 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14615 where
14616 D: serde::Deserializer<'de>,
14617 {
14618 const FIELDS: &[&str] = &[
14619 "reset_splits",
14620 "resetSplits",
14621 ];
14622
14623 #[allow(clippy::enum_variant_names)]
14624 enum GeneratedField {
14625 ResetSplits,
14626 }
14627 impl<'de> serde::Deserialize<'de> for GeneratedField {
14628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14629 where
14630 D: serde::Deserializer<'de>,
14631 {
14632 struct GeneratedVisitor;
14633
14634 impl serde::de::Visitor<'_> for GeneratedVisitor {
14635 type Value = GeneratedField;
14636
14637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14638 write!(formatter, "expected one of: {:?}", &FIELDS)
14639 }
14640
14641 #[allow(unused_variables)]
14642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14643 where
14644 E: serde::de::Error,
14645 {
14646 match value {
14647 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
14648 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14649 }
14650 }
14651 }
14652 deserializer.deserialize_identifier(GeneratedVisitor)
14653 }
14654 }
14655 struct GeneratedVisitor;
14656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14657 type Value = PropertyUpdateOptions;
14658
14659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14660 formatter.write_str("struct meta.PropertyUpdateOptions")
14661 }
14662
14663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
14664 where
14665 V: serde::de::MapAccess<'de>,
14666 {
14667 let mut reset_splits__ = None;
14668 while let Some(k) = map_.next_key()? {
14669 match k {
14670 GeneratedField::ResetSplits => {
14671 if reset_splits__.is_some() {
14672 return Err(serde::de::Error::duplicate_field("resetSplits"));
14673 }
14674 reset_splits__ = Some(map_.next_value()?);
14675 }
14676 }
14677 }
14678 Ok(PropertyUpdateOptions {
14679 reset_splits: reset_splits__.unwrap_or_default(),
14680 })
14681 }
14682 }
14683 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
14684 }
14685}
14686impl serde::Serialize for RecoverRequest {
14687 #[allow(deprecated)]
14688 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14689 where
14690 S: serde::Serializer,
14691 {
14692 use serde::ser::SerializeStruct;
14693 let len = 0;
14694 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
14695 struct_ser.end()
14696 }
14697}
14698impl<'de> serde::Deserialize<'de> for RecoverRequest {
14699 #[allow(deprecated)]
14700 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14701 where
14702 D: serde::Deserializer<'de>,
14703 {
14704 const FIELDS: &[&str] = &[
14705 ];
14706
14707 #[allow(clippy::enum_variant_names)]
14708 enum GeneratedField {
14709 }
14710 impl<'de> serde::Deserialize<'de> for GeneratedField {
14711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14712 where
14713 D: serde::Deserializer<'de>,
14714 {
14715 struct GeneratedVisitor;
14716
14717 impl serde::de::Visitor<'_> for GeneratedVisitor {
14718 type Value = GeneratedField;
14719
14720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14721 write!(formatter, "expected one of: {:?}", &FIELDS)
14722 }
14723
14724 #[allow(unused_variables)]
14725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14726 where
14727 E: serde::de::Error,
14728 {
14729 Err(serde::de::Error::unknown_field(value, FIELDS))
14730 }
14731 }
14732 deserializer.deserialize_identifier(GeneratedVisitor)
14733 }
14734 }
14735 struct GeneratedVisitor;
14736 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14737 type Value = RecoverRequest;
14738
14739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14740 formatter.write_str("struct meta.RecoverRequest")
14741 }
14742
14743 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
14744 where
14745 V: serde::de::MapAccess<'de>,
14746 {
14747 while map_.next_key::<GeneratedField>()?.is_some() {
14748 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14749 }
14750 Ok(RecoverRequest {
14751 })
14752 }
14753 }
14754 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
14755 }
14756}
14757impl serde::Serialize for RecoverResponse {
14758 #[allow(deprecated)]
14759 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14760 where
14761 S: serde::Serializer,
14762 {
14763 use serde::ser::SerializeStruct;
14764 let len = 0;
14765 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
14766 struct_ser.end()
14767 }
14768}
14769impl<'de> serde::Deserialize<'de> for RecoverResponse {
14770 #[allow(deprecated)]
14771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14772 where
14773 D: serde::Deserializer<'de>,
14774 {
14775 const FIELDS: &[&str] = &[
14776 ];
14777
14778 #[allow(clippy::enum_variant_names)]
14779 enum GeneratedField {
14780 }
14781 impl<'de> serde::Deserialize<'de> for GeneratedField {
14782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14783 where
14784 D: serde::Deserializer<'de>,
14785 {
14786 struct GeneratedVisitor;
14787
14788 impl serde::de::Visitor<'_> for GeneratedVisitor {
14789 type Value = GeneratedField;
14790
14791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14792 write!(formatter, "expected one of: {:?}", &FIELDS)
14793 }
14794
14795 #[allow(unused_variables)]
14796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14797 where
14798 E: serde::de::Error,
14799 {
14800 Err(serde::de::Error::unknown_field(value, FIELDS))
14801 }
14802 }
14803 deserializer.deserialize_identifier(GeneratedVisitor)
14804 }
14805 }
14806 struct GeneratedVisitor;
14807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14808 type Value = RecoverResponse;
14809
14810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14811 formatter.write_str("struct meta.RecoverResponse")
14812 }
14813
14814 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
14815 where
14816 V: serde::de::MapAccess<'de>,
14817 {
14818 while map_.next_key::<GeneratedField>()?.is_some() {
14819 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14820 }
14821 Ok(RecoverResponse {
14822 })
14823 }
14824 }
14825 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
14826 }
14827}
14828impl serde::Serialize for Recovery {
14829 #[allow(deprecated)]
14830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14831 where
14832 S: serde::Serializer,
14833 {
14834 use serde::ser::SerializeStruct;
14835 let len = 0;
14836 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
14837 struct_ser.end()
14838 }
14839}
14840impl<'de> serde::Deserialize<'de> for Recovery {
14841 #[allow(deprecated)]
14842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14843 where
14844 D: serde::Deserializer<'de>,
14845 {
14846 const FIELDS: &[&str] = &[
14847 ];
14848
14849 #[allow(clippy::enum_variant_names)]
14850 enum GeneratedField {
14851 }
14852 impl<'de> serde::Deserialize<'de> for GeneratedField {
14853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14854 where
14855 D: serde::Deserializer<'de>,
14856 {
14857 struct GeneratedVisitor;
14858
14859 impl serde::de::Visitor<'_> for GeneratedVisitor {
14860 type Value = GeneratedField;
14861
14862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14863 write!(formatter, "expected one of: {:?}", &FIELDS)
14864 }
14865
14866 #[allow(unused_variables)]
14867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14868 where
14869 E: serde::de::Error,
14870 {
14871 Err(serde::de::Error::unknown_field(value, FIELDS))
14872 }
14873 }
14874 deserializer.deserialize_identifier(GeneratedVisitor)
14875 }
14876 }
14877 struct GeneratedVisitor;
14878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14879 type Value = Recovery;
14880
14881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14882 formatter.write_str("struct meta.Recovery")
14883 }
14884
14885 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
14886 where
14887 V: serde::de::MapAccess<'de>,
14888 {
14889 while map_.next_key::<GeneratedField>()?.is_some() {
14890 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14891 }
14892 Ok(Recovery {
14893 })
14894 }
14895 }
14896 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
14897 }
14898}
14899impl serde::Serialize for RecoveryStatus {
14900 #[allow(deprecated)]
14901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14902 where
14903 S: serde::Serializer,
14904 {
14905 let variant = match self {
14906 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
14907 Self::StatusStarting => "STATUS_STARTING",
14908 Self::StatusRecovering => "STATUS_RECOVERING",
14909 Self::StatusRunning => "STATUS_RUNNING",
14910 };
14911 serializer.serialize_str(variant)
14912 }
14913}
14914impl<'de> serde::Deserialize<'de> for RecoveryStatus {
14915 #[allow(deprecated)]
14916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14917 where
14918 D: serde::Deserializer<'de>,
14919 {
14920 const FIELDS: &[&str] = &[
14921 "STATUS_UNSPECIFIED",
14922 "STATUS_STARTING",
14923 "STATUS_RECOVERING",
14924 "STATUS_RUNNING",
14925 ];
14926
14927 struct GeneratedVisitor;
14928
14929 impl serde::de::Visitor<'_> for GeneratedVisitor {
14930 type Value = RecoveryStatus;
14931
14932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14933 write!(formatter, "expected one of: {:?}", &FIELDS)
14934 }
14935
14936 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14937 where
14938 E: serde::de::Error,
14939 {
14940 i32::try_from(v)
14941 .ok()
14942 .and_then(|x| x.try_into().ok())
14943 .ok_or_else(|| {
14944 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14945 })
14946 }
14947
14948 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14949 where
14950 E: serde::de::Error,
14951 {
14952 i32::try_from(v)
14953 .ok()
14954 .and_then(|x| x.try_into().ok())
14955 .ok_or_else(|| {
14956 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14957 })
14958 }
14959
14960 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14961 where
14962 E: serde::de::Error,
14963 {
14964 match value {
14965 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
14966 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
14967 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
14968 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
14969 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14970 }
14971 }
14972 }
14973 deserializer.deserialize_any(GeneratedVisitor)
14974 }
14975}
14976impl serde::Serialize for RefreshRequest {
14977 #[allow(deprecated)]
14978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14979 where
14980 S: serde::Serializer,
14981 {
14982 use serde::ser::SerializeStruct;
14983 let mut len = 0;
14984 if self.table_id != 0 {
14985 len += 1;
14986 }
14987 if self.associated_source_id != 0 {
14988 len += 1;
14989 }
14990 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
14991 if self.table_id != 0 {
14992 struct_ser.serialize_field("tableId", &self.table_id)?;
14993 }
14994 if self.associated_source_id != 0 {
14995 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
14996 }
14997 struct_ser.end()
14998 }
14999}
15000impl<'de> serde::Deserialize<'de> for RefreshRequest {
15001 #[allow(deprecated)]
15002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15003 where
15004 D: serde::Deserializer<'de>,
15005 {
15006 const FIELDS: &[&str] = &[
15007 "table_id",
15008 "tableId",
15009 "associated_source_id",
15010 "associatedSourceId",
15011 ];
15012
15013 #[allow(clippy::enum_variant_names)]
15014 enum GeneratedField {
15015 TableId,
15016 AssociatedSourceId,
15017 }
15018 impl<'de> serde::Deserialize<'de> for GeneratedField {
15019 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15020 where
15021 D: serde::Deserializer<'de>,
15022 {
15023 struct GeneratedVisitor;
15024
15025 impl serde::de::Visitor<'_> for GeneratedVisitor {
15026 type Value = GeneratedField;
15027
15028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15029 write!(formatter, "expected one of: {:?}", &FIELDS)
15030 }
15031
15032 #[allow(unused_variables)]
15033 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15034 where
15035 E: serde::de::Error,
15036 {
15037 match value {
15038 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15039 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15040 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15041 }
15042 }
15043 }
15044 deserializer.deserialize_identifier(GeneratedVisitor)
15045 }
15046 }
15047 struct GeneratedVisitor;
15048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15049 type Value = RefreshRequest;
15050
15051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15052 formatter.write_str("struct meta.RefreshRequest")
15053 }
15054
15055 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15056 where
15057 V: serde::de::MapAccess<'de>,
15058 {
15059 let mut table_id__ = None;
15060 let mut associated_source_id__ = None;
15061 while let Some(k) = map_.next_key()? {
15062 match k {
15063 GeneratedField::TableId => {
15064 if table_id__.is_some() {
15065 return Err(serde::de::Error::duplicate_field("tableId"));
15066 }
15067 table_id__ =
15068 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15069 ;
15070 }
15071 GeneratedField::AssociatedSourceId => {
15072 if associated_source_id__.is_some() {
15073 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15074 }
15075 associated_source_id__ =
15076 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15077 ;
15078 }
15079 }
15080 }
15081 Ok(RefreshRequest {
15082 table_id: table_id__.unwrap_or_default(),
15083 associated_source_id: associated_source_id__.unwrap_or_default(),
15084 })
15085 }
15086 }
15087 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15088 }
15089}
15090impl serde::Serialize for RefreshResponse {
15091 #[allow(deprecated)]
15092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15093 where
15094 S: serde::Serializer,
15095 {
15096 use serde::ser::SerializeStruct;
15097 let mut len = 0;
15098 if self.status.is_some() {
15099 len += 1;
15100 }
15101 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15102 if let Some(v) = self.status.as_ref() {
15103 struct_ser.serialize_field("status", v)?;
15104 }
15105 struct_ser.end()
15106 }
15107}
15108impl<'de> serde::Deserialize<'de> for RefreshResponse {
15109 #[allow(deprecated)]
15110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15111 where
15112 D: serde::Deserializer<'de>,
15113 {
15114 const FIELDS: &[&str] = &[
15115 "status",
15116 ];
15117
15118 #[allow(clippy::enum_variant_names)]
15119 enum GeneratedField {
15120 Status,
15121 }
15122 impl<'de> serde::Deserialize<'de> for GeneratedField {
15123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15124 where
15125 D: serde::Deserializer<'de>,
15126 {
15127 struct GeneratedVisitor;
15128
15129 impl serde::de::Visitor<'_> for GeneratedVisitor {
15130 type Value = GeneratedField;
15131
15132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15133 write!(formatter, "expected one of: {:?}", &FIELDS)
15134 }
15135
15136 #[allow(unused_variables)]
15137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15138 where
15139 E: serde::de::Error,
15140 {
15141 match value {
15142 "status" => Ok(GeneratedField::Status),
15143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15144 }
15145 }
15146 }
15147 deserializer.deserialize_identifier(GeneratedVisitor)
15148 }
15149 }
15150 struct GeneratedVisitor;
15151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15152 type Value = RefreshResponse;
15153
15154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15155 formatter.write_str("struct meta.RefreshResponse")
15156 }
15157
15158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15159 where
15160 V: serde::de::MapAccess<'de>,
15161 {
15162 let mut status__ = None;
15163 while let Some(k) = map_.next_key()? {
15164 match k {
15165 GeneratedField::Status => {
15166 if status__.is_some() {
15167 return Err(serde::de::Error::duplicate_field("status"));
15168 }
15169 status__ = map_.next_value()?;
15170 }
15171 }
15172 }
15173 Ok(RefreshResponse {
15174 status: status__,
15175 })
15176 }
15177 }
15178 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15179 }
15180}
15181impl serde::Serialize for RelationIdInfos {
15182 #[allow(deprecated)]
15183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15184 where
15185 S: serde::Serializer,
15186 {
15187 use serde::ser::SerializeStruct;
15188 let mut len = 0;
15189 if !self.map.is_empty() {
15190 len += 1;
15191 }
15192 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15193 if !self.map.is_empty() {
15194 struct_ser.serialize_field("map", &self.map)?;
15195 }
15196 struct_ser.end()
15197 }
15198}
15199impl<'de> serde::Deserialize<'de> for RelationIdInfos {
15200 #[allow(deprecated)]
15201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15202 where
15203 D: serde::Deserializer<'de>,
15204 {
15205 const FIELDS: &[&str] = &[
15206 "map",
15207 ];
15208
15209 #[allow(clippy::enum_variant_names)]
15210 enum GeneratedField {
15211 Map,
15212 }
15213 impl<'de> serde::Deserialize<'de> for GeneratedField {
15214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15215 where
15216 D: serde::Deserializer<'de>,
15217 {
15218 struct GeneratedVisitor;
15219
15220 impl serde::de::Visitor<'_> for GeneratedVisitor {
15221 type Value = GeneratedField;
15222
15223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15224 write!(formatter, "expected one of: {:?}", &FIELDS)
15225 }
15226
15227 #[allow(unused_variables)]
15228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15229 where
15230 E: serde::de::Error,
15231 {
15232 match value {
15233 "map" => Ok(GeneratedField::Map),
15234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15235 }
15236 }
15237 }
15238 deserializer.deserialize_identifier(GeneratedVisitor)
15239 }
15240 }
15241 struct GeneratedVisitor;
15242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15243 type Value = RelationIdInfos;
15244
15245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15246 formatter.write_str("struct meta.RelationIdInfos")
15247 }
15248
15249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15250 where
15251 V: serde::de::MapAccess<'de>,
15252 {
15253 let mut map__ = None;
15254 while let Some(k) = map_.next_key()? {
15255 match k {
15256 GeneratedField::Map => {
15257 if map__.is_some() {
15258 return Err(serde::de::Error::duplicate_field("map"));
15259 }
15260 map__ = Some(
15261 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15262 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15263 );
15264 }
15265 }
15266 }
15267 Ok(RelationIdInfos {
15268 map: map__.unwrap_or_default(),
15269 })
15270 }
15271 }
15272 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15273 }
15274}
15275impl serde::Serialize for RescheduleRequest {
15276 #[allow(deprecated)]
15277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15278 where
15279 S: serde::Serializer,
15280 {
15281 use serde::ser::SerializeStruct;
15282 let mut len = 0;
15283 if self.revision != 0 {
15284 len += 1;
15285 }
15286 if self.resolve_no_shuffle_upstream {
15287 len += 1;
15288 }
15289 if !self.worker_reschedules.is_empty() {
15290 len += 1;
15291 }
15292 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15293 if self.revision != 0 {
15294 #[allow(clippy::needless_borrow)]
15295 #[allow(clippy::needless_borrows_for_generic_args)]
15296 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15297 }
15298 if self.resolve_no_shuffle_upstream {
15299 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15300 }
15301 if !self.worker_reschedules.is_empty() {
15302 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15303 }
15304 struct_ser.end()
15305 }
15306}
15307impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15308 #[allow(deprecated)]
15309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15310 where
15311 D: serde::Deserializer<'de>,
15312 {
15313 const FIELDS: &[&str] = &[
15314 "revision",
15315 "resolve_no_shuffle_upstream",
15316 "resolveNoShuffleUpstream",
15317 "worker_reschedules",
15318 "workerReschedules",
15319 ];
15320
15321 #[allow(clippy::enum_variant_names)]
15322 enum GeneratedField {
15323 Revision,
15324 ResolveNoShuffleUpstream,
15325 WorkerReschedules,
15326 }
15327 impl<'de> serde::Deserialize<'de> for GeneratedField {
15328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15329 where
15330 D: serde::Deserializer<'de>,
15331 {
15332 struct GeneratedVisitor;
15333
15334 impl serde::de::Visitor<'_> for GeneratedVisitor {
15335 type Value = GeneratedField;
15336
15337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15338 write!(formatter, "expected one of: {:?}", &FIELDS)
15339 }
15340
15341 #[allow(unused_variables)]
15342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15343 where
15344 E: serde::de::Error,
15345 {
15346 match value {
15347 "revision" => Ok(GeneratedField::Revision),
15348 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15349 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15350 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15351 }
15352 }
15353 }
15354 deserializer.deserialize_identifier(GeneratedVisitor)
15355 }
15356 }
15357 struct GeneratedVisitor;
15358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15359 type Value = RescheduleRequest;
15360
15361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15362 formatter.write_str("struct meta.RescheduleRequest")
15363 }
15364
15365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15366 where
15367 V: serde::de::MapAccess<'de>,
15368 {
15369 let mut revision__ = None;
15370 let mut resolve_no_shuffle_upstream__ = None;
15371 let mut worker_reschedules__ = None;
15372 while let Some(k) = map_.next_key()? {
15373 match k {
15374 GeneratedField::Revision => {
15375 if revision__.is_some() {
15376 return Err(serde::de::Error::duplicate_field("revision"));
15377 }
15378 revision__ =
15379 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15380 ;
15381 }
15382 GeneratedField::ResolveNoShuffleUpstream => {
15383 if resolve_no_shuffle_upstream__.is_some() {
15384 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
15385 }
15386 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
15387 }
15388 GeneratedField::WorkerReschedules => {
15389 if worker_reschedules__.is_some() {
15390 return Err(serde::de::Error::duplicate_field("workerReschedules"));
15391 }
15392 worker_reschedules__ = Some(
15393 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15394 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15395 );
15396 }
15397 }
15398 }
15399 Ok(RescheduleRequest {
15400 revision: revision__.unwrap_or_default(),
15401 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
15402 worker_reschedules: worker_reschedules__.unwrap_or_default(),
15403 })
15404 }
15405 }
15406 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
15407 }
15408}
15409impl serde::Serialize for RescheduleResponse {
15410 #[allow(deprecated)]
15411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15412 where
15413 S: serde::Serializer,
15414 {
15415 use serde::ser::SerializeStruct;
15416 let mut len = 0;
15417 if self.success {
15418 len += 1;
15419 }
15420 if self.revision != 0 {
15421 len += 1;
15422 }
15423 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
15424 if self.success {
15425 struct_ser.serialize_field("success", &self.success)?;
15426 }
15427 if self.revision != 0 {
15428 #[allow(clippy::needless_borrow)]
15429 #[allow(clippy::needless_borrows_for_generic_args)]
15430 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15431 }
15432 struct_ser.end()
15433 }
15434}
15435impl<'de> serde::Deserialize<'de> for RescheduleResponse {
15436 #[allow(deprecated)]
15437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15438 where
15439 D: serde::Deserializer<'de>,
15440 {
15441 const FIELDS: &[&str] = &[
15442 "success",
15443 "revision",
15444 ];
15445
15446 #[allow(clippy::enum_variant_names)]
15447 enum GeneratedField {
15448 Success,
15449 Revision,
15450 }
15451 impl<'de> serde::Deserialize<'de> for GeneratedField {
15452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15453 where
15454 D: serde::Deserializer<'de>,
15455 {
15456 struct GeneratedVisitor;
15457
15458 impl serde::de::Visitor<'_> for GeneratedVisitor {
15459 type Value = GeneratedField;
15460
15461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15462 write!(formatter, "expected one of: {:?}", &FIELDS)
15463 }
15464
15465 #[allow(unused_variables)]
15466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15467 where
15468 E: serde::de::Error,
15469 {
15470 match value {
15471 "success" => Ok(GeneratedField::Success),
15472 "revision" => Ok(GeneratedField::Revision),
15473 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15474 }
15475 }
15476 }
15477 deserializer.deserialize_identifier(GeneratedVisitor)
15478 }
15479 }
15480 struct GeneratedVisitor;
15481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15482 type Value = RescheduleResponse;
15483
15484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15485 formatter.write_str("struct meta.RescheduleResponse")
15486 }
15487
15488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
15489 where
15490 V: serde::de::MapAccess<'de>,
15491 {
15492 let mut success__ = None;
15493 let mut revision__ = None;
15494 while let Some(k) = map_.next_key()? {
15495 match k {
15496 GeneratedField::Success => {
15497 if success__.is_some() {
15498 return Err(serde::de::Error::duplicate_field("success"));
15499 }
15500 success__ = Some(map_.next_value()?);
15501 }
15502 GeneratedField::Revision => {
15503 if revision__.is_some() {
15504 return Err(serde::de::Error::duplicate_field("revision"));
15505 }
15506 revision__ =
15507 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15508 ;
15509 }
15510 }
15511 }
15512 Ok(RescheduleResponse {
15513 success: success__.unwrap_or_default(),
15514 revision: revision__.unwrap_or_default(),
15515 })
15516 }
15517 }
15518 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
15519 }
15520}
15521impl serde::Serialize for ResetSourceSplitsRequest {
15522 #[allow(deprecated)]
15523 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15524 where
15525 S: serde::Serializer,
15526 {
15527 use serde::ser::SerializeStruct;
15528 let mut len = 0;
15529 if self.source_id != 0 {
15530 len += 1;
15531 }
15532 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
15533 if self.source_id != 0 {
15534 struct_ser.serialize_field("sourceId", &self.source_id)?;
15535 }
15536 struct_ser.end()
15537 }
15538}
15539impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
15540 #[allow(deprecated)]
15541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15542 where
15543 D: serde::Deserializer<'de>,
15544 {
15545 const FIELDS: &[&str] = &[
15546 "source_id",
15547 "sourceId",
15548 ];
15549
15550 #[allow(clippy::enum_variant_names)]
15551 enum GeneratedField {
15552 SourceId,
15553 }
15554 impl<'de> serde::Deserialize<'de> for GeneratedField {
15555 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15556 where
15557 D: serde::Deserializer<'de>,
15558 {
15559 struct GeneratedVisitor;
15560
15561 impl serde::de::Visitor<'_> for GeneratedVisitor {
15562 type Value = GeneratedField;
15563
15564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15565 write!(formatter, "expected one of: {:?}", &FIELDS)
15566 }
15567
15568 #[allow(unused_variables)]
15569 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15570 where
15571 E: serde::de::Error,
15572 {
15573 match value {
15574 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15575 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15576 }
15577 }
15578 }
15579 deserializer.deserialize_identifier(GeneratedVisitor)
15580 }
15581 }
15582 struct GeneratedVisitor;
15583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15584 type Value = ResetSourceSplitsRequest;
15585
15586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15587 formatter.write_str("struct meta.ResetSourceSplitsRequest")
15588 }
15589
15590 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
15591 where
15592 V: serde::de::MapAccess<'de>,
15593 {
15594 let mut source_id__ = None;
15595 while let Some(k) = map_.next_key()? {
15596 match k {
15597 GeneratedField::SourceId => {
15598 if source_id__.is_some() {
15599 return Err(serde::de::Error::duplicate_field("sourceId"));
15600 }
15601 source_id__ =
15602 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15603 ;
15604 }
15605 }
15606 }
15607 Ok(ResetSourceSplitsRequest {
15608 source_id: source_id__.unwrap_or_default(),
15609 })
15610 }
15611 }
15612 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
15613 }
15614}
15615impl serde::Serialize for ResetSourceSplitsResponse {
15616 #[allow(deprecated)]
15617 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15618 where
15619 S: serde::Serializer,
15620 {
15621 use serde::ser::SerializeStruct;
15622 let len = 0;
15623 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
15624 struct_ser.end()
15625 }
15626}
15627impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
15628 #[allow(deprecated)]
15629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15630 where
15631 D: serde::Deserializer<'de>,
15632 {
15633 const FIELDS: &[&str] = &[
15634 ];
15635
15636 #[allow(clippy::enum_variant_names)]
15637 enum GeneratedField {
15638 }
15639 impl<'de> serde::Deserialize<'de> for GeneratedField {
15640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15641 where
15642 D: serde::Deserializer<'de>,
15643 {
15644 struct GeneratedVisitor;
15645
15646 impl serde::de::Visitor<'_> for GeneratedVisitor {
15647 type Value = GeneratedField;
15648
15649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15650 write!(formatter, "expected one of: {:?}", &FIELDS)
15651 }
15652
15653 #[allow(unused_variables)]
15654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15655 where
15656 E: serde::de::Error,
15657 {
15658 Err(serde::de::Error::unknown_field(value, FIELDS))
15659 }
15660 }
15661 deserializer.deserialize_identifier(GeneratedVisitor)
15662 }
15663 }
15664 struct GeneratedVisitor;
15665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15666 type Value = ResetSourceSplitsResponse;
15667
15668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15669 formatter.write_str("struct meta.ResetSourceSplitsResponse")
15670 }
15671
15672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
15673 where
15674 V: serde::de::MapAccess<'de>,
15675 {
15676 while map_.next_key::<GeneratedField>()?.is_some() {
15677 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15678 }
15679 Ok(ResetSourceSplitsResponse {
15680 })
15681 }
15682 }
15683 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
15684 }
15685}
15686impl serde::Serialize for ResumeRequest {
15687 #[allow(deprecated)]
15688 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15689 where
15690 S: serde::Serializer,
15691 {
15692 use serde::ser::SerializeStruct;
15693 let len = 0;
15694 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
15695 struct_ser.end()
15696 }
15697}
15698impl<'de> serde::Deserialize<'de> for ResumeRequest {
15699 #[allow(deprecated)]
15700 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15701 where
15702 D: serde::Deserializer<'de>,
15703 {
15704 const FIELDS: &[&str] = &[
15705 ];
15706
15707 #[allow(clippy::enum_variant_names)]
15708 enum GeneratedField {
15709 }
15710 impl<'de> serde::Deserialize<'de> for GeneratedField {
15711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15712 where
15713 D: serde::Deserializer<'de>,
15714 {
15715 struct GeneratedVisitor;
15716
15717 impl serde::de::Visitor<'_> for GeneratedVisitor {
15718 type Value = GeneratedField;
15719
15720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15721 write!(formatter, "expected one of: {:?}", &FIELDS)
15722 }
15723
15724 #[allow(unused_variables)]
15725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15726 where
15727 E: serde::de::Error,
15728 {
15729 Err(serde::de::Error::unknown_field(value, FIELDS))
15730 }
15731 }
15732 deserializer.deserialize_identifier(GeneratedVisitor)
15733 }
15734 }
15735 struct GeneratedVisitor;
15736 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15737 type Value = ResumeRequest;
15738
15739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15740 formatter.write_str("struct meta.ResumeRequest")
15741 }
15742
15743 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
15744 where
15745 V: serde::de::MapAccess<'de>,
15746 {
15747 while map_.next_key::<GeneratedField>()?.is_some() {
15748 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15749 }
15750 Ok(ResumeRequest {
15751 })
15752 }
15753 }
15754 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
15755 }
15756}
15757impl serde::Serialize for ResumeResponse {
15758 #[allow(deprecated)]
15759 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15760 where
15761 S: serde::Serializer,
15762 {
15763 use serde::ser::SerializeStruct;
15764 let len = 0;
15765 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
15766 struct_ser.end()
15767 }
15768}
15769impl<'de> serde::Deserialize<'de> for ResumeResponse {
15770 #[allow(deprecated)]
15771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15772 where
15773 D: serde::Deserializer<'de>,
15774 {
15775 const FIELDS: &[&str] = &[
15776 ];
15777
15778 #[allow(clippy::enum_variant_names)]
15779 enum GeneratedField {
15780 }
15781 impl<'de> serde::Deserialize<'de> for GeneratedField {
15782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15783 where
15784 D: serde::Deserializer<'de>,
15785 {
15786 struct GeneratedVisitor;
15787
15788 impl serde::de::Visitor<'_> for GeneratedVisitor {
15789 type Value = GeneratedField;
15790
15791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15792 write!(formatter, "expected one of: {:?}", &FIELDS)
15793 }
15794
15795 #[allow(unused_variables)]
15796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15797 where
15798 E: serde::de::Error,
15799 {
15800 Err(serde::de::Error::unknown_field(value, FIELDS))
15801 }
15802 }
15803 deserializer.deserialize_identifier(GeneratedVisitor)
15804 }
15805 }
15806 struct GeneratedVisitor;
15807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15808 type Value = ResumeResponse;
15809
15810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15811 formatter.write_str("struct meta.ResumeResponse")
15812 }
15813
15814 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
15815 where
15816 V: serde::de::MapAccess<'de>,
15817 {
15818 while map_.next_key::<GeneratedField>()?.is_some() {
15819 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15820 }
15821 Ok(ResumeResponse {
15822 })
15823 }
15824 }
15825 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
15826 }
15827}
15828impl serde::Serialize for SetSessionParamRequest {
15829 #[allow(deprecated)]
15830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15831 where
15832 S: serde::Serializer,
15833 {
15834 use serde::ser::SerializeStruct;
15835 let mut len = 0;
15836 if !self.param.is_empty() {
15837 len += 1;
15838 }
15839 if self.value.is_some() {
15840 len += 1;
15841 }
15842 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
15843 if !self.param.is_empty() {
15844 struct_ser.serialize_field("param", &self.param)?;
15845 }
15846 if let Some(v) = self.value.as_ref() {
15847 struct_ser.serialize_field("value", v)?;
15848 }
15849 struct_ser.end()
15850 }
15851}
15852impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
15853 #[allow(deprecated)]
15854 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15855 where
15856 D: serde::Deserializer<'de>,
15857 {
15858 const FIELDS: &[&str] = &[
15859 "param",
15860 "value",
15861 ];
15862
15863 #[allow(clippy::enum_variant_names)]
15864 enum GeneratedField {
15865 Param,
15866 Value,
15867 }
15868 impl<'de> serde::Deserialize<'de> for GeneratedField {
15869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15870 where
15871 D: serde::Deserializer<'de>,
15872 {
15873 struct GeneratedVisitor;
15874
15875 impl serde::de::Visitor<'_> for GeneratedVisitor {
15876 type Value = GeneratedField;
15877
15878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15879 write!(formatter, "expected one of: {:?}", &FIELDS)
15880 }
15881
15882 #[allow(unused_variables)]
15883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15884 where
15885 E: serde::de::Error,
15886 {
15887 match value {
15888 "param" => Ok(GeneratedField::Param),
15889 "value" => Ok(GeneratedField::Value),
15890 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15891 }
15892 }
15893 }
15894 deserializer.deserialize_identifier(GeneratedVisitor)
15895 }
15896 }
15897 struct GeneratedVisitor;
15898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15899 type Value = SetSessionParamRequest;
15900
15901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15902 formatter.write_str("struct meta.SetSessionParamRequest")
15903 }
15904
15905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
15906 where
15907 V: serde::de::MapAccess<'de>,
15908 {
15909 let mut param__ = None;
15910 let mut value__ = None;
15911 while let Some(k) = map_.next_key()? {
15912 match k {
15913 GeneratedField::Param => {
15914 if param__.is_some() {
15915 return Err(serde::de::Error::duplicate_field("param"));
15916 }
15917 param__ = Some(map_.next_value()?);
15918 }
15919 GeneratedField::Value => {
15920 if value__.is_some() {
15921 return Err(serde::de::Error::duplicate_field("value"));
15922 }
15923 value__ = map_.next_value()?;
15924 }
15925 }
15926 }
15927 Ok(SetSessionParamRequest {
15928 param: param__.unwrap_or_default(),
15929 value: value__,
15930 })
15931 }
15932 }
15933 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
15934 }
15935}
15936impl serde::Serialize for SetSessionParamResponse {
15937 #[allow(deprecated)]
15938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15939 where
15940 S: serde::Serializer,
15941 {
15942 use serde::ser::SerializeStruct;
15943 let mut len = 0;
15944 if !self.param.is_empty() {
15945 len += 1;
15946 }
15947 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
15948 if !self.param.is_empty() {
15949 struct_ser.serialize_field("param", &self.param)?;
15950 }
15951 struct_ser.end()
15952 }
15953}
15954impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
15955 #[allow(deprecated)]
15956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15957 where
15958 D: serde::Deserializer<'de>,
15959 {
15960 const FIELDS: &[&str] = &[
15961 "param",
15962 ];
15963
15964 #[allow(clippy::enum_variant_names)]
15965 enum GeneratedField {
15966 Param,
15967 }
15968 impl<'de> serde::Deserialize<'de> for GeneratedField {
15969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15970 where
15971 D: serde::Deserializer<'de>,
15972 {
15973 struct GeneratedVisitor;
15974
15975 impl serde::de::Visitor<'_> for GeneratedVisitor {
15976 type Value = GeneratedField;
15977
15978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15979 write!(formatter, "expected one of: {:?}", &FIELDS)
15980 }
15981
15982 #[allow(unused_variables)]
15983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15984 where
15985 E: serde::de::Error,
15986 {
15987 match value {
15988 "param" => Ok(GeneratedField::Param),
15989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15990 }
15991 }
15992 }
15993 deserializer.deserialize_identifier(GeneratedVisitor)
15994 }
15995 }
15996 struct GeneratedVisitor;
15997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15998 type Value = SetSessionParamResponse;
15999
16000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16001 formatter.write_str("struct meta.SetSessionParamResponse")
16002 }
16003
16004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16005 where
16006 V: serde::de::MapAccess<'de>,
16007 {
16008 let mut param__ = None;
16009 while let Some(k) = map_.next_key()? {
16010 match k {
16011 GeneratedField::Param => {
16012 if param__.is_some() {
16013 return Err(serde::de::Error::duplicate_field("param"));
16014 }
16015 param__ = Some(map_.next_value()?);
16016 }
16017 }
16018 }
16019 Ok(SetSessionParamResponse {
16020 param: param__.unwrap_or_default(),
16021 })
16022 }
16023 }
16024 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16025 }
16026}
16027impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16028 #[allow(deprecated)]
16029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16030 where
16031 S: serde::Serializer,
16032 {
16033 use serde::ser::SerializeStruct;
16034 let mut len = 0;
16035 if self.job_id != 0 {
16036 len += 1;
16037 }
16038 if self.aligned {
16039 len += 1;
16040 }
16041 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16042 if self.job_id != 0 {
16043 struct_ser.serialize_field("jobId", &self.job_id)?;
16044 }
16045 if self.aligned {
16046 struct_ser.serialize_field("aligned", &self.aligned)?;
16047 }
16048 struct_ser.end()
16049 }
16050}
16051impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16052 #[allow(deprecated)]
16053 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16054 where
16055 D: serde::Deserializer<'de>,
16056 {
16057 const FIELDS: &[&str] = &[
16058 "job_id",
16059 "jobId",
16060 "aligned",
16061 ];
16062
16063 #[allow(clippy::enum_variant_names)]
16064 enum GeneratedField {
16065 JobId,
16066 Aligned,
16067 }
16068 impl<'de> serde::Deserialize<'de> for GeneratedField {
16069 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16070 where
16071 D: serde::Deserializer<'de>,
16072 {
16073 struct GeneratedVisitor;
16074
16075 impl serde::de::Visitor<'_> for GeneratedVisitor {
16076 type Value = GeneratedField;
16077
16078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16079 write!(formatter, "expected one of: {:?}", &FIELDS)
16080 }
16081
16082 #[allow(unused_variables)]
16083 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16084 where
16085 E: serde::de::Error,
16086 {
16087 match value {
16088 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16089 "aligned" => Ok(GeneratedField::Aligned),
16090 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16091 }
16092 }
16093 }
16094 deserializer.deserialize_identifier(GeneratedVisitor)
16095 }
16096 }
16097 struct GeneratedVisitor;
16098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16099 type Value = SetSyncLogStoreAlignedRequest;
16100
16101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16102 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16103 }
16104
16105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16106 where
16107 V: serde::de::MapAccess<'de>,
16108 {
16109 let mut job_id__ = None;
16110 let mut aligned__ = None;
16111 while let Some(k) = map_.next_key()? {
16112 match k {
16113 GeneratedField::JobId => {
16114 if job_id__.is_some() {
16115 return Err(serde::de::Error::duplicate_field("jobId"));
16116 }
16117 job_id__ =
16118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16119 ;
16120 }
16121 GeneratedField::Aligned => {
16122 if aligned__.is_some() {
16123 return Err(serde::de::Error::duplicate_field("aligned"));
16124 }
16125 aligned__ = Some(map_.next_value()?);
16126 }
16127 }
16128 }
16129 Ok(SetSyncLogStoreAlignedRequest {
16130 job_id: job_id__.unwrap_or_default(),
16131 aligned: aligned__.unwrap_or_default(),
16132 })
16133 }
16134 }
16135 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16136 }
16137}
16138impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16139 #[allow(deprecated)]
16140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16141 where
16142 S: serde::Serializer,
16143 {
16144 use serde::ser::SerializeStruct;
16145 let len = 0;
16146 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16147 struct_ser.end()
16148 }
16149}
16150impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16151 #[allow(deprecated)]
16152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16153 where
16154 D: serde::Deserializer<'de>,
16155 {
16156 const FIELDS: &[&str] = &[
16157 ];
16158
16159 #[allow(clippy::enum_variant_names)]
16160 enum GeneratedField {
16161 }
16162 impl<'de> serde::Deserialize<'de> for GeneratedField {
16163 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16164 where
16165 D: serde::Deserializer<'de>,
16166 {
16167 struct GeneratedVisitor;
16168
16169 impl serde::de::Visitor<'_> for GeneratedVisitor {
16170 type Value = GeneratedField;
16171
16172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16173 write!(formatter, "expected one of: {:?}", &FIELDS)
16174 }
16175
16176 #[allow(unused_variables)]
16177 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16178 where
16179 E: serde::de::Error,
16180 {
16181 Err(serde::de::Error::unknown_field(value, FIELDS))
16182 }
16183 }
16184 deserializer.deserialize_identifier(GeneratedVisitor)
16185 }
16186 }
16187 struct GeneratedVisitor;
16188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16189 type Value = SetSyncLogStoreAlignedResponse;
16190
16191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16192 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
16193 }
16194
16195 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
16196 where
16197 V: serde::de::MapAccess<'de>,
16198 {
16199 while map_.next_key::<GeneratedField>()?.is_some() {
16200 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16201 }
16202 Ok(SetSyncLogStoreAlignedResponse {
16203 })
16204 }
16205 }
16206 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
16207 }
16208}
16209impl serde::Serialize for SetSystemParamRequest {
16210 #[allow(deprecated)]
16211 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16212 where
16213 S: serde::Serializer,
16214 {
16215 use serde::ser::SerializeStruct;
16216 let mut len = 0;
16217 if !self.param.is_empty() {
16218 len += 1;
16219 }
16220 if self.value.is_some() {
16221 len += 1;
16222 }
16223 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
16224 if !self.param.is_empty() {
16225 struct_ser.serialize_field("param", &self.param)?;
16226 }
16227 if let Some(v) = self.value.as_ref() {
16228 struct_ser.serialize_field("value", v)?;
16229 }
16230 struct_ser.end()
16231 }
16232}
16233impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
16234 #[allow(deprecated)]
16235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16236 where
16237 D: serde::Deserializer<'de>,
16238 {
16239 const FIELDS: &[&str] = &[
16240 "param",
16241 "value",
16242 ];
16243
16244 #[allow(clippy::enum_variant_names)]
16245 enum GeneratedField {
16246 Param,
16247 Value,
16248 }
16249 impl<'de> serde::Deserialize<'de> for GeneratedField {
16250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16251 where
16252 D: serde::Deserializer<'de>,
16253 {
16254 struct GeneratedVisitor;
16255
16256 impl serde::de::Visitor<'_> for GeneratedVisitor {
16257 type Value = GeneratedField;
16258
16259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16260 write!(formatter, "expected one of: {:?}", &FIELDS)
16261 }
16262
16263 #[allow(unused_variables)]
16264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16265 where
16266 E: serde::de::Error,
16267 {
16268 match value {
16269 "param" => Ok(GeneratedField::Param),
16270 "value" => Ok(GeneratedField::Value),
16271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16272 }
16273 }
16274 }
16275 deserializer.deserialize_identifier(GeneratedVisitor)
16276 }
16277 }
16278 struct GeneratedVisitor;
16279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16280 type Value = SetSystemParamRequest;
16281
16282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16283 formatter.write_str("struct meta.SetSystemParamRequest")
16284 }
16285
16286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
16287 where
16288 V: serde::de::MapAccess<'de>,
16289 {
16290 let mut param__ = None;
16291 let mut value__ = None;
16292 while let Some(k) = map_.next_key()? {
16293 match k {
16294 GeneratedField::Param => {
16295 if param__.is_some() {
16296 return Err(serde::de::Error::duplicate_field("param"));
16297 }
16298 param__ = Some(map_.next_value()?);
16299 }
16300 GeneratedField::Value => {
16301 if value__.is_some() {
16302 return Err(serde::de::Error::duplicate_field("value"));
16303 }
16304 value__ = map_.next_value()?;
16305 }
16306 }
16307 }
16308 Ok(SetSystemParamRequest {
16309 param: param__.unwrap_or_default(),
16310 value: value__,
16311 })
16312 }
16313 }
16314 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
16315 }
16316}
16317impl serde::Serialize for SetSystemParamResponse {
16318 #[allow(deprecated)]
16319 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16320 where
16321 S: serde::Serializer,
16322 {
16323 use serde::ser::SerializeStruct;
16324 let mut len = 0;
16325 if self.params.is_some() {
16326 len += 1;
16327 }
16328 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
16329 if let Some(v) = self.params.as_ref() {
16330 struct_ser.serialize_field("params", v)?;
16331 }
16332 struct_ser.end()
16333 }
16334}
16335impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
16336 #[allow(deprecated)]
16337 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16338 where
16339 D: serde::Deserializer<'de>,
16340 {
16341 const FIELDS: &[&str] = &[
16342 "params",
16343 ];
16344
16345 #[allow(clippy::enum_variant_names)]
16346 enum GeneratedField {
16347 Params,
16348 }
16349 impl<'de> serde::Deserialize<'de> for GeneratedField {
16350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16351 where
16352 D: serde::Deserializer<'de>,
16353 {
16354 struct GeneratedVisitor;
16355
16356 impl serde::de::Visitor<'_> for GeneratedVisitor {
16357 type Value = GeneratedField;
16358
16359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16360 write!(formatter, "expected one of: {:?}", &FIELDS)
16361 }
16362
16363 #[allow(unused_variables)]
16364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16365 where
16366 E: serde::de::Error,
16367 {
16368 match value {
16369 "params" => Ok(GeneratedField::Params),
16370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16371 }
16372 }
16373 }
16374 deserializer.deserialize_identifier(GeneratedVisitor)
16375 }
16376 }
16377 struct GeneratedVisitor;
16378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16379 type Value = SetSystemParamResponse;
16380
16381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16382 formatter.write_str("struct meta.SetSystemParamResponse")
16383 }
16384
16385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
16386 where
16387 V: serde::de::MapAccess<'de>,
16388 {
16389 let mut params__ = None;
16390 while let Some(k) = map_.next_key()? {
16391 match k {
16392 GeneratedField::Params => {
16393 if params__.is_some() {
16394 return Err(serde::de::Error::duplicate_field("params"));
16395 }
16396 params__ = map_.next_value()?;
16397 }
16398 }
16399 }
16400 Ok(SetSystemParamResponse {
16401 params: params__,
16402 })
16403 }
16404 }
16405 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
16406 }
16407}
16408impl serde::Serialize for SubscribeRequest {
16409 #[allow(deprecated)]
16410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16411 where
16412 S: serde::Serializer,
16413 {
16414 use serde::ser::SerializeStruct;
16415 let mut len = 0;
16416 if self.subscribe_type != 0 {
16417 len += 1;
16418 }
16419 if self.host.is_some() {
16420 len += 1;
16421 }
16422 if self.worker_id != 0 {
16423 len += 1;
16424 }
16425 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
16426 if self.subscribe_type != 0 {
16427 let v = SubscribeType::try_from(self.subscribe_type)
16428 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
16429 struct_ser.serialize_field("subscribeType", &v)?;
16430 }
16431 if let Some(v) = self.host.as_ref() {
16432 struct_ser.serialize_field("host", v)?;
16433 }
16434 if self.worker_id != 0 {
16435 struct_ser.serialize_field("workerId", &self.worker_id)?;
16436 }
16437 struct_ser.end()
16438 }
16439}
16440impl<'de> serde::Deserialize<'de> for SubscribeRequest {
16441 #[allow(deprecated)]
16442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16443 where
16444 D: serde::Deserializer<'de>,
16445 {
16446 const FIELDS: &[&str] = &[
16447 "subscribe_type",
16448 "subscribeType",
16449 "host",
16450 "worker_id",
16451 "workerId",
16452 ];
16453
16454 #[allow(clippy::enum_variant_names)]
16455 enum GeneratedField {
16456 SubscribeType,
16457 Host,
16458 WorkerId,
16459 }
16460 impl<'de> serde::Deserialize<'de> for GeneratedField {
16461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16462 where
16463 D: serde::Deserializer<'de>,
16464 {
16465 struct GeneratedVisitor;
16466
16467 impl serde::de::Visitor<'_> for GeneratedVisitor {
16468 type Value = GeneratedField;
16469
16470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16471 write!(formatter, "expected one of: {:?}", &FIELDS)
16472 }
16473
16474 #[allow(unused_variables)]
16475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16476 where
16477 E: serde::de::Error,
16478 {
16479 match value {
16480 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
16481 "host" => Ok(GeneratedField::Host),
16482 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
16483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16484 }
16485 }
16486 }
16487 deserializer.deserialize_identifier(GeneratedVisitor)
16488 }
16489 }
16490 struct GeneratedVisitor;
16491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16492 type Value = SubscribeRequest;
16493
16494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16495 formatter.write_str("struct meta.SubscribeRequest")
16496 }
16497
16498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
16499 where
16500 V: serde::de::MapAccess<'de>,
16501 {
16502 let mut subscribe_type__ = None;
16503 let mut host__ = None;
16504 let mut worker_id__ = None;
16505 while let Some(k) = map_.next_key()? {
16506 match k {
16507 GeneratedField::SubscribeType => {
16508 if subscribe_type__.is_some() {
16509 return Err(serde::de::Error::duplicate_field("subscribeType"));
16510 }
16511 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
16512 }
16513 GeneratedField::Host => {
16514 if host__.is_some() {
16515 return Err(serde::de::Error::duplicate_field("host"));
16516 }
16517 host__ = map_.next_value()?;
16518 }
16519 GeneratedField::WorkerId => {
16520 if worker_id__.is_some() {
16521 return Err(serde::de::Error::duplicate_field("workerId"));
16522 }
16523 worker_id__ =
16524 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16525 ;
16526 }
16527 }
16528 }
16529 Ok(SubscribeRequest {
16530 subscribe_type: subscribe_type__.unwrap_or_default(),
16531 host: host__,
16532 worker_id: worker_id__.unwrap_or_default(),
16533 })
16534 }
16535 }
16536 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
16537 }
16538}
16539impl serde::Serialize for SubscribeResponse {
16540 #[allow(deprecated)]
16541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16542 where
16543 S: serde::Serializer,
16544 {
16545 use serde::ser::SerializeStruct;
16546 let mut len = 0;
16547 if self.status.is_some() {
16548 len += 1;
16549 }
16550 if self.operation != 0 {
16551 len += 1;
16552 }
16553 if self.version != 0 {
16554 len += 1;
16555 }
16556 if self.info.is_some() {
16557 len += 1;
16558 }
16559 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
16560 if let Some(v) = self.status.as_ref() {
16561 struct_ser.serialize_field("status", v)?;
16562 }
16563 if self.operation != 0 {
16564 let v = subscribe_response::Operation::try_from(self.operation)
16565 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
16566 struct_ser.serialize_field("operation", &v)?;
16567 }
16568 if self.version != 0 {
16569 #[allow(clippy::needless_borrow)]
16570 #[allow(clippy::needless_borrows_for_generic_args)]
16571 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
16572 }
16573 if let Some(v) = self.info.as_ref() {
16574 match v {
16575 subscribe_response::Info::Database(v) => {
16576 struct_ser.serialize_field("database", v)?;
16577 }
16578 subscribe_response::Info::Schema(v) => {
16579 struct_ser.serialize_field("schema", v)?;
16580 }
16581 subscribe_response::Info::Function(v) => {
16582 struct_ser.serialize_field("function", v)?;
16583 }
16584 subscribe_response::Info::User(v) => {
16585 struct_ser.serialize_field("user", v)?;
16586 }
16587 subscribe_response::Info::SessionParam(v) => {
16588 struct_ser.serialize_field("sessionParam", v)?;
16589 }
16590 subscribe_response::Info::Node(v) => {
16591 struct_ser.serialize_field("node", v)?;
16592 }
16593 subscribe_response::Info::HummockVersionDeltas(v) => {
16594 struct_ser.serialize_field("hummockVersionDeltas", v)?;
16595 }
16596 subscribe_response::Info::Snapshot(v) => {
16597 struct_ser.serialize_field("snapshot", v)?;
16598 }
16599 subscribe_response::Info::MetaBackupManifestId(v) => {
16600 struct_ser.serialize_field("metaBackupManifestId", v)?;
16601 }
16602 subscribe_response::Info::SystemParams(v) => {
16603 struct_ser.serialize_field("systemParams", v)?;
16604 }
16605 subscribe_response::Info::HummockWriteLimits(v) => {
16606 struct_ser.serialize_field("hummockWriteLimits", v)?;
16607 }
16608 subscribe_response::Info::ObjectGroup(v) => {
16609 struct_ser.serialize_field("objectGroup", v)?;
16610 }
16611 subscribe_response::Info::Connection(v) => {
16612 struct_ser.serialize_field("connection", v)?;
16613 }
16614 subscribe_response::Info::HummockStats(v) => {
16615 struct_ser.serialize_field("hummockStats", v)?;
16616 }
16617 subscribe_response::Info::Recovery(v) => {
16618 struct_ser.serialize_field("recovery", v)?;
16619 }
16620 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
16621 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
16622 }
16623 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
16624 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
16625 }
16626 subscribe_response::Info::Secret(v) => {
16627 struct_ser.serialize_field("secret", v)?;
16628 }
16629 subscribe_response::Info::ClusterResource(v) => {
16630 struct_ser.serialize_field("clusterResource", v)?;
16631 }
16632 }
16633 }
16634 struct_ser.end()
16635 }
16636}
16637impl<'de> serde::Deserialize<'de> for SubscribeResponse {
16638 #[allow(deprecated)]
16639 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16640 where
16641 D: serde::Deserializer<'de>,
16642 {
16643 const FIELDS: &[&str] = &[
16644 "status",
16645 "operation",
16646 "version",
16647 "database",
16648 "schema",
16649 "function",
16650 "user",
16651 "session_param",
16652 "sessionParam",
16653 "node",
16654 "hummock_version_deltas",
16655 "hummockVersionDeltas",
16656 "snapshot",
16657 "meta_backup_manifest_id",
16658 "metaBackupManifestId",
16659 "system_params",
16660 "systemParams",
16661 "hummock_write_limits",
16662 "hummockWriteLimits",
16663 "object_group",
16664 "objectGroup",
16665 "connection",
16666 "hummock_stats",
16667 "hummockStats",
16668 "recovery",
16669 "streaming_worker_slot_mapping",
16670 "streamingWorkerSlotMapping",
16671 "serving_worker_slot_mappings",
16672 "servingWorkerSlotMappings",
16673 "secret",
16674 "cluster_resource",
16675 "clusterResource",
16676 ];
16677
16678 #[allow(clippy::enum_variant_names)]
16679 enum GeneratedField {
16680 Status,
16681 Operation,
16682 Version,
16683 Database,
16684 Schema,
16685 Function,
16686 User,
16687 SessionParam,
16688 Node,
16689 HummockVersionDeltas,
16690 Snapshot,
16691 MetaBackupManifestId,
16692 SystemParams,
16693 HummockWriteLimits,
16694 ObjectGroup,
16695 Connection,
16696 HummockStats,
16697 Recovery,
16698 StreamingWorkerSlotMapping,
16699 ServingWorkerSlotMappings,
16700 Secret,
16701 ClusterResource,
16702 }
16703 impl<'de> serde::Deserialize<'de> for GeneratedField {
16704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16705 where
16706 D: serde::Deserializer<'de>,
16707 {
16708 struct GeneratedVisitor;
16709
16710 impl serde::de::Visitor<'_> for GeneratedVisitor {
16711 type Value = GeneratedField;
16712
16713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16714 write!(formatter, "expected one of: {:?}", &FIELDS)
16715 }
16716
16717 #[allow(unused_variables)]
16718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16719 where
16720 E: serde::de::Error,
16721 {
16722 match value {
16723 "status" => Ok(GeneratedField::Status),
16724 "operation" => Ok(GeneratedField::Operation),
16725 "version" => Ok(GeneratedField::Version),
16726 "database" => Ok(GeneratedField::Database),
16727 "schema" => Ok(GeneratedField::Schema),
16728 "function" => Ok(GeneratedField::Function),
16729 "user" => Ok(GeneratedField::User),
16730 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
16731 "node" => Ok(GeneratedField::Node),
16732 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
16733 "snapshot" => Ok(GeneratedField::Snapshot),
16734 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
16735 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
16736 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
16737 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
16738 "connection" => Ok(GeneratedField::Connection),
16739 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
16740 "recovery" => Ok(GeneratedField::Recovery),
16741 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
16742 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
16743 "secret" => Ok(GeneratedField::Secret),
16744 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
16745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16746 }
16747 }
16748 }
16749 deserializer.deserialize_identifier(GeneratedVisitor)
16750 }
16751 }
16752 struct GeneratedVisitor;
16753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16754 type Value = SubscribeResponse;
16755
16756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16757 formatter.write_str("struct meta.SubscribeResponse")
16758 }
16759
16760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
16761 where
16762 V: serde::de::MapAccess<'de>,
16763 {
16764 let mut status__ = None;
16765 let mut operation__ = None;
16766 let mut version__ = None;
16767 let mut info__ = None;
16768 while let Some(k) = map_.next_key()? {
16769 match k {
16770 GeneratedField::Status => {
16771 if status__.is_some() {
16772 return Err(serde::de::Error::duplicate_field("status"));
16773 }
16774 status__ = map_.next_value()?;
16775 }
16776 GeneratedField::Operation => {
16777 if operation__.is_some() {
16778 return Err(serde::de::Error::duplicate_field("operation"));
16779 }
16780 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
16781 }
16782 GeneratedField::Version => {
16783 if version__.is_some() {
16784 return Err(serde::de::Error::duplicate_field("version"));
16785 }
16786 version__ =
16787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16788 ;
16789 }
16790 GeneratedField::Database => {
16791 if info__.is_some() {
16792 return Err(serde::de::Error::duplicate_field("database"));
16793 }
16794 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
16795;
16796 }
16797 GeneratedField::Schema => {
16798 if info__.is_some() {
16799 return Err(serde::de::Error::duplicate_field("schema"));
16800 }
16801 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
16802;
16803 }
16804 GeneratedField::Function => {
16805 if info__.is_some() {
16806 return Err(serde::de::Error::duplicate_field("function"));
16807 }
16808 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
16809;
16810 }
16811 GeneratedField::User => {
16812 if info__.is_some() {
16813 return Err(serde::de::Error::duplicate_field("user"));
16814 }
16815 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
16816;
16817 }
16818 GeneratedField::SessionParam => {
16819 if info__.is_some() {
16820 return Err(serde::de::Error::duplicate_field("sessionParam"));
16821 }
16822 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
16823;
16824 }
16825 GeneratedField::Node => {
16826 if info__.is_some() {
16827 return Err(serde::de::Error::duplicate_field("node"));
16828 }
16829 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
16830;
16831 }
16832 GeneratedField::HummockVersionDeltas => {
16833 if info__.is_some() {
16834 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
16835 }
16836 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
16837;
16838 }
16839 GeneratedField::Snapshot => {
16840 if info__.is_some() {
16841 return Err(serde::de::Error::duplicate_field("snapshot"));
16842 }
16843 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
16844;
16845 }
16846 GeneratedField::MetaBackupManifestId => {
16847 if info__.is_some() {
16848 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
16849 }
16850 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
16851;
16852 }
16853 GeneratedField::SystemParams => {
16854 if info__.is_some() {
16855 return Err(serde::de::Error::duplicate_field("systemParams"));
16856 }
16857 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
16858;
16859 }
16860 GeneratedField::HummockWriteLimits => {
16861 if info__.is_some() {
16862 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
16863 }
16864 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
16865;
16866 }
16867 GeneratedField::ObjectGroup => {
16868 if info__.is_some() {
16869 return Err(serde::de::Error::duplicate_field("objectGroup"));
16870 }
16871 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
16872;
16873 }
16874 GeneratedField::Connection => {
16875 if info__.is_some() {
16876 return Err(serde::de::Error::duplicate_field("connection"));
16877 }
16878 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
16879;
16880 }
16881 GeneratedField::HummockStats => {
16882 if info__.is_some() {
16883 return Err(serde::de::Error::duplicate_field("hummockStats"));
16884 }
16885 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
16886;
16887 }
16888 GeneratedField::Recovery => {
16889 if info__.is_some() {
16890 return Err(serde::de::Error::duplicate_field("recovery"));
16891 }
16892 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
16893;
16894 }
16895 GeneratedField::StreamingWorkerSlotMapping => {
16896 if info__.is_some() {
16897 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
16898 }
16899 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
16900;
16901 }
16902 GeneratedField::ServingWorkerSlotMappings => {
16903 if info__.is_some() {
16904 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
16905 }
16906 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
16907;
16908 }
16909 GeneratedField::Secret => {
16910 if info__.is_some() {
16911 return Err(serde::de::Error::duplicate_field("secret"));
16912 }
16913 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
16914;
16915 }
16916 GeneratedField::ClusterResource => {
16917 if info__.is_some() {
16918 return Err(serde::de::Error::duplicate_field("clusterResource"));
16919 }
16920 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
16921;
16922 }
16923 }
16924 }
16925 Ok(SubscribeResponse {
16926 status: status__,
16927 operation: operation__.unwrap_or_default(),
16928 version: version__.unwrap_or_default(),
16929 info: info__,
16930 })
16931 }
16932 }
16933 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
16934 }
16935}
16936impl serde::Serialize for subscribe_response::Operation {
16937 #[allow(deprecated)]
16938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16939 where
16940 S: serde::Serializer,
16941 {
16942 let variant = match self {
16943 Self::Unspecified => "UNSPECIFIED",
16944 Self::Add => "ADD",
16945 Self::Delete => "DELETE",
16946 Self::Update => "UPDATE",
16947 Self::Snapshot => "SNAPSHOT",
16948 };
16949 serializer.serialize_str(variant)
16950 }
16951}
16952impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
16953 #[allow(deprecated)]
16954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16955 where
16956 D: serde::Deserializer<'de>,
16957 {
16958 const FIELDS: &[&str] = &[
16959 "UNSPECIFIED",
16960 "ADD",
16961 "DELETE",
16962 "UPDATE",
16963 "SNAPSHOT",
16964 ];
16965
16966 struct GeneratedVisitor;
16967
16968 impl serde::de::Visitor<'_> for GeneratedVisitor {
16969 type Value = subscribe_response::Operation;
16970
16971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16972 write!(formatter, "expected one of: {:?}", &FIELDS)
16973 }
16974
16975 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16976 where
16977 E: serde::de::Error,
16978 {
16979 i32::try_from(v)
16980 .ok()
16981 .and_then(|x| x.try_into().ok())
16982 .ok_or_else(|| {
16983 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16984 })
16985 }
16986
16987 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16988 where
16989 E: serde::de::Error,
16990 {
16991 i32::try_from(v)
16992 .ok()
16993 .and_then(|x| x.try_into().ok())
16994 .ok_or_else(|| {
16995 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16996 })
16997 }
16998
16999 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17000 where
17001 E: serde::de::Error,
17002 {
17003 match value {
17004 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17005 "ADD" => Ok(subscribe_response::Operation::Add),
17006 "DELETE" => Ok(subscribe_response::Operation::Delete),
17007 "UPDATE" => Ok(subscribe_response::Operation::Update),
17008 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17009 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17010 }
17011 }
17012 }
17013 deserializer.deserialize_any(GeneratedVisitor)
17014 }
17015}
17016impl serde::Serialize for SubscribeType {
17017 #[allow(deprecated)]
17018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17019 where
17020 S: serde::Serializer,
17021 {
17022 let variant = match self {
17023 Self::Unspecified => "UNSPECIFIED",
17024 Self::Frontend => "FRONTEND",
17025 Self::Hummock => "HUMMOCK",
17026 Self::Compactor => "COMPACTOR",
17027 Self::Compute => "COMPUTE",
17028 };
17029 serializer.serialize_str(variant)
17030 }
17031}
17032impl<'de> serde::Deserialize<'de> for SubscribeType {
17033 #[allow(deprecated)]
17034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17035 where
17036 D: serde::Deserializer<'de>,
17037 {
17038 const FIELDS: &[&str] = &[
17039 "UNSPECIFIED",
17040 "FRONTEND",
17041 "HUMMOCK",
17042 "COMPACTOR",
17043 "COMPUTE",
17044 ];
17045
17046 struct GeneratedVisitor;
17047
17048 impl serde::de::Visitor<'_> for GeneratedVisitor {
17049 type Value = SubscribeType;
17050
17051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17052 write!(formatter, "expected one of: {:?}", &FIELDS)
17053 }
17054
17055 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17056 where
17057 E: serde::de::Error,
17058 {
17059 i32::try_from(v)
17060 .ok()
17061 .and_then(|x| x.try_into().ok())
17062 .ok_or_else(|| {
17063 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17064 })
17065 }
17066
17067 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17068 where
17069 E: serde::de::Error,
17070 {
17071 i32::try_from(v)
17072 .ok()
17073 .and_then(|x| x.try_into().ok())
17074 .ok_or_else(|| {
17075 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17076 })
17077 }
17078
17079 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17080 where
17081 E: serde::de::Error,
17082 {
17083 match value {
17084 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17085 "FRONTEND" => Ok(SubscribeType::Frontend),
17086 "HUMMOCK" => Ok(SubscribeType::Hummock),
17087 "COMPACTOR" => Ok(SubscribeType::Compactor),
17088 "COMPUTE" => Ok(SubscribeType::Compute),
17089 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17090 }
17091 }
17092 }
17093 deserializer.deserialize_any(GeneratedVisitor)
17094 }
17095}
17096impl serde::Serialize for SystemParams {
17097 #[allow(deprecated)]
17098 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17099 where
17100 S: serde::Serializer,
17101 {
17102 use serde::ser::SerializeStruct;
17103 let mut len = 0;
17104 if self.barrier_interval_ms.is_some() {
17105 len += 1;
17106 }
17107 if self.checkpoint_frequency.is_some() {
17108 len += 1;
17109 }
17110 if self.sstable_size_mb.is_some() {
17111 len += 1;
17112 }
17113 if self.block_size_kb.is_some() {
17114 len += 1;
17115 }
17116 if self.bloom_false_positive.is_some() {
17117 len += 1;
17118 }
17119 if self.state_store.is_some() {
17120 len += 1;
17121 }
17122 if self.data_directory.is_some() {
17123 len += 1;
17124 }
17125 if self.backup_storage_url.is_some() {
17126 len += 1;
17127 }
17128 if self.backup_storage_directory.is_some() {
17129 len += 1;
17130 }
17131 if self.telemetry_enabled.is_some() {
17132 len += 1;
17133 }
17134 if self.parallel_compact_size_mb.is_some() {
17135 len += 1;
17136 }
17137 if self.max_concurrent_creating_streaming_jobs.is_some() {
17138 len += 1;
17139 }
17140 if self.pause_on_next_bootstrap.is_some() {
17141 len += 1;
17142 }
17143 if self.wasm_storage_url.is_some() {
17144 len += 1;
17145 }
17146 if self.enable_tracing.is_some() {
17147 len += 1;
17148 }
17149 if self.use_new_object_prefix_strategy.is_some() {
17150 len += 1;
17151 }
17152 if self.license_key.is_some() {
17153 len += 1;
17154 }
17155 if self.time_travel_retention_ms.is_some() {
17156 len += 1;
17157 }
17158 if self.adaptive_parallelism_strategy.is_some() {
17159 len += 1;
17160 }
17161 if self.per_database_isolation.is_some() {
17162 len += 1;
17163 }
17164 if self.enforce_secret.is_some() {
17165 len += 1;
17166 }
17167 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
17168 if let Some(v) = self.barrier_interval_ms.as_ref() {
17169 struct_ser.serialize_field("barrierIntervalMs", v)?;
17170 }
17171 if let Some(v) = self.checkpoint_frequency.as_ref() {
17172 #[allow(clippy::needless_borrow)]
17173 #[allow(clippy::needless_borrows_for_generic_args)]
17174 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
17175 }
17176 if let Some(v) = self.sstable_size_mb.as_ref() {
17177 struct_ser.serialize_field("sstableSizeMb", v)?;
17178 }
17179 if let Some(v) = self.block_size_kb.as_ref() {
17180 struct_ser.serialize_field("blockSizeKb", v)?;
17181 }
17182 if let Some(v) = self.bloom_false_positive.as_ref() {
17183 struct_ser.serialize_field("bloomFalsePositive", v)?;
17184 }
17185 if let Some(v) = self.state_store.as_ref() {
17186 struct_ser.serialize_field("stateStore", v)?;
17187 }
17188 if let Some(v) = self.data_directory.as_ref() {
17189 struct_ser.serialize_field("dataDirectory", v)?;
17190 }
17191 if let Some(v) = self.backup_storage_url.as_ref() {
17192 struct_ser.serialize_field("backupStorageUrl", v)?;
17193 }
17194 if let Some(v) = self.backup_storage_directory.as_ref() {
17195 struct_ser.serialize_field("backupStorageDirectory", v)?;
17196 }
17197 if let Some(v) = self.telemetry_enabled.as_ref() {
17198 struct_ser.serialize_field("telemetryEnabled", v)?;
17199 }
17200 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
17201 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
17202 }
17203 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
17204 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
17205 }
17206 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
17207 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
17208 }
17209 if let Some(v) = self.wasm_storage_url.as_ref() {
17210 struct_ser.serialize_field("wasmStorageUrl", v)?;
17211 }
17212 if let Some(v) = self.enable_tracing.as_ref() {
17213 struct_ser.serialize_field("enableTracing", v)?;
17214 }
17215 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
17216 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
17217 }
17218 if let Some(v) = self.license_key.as_ref() {
17219 struct_ser.serialize_field("licenseKey", v)?;
17220 }
17221 if let Some(v) = self.time_travel_retention_ms.as_ref() {
17222 #[allow(clippy::needless_borrow)]
17223 #[allow(clippy::needless_borrows_for_generic_args)]
17224 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
17225 }
17226 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
17227 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
17228 }
17229 if let Some(v) = self.per_database_isolation.as_ref() {
17230 struct_ser.serialize_field("perDatabaseIsolation", v)?;
17231 }
17232 if let Some(v) = self.enforce_secret.as_ref() {
17233 struct_ser.serialize_field("enforceSecret", v)?;
17234 }
17235 struct_ser.end()
17236 }
17237}
17238impl<'de> serde::Deserialize<'de> for SystemParams {
17239 #[allow(deprecated)]
17240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17241 where
17242 D: serde::Deserializer<'de>,
17243 {
17244 const FIELDS: &[&str] = &[
17245 "barrier_interval_ms",
17246 "barrierIntervalMs",
17247 "checkpoint_frequency",
17248 "checkpointFrequency",
17249 "sstable_size_mb",
17250 "sstableSizeMb",
17251 "block_size_kb",
17252 "blockSizeKb",
17253 "bloom_false_positive",
17254 "bloomFalsePositive",
17255 "state_store",
17256 "stateStore",
17257 "data_directory",
17258 "dataDirectory",
17259 "backup_storage_url",
17260 "backupStorageUrl",
17261 "backup_storage_directory",
17262 "backupStorageDirectory",
17263 "telemetry_enabled",
17264 "telemetryEnabled",
17265 "parallel_compact_size_mb",
17266 "parallelCompactSizeMb",
17267 "max_concurrent_creating_streaming_jobs",
17268 "maxConcurrentCreatingStreamingJobs",
17269 "pause_on_next_bootstrap",
17270 "pauseOnNextBootstrap",
17271 "wasm_storage_url",
17272 "wasmStorageUrl",
17273 "enable_tracing",
17274 "enableTracing",
17275 "use_new_object_prefix_strategy",
17276 "useNewObjectPrefixStrategy",
17277 "license_key",
17278 "licenseKey",
17279 "time_travel_retention_ms",
17280 "timeTravelRetentionMs",
17281 "adaptive_parallelism_strategy",
17282 "adaptiveParallelismStrategy",
17283 "per_database_isolation",
17284 "perDatabaseIsolation",
17285 "enforce_secret",
17286 "enforceSecret",
17287 ];
17288
17289 #[allow(clippy::enum_variant_names)]
17290 enum GeneratedField {
17291 BarrierIntervalMs,
17292 CheckpointFrequency,
17293 SstableSizeMb,
17294 BlockSizeKb,
17295 BloomFalsePositive,
17296 StateStore,
17297 DataDirectory,
17298 BackupStorageUrl,
17299 BackupStorageDirectory,
17300 TelemetryEnabled,
17301 ParallelCompactSizeMb,
17302 MaxConcurrentCreatingStreamingJobs,
17303 PauseOnNextBootstrap,
17304 WasmStorageUrl,
17305 EnableTracing,
17306 UseNewObjectPrefixStrategy,
17307 LicenseKey,
17308 TimeTravelRetentionMs,
17309 AdaptiveParallelismStrategy,
17310 PerDatabaseIsolation,
17311 EnforceSecret,
17312 }
17313 impl<'de> serde::Deserialize<'de> for GeneratedField {
17314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17315 where
17316 D: serde::Deserializer<'de>,
17317 {
17318 struct GeneratedVisitor;
17319
17320 impl serde::de::Visitor<'_> for GeneratedVisitor {
17321 type Value = GeneratedField;
17322
17323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17324 write!(formatter, "expected one of: {:?}", &FIELDS)
17325 }
17326
17327 #[allow(unused_variables)]
17328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17329 where
17330 E: serde::de::Error,
17331 {
17332 match value {
17333 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
17334 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
17335 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
17336 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
17337 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
17338 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
17339 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
17340 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
17341 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
17342 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
17343 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
17344 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
17345 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
17346 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
17347 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
17348 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
17349 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
17350 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
17351 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
17352 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
17353 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
17354 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17355 }
17356 }
17357 }
17358 deserializer.deserialize_identifier(GeneratedVisitor)
17359 }
17360 }
17361 struct GeneratedVisitor;
17362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17363 type Value = SystemParams;
17364
17365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17366 formatter.write_str("struct meta.SystemParams")
17367 }
17368
17369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
17370 where
17371 V: serde::de::MapAccess<'de>,
17372 {
17373 let mut barrier_interval_ms__ = None;
17374 let mut checkpoint_frequency__ = None;
17375 let mut sstable_size_mb__ = None;
17376 let mut block_size_kb__ = None;
17377 let mut bloom_false_positive__ = None;
17378 let mut state_store__ = None;
17379 let mut data_directory__ = None;
17380 let mut backup_storage_url__ = None;
17381 let mut backup_storage_directory__ = None;
17382 let mut telemetry_enabled__ = None;
17383 let mut parallel_compact_size_mb__ = None;
17384 let mut max_concurrent_creating_streaming_jobs__ = None;
17385 let mut pause_on_next_bootstrap__ = None;
17386 let mut wasm_storage_url__ = None;
17387 let mut enable_tracing__ = None;
17388 let mut use_new_object_prefix_strategy__ = None;
17389 let mut license_key__ = None;
17390 let mut time_travel_retention_ms__ = None;
17391 let mut adaptive_parallelism_strategy__ = None;
17392 let mut per_database_isolation__ = None;
17393 let mut enforce_secret__ = None;
17394 while let Some(k) = map_.next_key()? {
17395 match k {
17396 GeneratedField::BarrierIntervalMs => {
17397 if barrier_interval_ms__.is_some() {
17398 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
17399 }
17400 barrier_interval_ms__ =
17401 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17402 ;
17403 }
17404 GeneratedField::CheckpointFrequency => {
17405 if checkpoint_frequency__.is_some() {
17406 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
17407 }
17408 checkpoint_frequency__ =
17409 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17410 ;
17411 }
17412 GeneratedField::SstableSizeMb => {
17413 if sstable_size_mb__.is_some() {
17414 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
17415 }
17416 sstable_size_mb__ =
17417 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17418 ;
17419 }
17420 GeneratedField::BlockSizeKb => {
17421 if block_size_kb__.is_some() {
17422 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
17423 }
17424 block_size_kb__ =
17425 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17426 ;
17427 }
17428 GeneratedField::BloomFalsePositive => {
17429 if bloom_false_positive__.is_some() {
17430 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
17431 }
17432 bloom_false_positive__ =
17433 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17434 ;
17435 }
17436 GeneratedField::StateStore => {
17437 if state_store__.is_some() {
17438 return Err(serde::de::Error::duplicate_field("stateStore"));
17439 }
17440 state_store__ = map_.next_value()?;
17441 }
17442 GeneratedField::DataDirectory => {
17443 if data_directory__.is_some() {
17444 return Err(serde::de::Error::duplicate_field("dataDirectory"));
17445 }
17446 data_directory__ = map_.next_value()?;
17447 }
17448 GeneratedField::BackupStorageUrl => {
17449 if backup_storage_url__.is_some() {
17450 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
17451 }
17452 backup_storage_url__ = map_.next_value()?;
17453 }
17454 GeneratedField::BackupStorageDirectory => {
17455 if backup_storage_directory__.is_some() {
17456 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
17457 }
17458 backup_storage_directory__ = map_.next_value()?;
17459 }
17460 GeneratedField::TelemetryEnabled => {
17461 if telemetry_enabled__.is_some() {
17462 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
17463 }
17464 telemetry_enabled__ = map_.next_value()?;
17465 }
17466 GeneratedField::ParallelCompactSizeMb => {
17467 if parallel_compact_size_mb__.is_some() {
17468 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
17469 }
17470 parallel_compact_size_mb__ =
17471 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17472 ;
17473 }
17474 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
17475 if max_concurrent_creating_streaming_jobs__.is_some() {
17476 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
17477 }
17478 max_concurrent_creating_streaming_jobs__ =
17479 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17480 ;
17481 }
17482 GeneratedField::PauseOnNextBootstrap => {
17483 if pause_on_next_bootstrap__.is_some() {
17484 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
17485 }
17486 pause_on_next_bootstrap__ = map_.next_value()?;
17487 }
17488 GeneratedField::WasmStorageUrl => {
17489 if wasm_storage_url__.is_some() {
17490 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
17491 }
17492 wasm_storage_url__ = map_.next_value()?;
17493 }
17494 GeneratedField::EnableTracing => {
17495 if enable_tracing__.is_some() {
17496 return Err(serde::de::Error::duplicate_field("enableTracing"));
17497 }
17498 enable_tracing__ = map_.next_value()?;
17499 }
17500 GeneratedField::UseNewObjectPrefixStrategy => {
17501 if use_new_object_prefix_strategy__.is_some() {
17502 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
17503 }
17504 use_new_object_prefix_strategy__ = map_.next_value()?;
17505 }
17506 GeneratedField::LicenseKey => {
17507 if license_key__.is_some() {
17508 return Err(serde::de::Error::duplicate_field("licenseKey"));
17509 }
17510 license_key__ = map_.next_value()?;
17511 }
17512 GeneratedField::TimeTravelRetentionMs => {
17513 if time_travel_retention_ms__.is_some() {
17514 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
17515 }
17516 time_travel_retention_ms__ =
17517 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17518 ;
17519 }
17520 GeneratedField::AdaptiveParallelismStrategy => {
17521 if adaptive_parallelism_strategy__.is_some() {
17522 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
17523 }
17524 adaptive_parallelism_strategy__ = map_.next_value()?;
17525 }
17526 GeneratedField::PerDatabaseIsolation => {
17527 if per_database_isolation__.is_some() {
17528 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
17529 }
17530 per_database_isolation__ = map_.next_value()?;
17531 }
17532 GeneratedField::EnforceSecret => {
17533 if enforce_secret__.is_some() {
17534 return Err(serde::de::Error::duplicate_field("enforceSecret"));
17535 }
17536 enforce_secret__ = map_.next_value()?;
17537 }
17538 }
17539 }
17540 Ok(SystemParams {
17541 barrier_interval_ms: barrier_interval_ms__,
17542 checkpoint_frequency: checkpoint_frequency__,
17543 sstable_size_mb: sstable_size_mb__,
17544 block_size_kb: block_size_kb__,
17545 bloom_false_positive: bloom_false_positive__,
17546 state_store: state_store__,
17547 data_directory: data_directory__,
17548 backup_storage_url: backup_storage_url__,
17549 backup_storage_directory: backup_storage_directory__,
17550 telemetry_enabled: telemetry_enabled__,
17551 parallel_compact_size_mb: parallel_compact_size_mb__,
17552 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
17553 pause_on_next_bootstrap: pause_on_next_bootstrap__,
17554 wasm_storage_url: wasm_storage_url__,
17555 enable_tracing: enable_tracing__,
17556 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
17557 license_key: license_key__,
17558 time_travel_retention_ms: time_travel_retention_ms__,
17559 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
17560 per_database_isolation: per_database_isolation__,
17561 enforce_secret: enforce_secret__,
17562 })
17563 }
17564 }
17565 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
17566 }
17567}
17568impl serde::Serialize for TableFragments {
17569 #[allow(deprecated)]
17570 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17571 where
17572 S: serde::Serializer,
17573 {
17574 use serde::ser::SerializeStruct;
17575 let mut len = 0;
17576 if self.table_id != 0 {
17577 len += 1;
17578 }
17579 if self.state != 0 {
17580 len += 1;
17581 }
17582 if !self.fragments.is_empty() {
17583 len += 1;
17584 }
17585 if !self.actor_status.is_empty() {
17586 len += 1;
17587 }
17588 if self.ctx.is_some() {
17589 len += 1;
17590 }
17591 if self.parallelism.is_some() {
17592 len += 1;
17593 }
17594 if self.max_parallelism.is_some() {
17595 len += 1;
17596 }
17597 if !self.node_label.is_empty() {
17598 len += 1;
17599 }
17600 if self.backfill_done {
17601 len += 1;
17602 }
17603 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
17604 if self.table_id != 0 {
17605 struct_ser.serialize_field("tableId", &self.table_id)?;
17606 }
17607 if self.state != 0 {
17608 let v = table_fragments::State::try_from(self.state)
17609 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
17610 struct_ser.serialize_field("state", &v)?;
17611 }
17612 if !self.fragments.is_empty() {
17613 struct_ser.serialize_field("fragments", &self.fragments)?;
17614 }
17615 if !self.actor_status.is_empty() {
17616 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
17617 }
17618 if let Some(v) = self.ctx.as_ref() {
17619 struct_ser.serialize_field("ctx", v)?;
17620 }
17621 if let Some(v) = self.parallelism.as_ref() {
17622 struct_ser.serialize_field("parallelism", v)?;
17623 }
17624 if let Some(v) = self.max_parallelism.as_ref() {
17625 struct_ser.serialize_field("maxParallelism", v)?;
17626 }
17627 if !self.node_label.is_empty() {
17628 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
17629 }
17630 if self.backfill_done {
17631 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
17632 }
17633 struct_ser.end()
17634 }
17635}
17636impl<'de> serde::Deserialize<'de> for TableFragments {
17637 #[allow(deprecated)]
17638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17639 where
17640 D: serde::Deserializer<'de>,
17641 {
17642 const FIELDS: &[&str] = &[
17643 "table_id",
17644 "tableId",
17645 "state",
17646 "fragments",
17647 "actor_status",
17648 "actorStatus",
17649 "ctx",
17650 "parallelism",
17651 "max_parallelism",
17652 "maxParallelism",
17653 "node_label",
17654 "nodeLabel",
17655 "backfill_done",
17656 "backfillDone",
17657 ];
17658
17659 #[allow(clippy::enum_variant_names)]
17660 enum GeneratedField {
17661 TableId,
17662 State,
17663 Fragments,
17664 ActorStatus,
17665 Ctx,
17666 Parallelism,
17667 MaxParallelism,
17668 NodeLabel,
17669 BackfillDone,
17670 }
17671 impl<'de> serde::Deserialize<'de> for GeneratedField {
17672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17673 where
17674 D: serde::Deserializer<'de>,
17675 {
17676 struct GeneratedVisitor;
17677
17678 impl serde::de::Visitor<'_> for GeneratedVisitor {
17679 type Value = GeneratedField;
17680
17681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17682 write!(formatter, "expected one of: {:?}", &FIELDS)
17683 }
17684
17685 #[allow(unused_variables)]
17686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17687 where
17688 E: serde::de::Error,
17689 {
17690 match value {
17691 "tableId" | "table_id" => Ok(GeneratedField::TableId),
17692 "state" => Ok(GeneratedField::State),
17693 "fragments" => Ok(GeneratedField::Fragments),
17694 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
17695 "ctx" => Ok(GeneratedField::Ctx),
17696 "parallelism" => Ok(GeneratedField::Parallelism),
17697 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
17698 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
17699 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
17700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17701 }
17702 }
17703 }
17704 deserializer.deserialize_identifier(GeneratedVisitor)
17705 }
17706 }
17707 struct GeneratedVisitor;
17708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17709 type Value = TableFragments;
17710
17711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17712 formatter.write_str("struct meta.TableFragments")
17713 }
17714
17715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
17716 where
17717 V: serde::de::MapAccess<'de>,
17718 {
17719 let mut table_id__ = None;
17720 let mut state__ = None;
17721 let mut fragments__ = None;
17722 let mut actor_status__ = None;
17723 let mut ctx__ = None;
17724 let mut parallelism__ = None;
17725 let mut max_parallelism__ = None;
17726 let mut node_label__ = None;
17727 let mut backfill_done__ = None;
17728 while let Some(k) = map_.next_key()? {
17729 match k {
17730 GeneratedField::TableId => {
17731 if table_id__.is_some() {
17732 return Err(serde::de::Error::duplicate_field("tableId"));
17733 }
17734 table_id__ =
17735 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17736 ;
17737 }
17738 GeneratedField::State => {
17739 if state__.is_some() {
17740 return Err(serde::de::Error::duplicate_field("state"));
17741 }
17742 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
17743 }
17744 GeneratedField::Fragments => {
17745 if fragments__.is_some() {
17746 return Err(serde::de::Error::duplicate_field("fragments"));
17747 }
17748 fragments__ = Some(
17749 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17750 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17751 );
17752 }
17753 GeneratedField::ActorStatus => {
17754 if actor_status__.is_some() {
17755 return Err(serde::de::Error::duplicate_field("actorStatus"));
17756 }
17757 actor_status__ = Some(
17758 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17759 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17760 );
17761 }
17762 GeneratedField::Ctx => {
17763 if ctx__.is_some() {
17764 return Err(serde::de::Error::duplicate_field("ctx"));
17765 }
17766 ctx__ = map_.next_value()?;
17767 }
17768 GeneratedField::Parallelism => {
17769 if parallelism__.is_some() {
17770 return Err(serde::de::Error::duplicate_field("parallelism"));
17771 }
17772 parallelism__ = map_.next_value()?;
17773 }
17774 GeneratedField::MaxParallelism => {
17775 if max_parallelism__.is_some() {
17776 return Err(serde::de::Error::duplicate_field("maxParallelism"));
17777 }
17778 max_parallelism__ =
17779 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17780 ;
17781 }
17782 GeneratedField::NodeLabel => {
17783 if node_label__.is_some() {
17784 return Err(serde::de::Error::duplicate_field("nodeLabel"));
17785 }
17786 node_label__ = Some(map_.next_value()?);
17787 }
17788 GeneratedField::BackfillDone => {
17789 if backfill_done__.is_some() {
17790 return Err(serde::de::Error::duplicate_field("backfillDone"));
17791 }
17792 backfill_done__ = Some(map_.next_value()?);
17793 }
17794 }
17795 }
17796 Ok(TableFragments {
17797 table_id: table_id__.unwrap_or_default(),
17798 state: state__.unwrap_or_default(),
17799 fragments: fragments__.unwrap_or_default(),
17800 actor_status: actor_status__.unwrap_or_default(),
17801 ctx: ctx__,
17802 parallelism: parallelism__,
17803 max_parallelism: max_parallelism__,
17804 node_label: node_label__.unwrap_or_default(),
17805 backfill_done: backfill_done__.unwrap_or_default(),
17806 })
17807 }
17808 }
17809 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
17810 }
17811}
17812impl serde::Serialize for table_fragments::ActorStatus {
17813 #[allow(deprecated)]
17814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17815 where
17816 S: serde::Serializer,
17817 {
17818 use serde::ser::SerializeStruct;
17819 let mut len = 0;
17820 if self.location.is_some() {
17821 len += 1;
17822 }
17823 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
17824 if let Some(v) = self.location.as_ref() {
17825 struct_ser.serialize_field("location", v)?;
17826 }
17827 struct_ser.end()
17828 }
17829}
17830impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
17831 #[allow(deprecated)]
17832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17833 where
17834 D: serde::Deserializer<'de>,
17835 {
17836 const FIELDS: &[&str] = &[
17837 "location",
17838 ];
17839
17840 #[allow(clippy::enum_variant_names)]
17841 enum GeneratedField {
17842 Location,
17843 }
17844 impl<'de> serde::Deserialize<'de> for GeneratedField {
17845 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17846 where
17847 D: serde::Deserializer<'de>,
17848 {
17849 struct GeneratedVisitor;
17850
17851 impl serde::de::Visitor<'_> for GeneratedVisitor {
17852 type Value = GeneratedField;
17853
17854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17855 write!(formatter, "expected one of: {:?}", &FIELDS)
17856 }
17857
17858 #[allow(unused_variables)]
17859 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17860 where
17861 E: serde::de::Error,
17862 {
17863 match value {
17864 "location" => Ok(GeneratedField::Location),
17865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17866 }
17867 }
17868 }
17869 deserializer.deserialize_identifier(GeneratedVisitor)
17870 }
17871 }
17872 struct GeneratedVisitor;
17873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17874 type Value = table_fragments::ActorStatus;
17875
17876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17877 formatter.write_str("struct meta.TableFragments.ActorStatus")
17878 }
17879
17880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
17881 where
17882 V: serde::de::MapAccess<'de>,
17883 {
17884 let mut location__ = None;
17885 while let Some(k) = map_.next_key()? {
17886 match k {
17887 GeneratedField::Location => {
17888 if location__.is_some() {
17889 return Err(serde::de::Error::duplicate_field("location"));
17890 }
17891 location__ = map_.next_value()?;
17892 }
17893 }
17894 }
17895 Ok(table_fragments::ActorStatus {
17896 location: location__,
17897 })
17898 }
17899 }
17900 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
17901 }
17902}
17903impl serde::Serialize for table_fragments::Fragment {
17904 #[allow(deprecated)]
17905 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17906 where
17907 S: serde::Serializer,
17908 {
17909 use serde::ser::SerializeStruct;
17910 let mut len = 0;
17911 if self.fragment_id != 0 {
17912 len += 1;
17913 }
17914 if self.fragment_type_mask != 0 {
17915 len += 1;
17916 }
17917 if self.distribution_type != 0 {
17918 len += 1;
17919 }
17920 if !self.actors.is_empty() {
17921 len += 1;
17922 }
17923 if !self.state_table_ids.is_empty() {
17924 len += 1;
17925 }
17926 if !self.upstream_fragment_ids.is_empty() {
17927 len += 1;
17928 }
17929 if self.maybe_vnode_count.is_some() {
17930 len += 1;
17931 }
17932 if self.nodes.is_some() {
17933 len += 1;
17934 }
17935 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
17936 if self.fragment_id != 0 {
17937 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
17938 }
17939 if self.fragment_type_mask != 0 {
17940 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
17941 }
17942 if self.distribution_type != 0 {
17943 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
17944 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
17945 struct_ser.serialize_field("distributionType", &v)?;
17946 }
17947 if !self.actors.is_empty() {
17948 struct_ser.serialize_field("actors", &self.actors)?;
17949 }
17950 if !self.state_table_ids.is_empty() {
17951 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
17952 }
17953 if !self.upstream_fragment_ids.is_empty() {
17954 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
17955 }
17956 if let Some(v) = self.maybe_vnode_count.as_ref() {
17957 struct_ser.serialize_field("maybeVnodeCount", v)?;
17958 }
17959 if let Some(v) = self.nodes.as_ref() {
17960 struct_ser.serialize_field("nodes", v)?;
17961 }
17962 struct_ser.end()
17963 }
17964}
17965impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
17966 #[allow(deprecated)]
17967 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17968 where
17969 D: serde::Deserializer<'de>,
17970 {
17971 const FIELDS: &[&str] = &[
17972 "fragment_id",
17973 "fragmentId",
17974 "fragment_type_mask",
17975 "fragmentTypeMask",
17976 "distribution_type",
17977 "distributionType",
17978 "actors",
17979 "state_table_ids",
17980 "stateTableIds",
17981 "upstream_fragment_ids",
17982 "upstreamFragmentIds",
17983 "maybe_vnode_count",
17984 "maybeVnodeCount",
17985 "nodes",
17986 ];
17987
17988 #[allow(clippy::enum_variant_names)]
17989 enum GeneratedField {
17990 FragmentId,
17991 FragmentTypeMask,
17992 DistributionType,
17993 Actors,
17994 StateTableIds,
17995 UpstreamFragmentIds,
17996 MaybeVnodeCount,
17997 Nodes,
17998 }
17999 impl<'de> serde::Deserialize<'de> for GeneratedField {
18000 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18001 where
18002 D: serde::Deserializer<'de>,
18003 {
18004 struct GeneratedVisitor;
18005
18006 impl serde::de::Visitor<'_> for GeneratedVisitor {
18007 type Value = GeneratedField;
18008
18009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18010 write!(formatter, "expected one of: {:?}", &FIELDS)
18011 }
18012
18013 #[allow(unused_variables)]
18014 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18015 where
18016 E: serde::de::Error,
18017 {
18018 match value {
18019 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
18020 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
18021 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
18022 "actors" => Ok(GeneratedField::Actors),
18023 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
18024 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
18025 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
18026 "nodes" => Ok(GeneratedField::Nodes),
18027 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18028 }
18029 }
18030 }
18031 deserializer.deserialize_identifier(GeneratedVisitor)
18032 }
18033 }
18034 struct GeneratedVisitor;
18035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18036 type Value = table_fragments::Fragment;
18037
18038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18039 formatter.write_str("struct meta.TableFragments.Fragment")
18040 }
18041
18042 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
18043 where
18044 V: serde::de::MapAccess<'de>,
18045 {
18046 let mut fragment_id__ = None;
18047 let mut fragment_type_mask__ = None;
18048 let mut distribution_type__ = None;
18049 let mut actors__ = None;
18050 let mut state_table_ids__ = None;
18051 let mut upstream_fragment_ids__ = None;
18052 let mut maybe_vnode_count__ = None;
18053 let mut nodes__ = None;
18054 while let Some(k) = map_.next_key()? {
18055 match k {
18056 GeneratedField::FragmentId => {
18057 if fragment_id__.is_some() {
18058 return Err(serde::de::Error::duplicate_field("fragmentId"));
18059 }
18060 fragment_id__ =
18061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18062 ;
18063 }
18064 GeneratedField::FragmentTypeMask => {
18065 if fragment_type_mask__.is_some() {
18066 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
18067 }
18068 fragment_type_mask__ =
18069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18070 ;
18071 }
18072 GeneratedField::DistributionType => {
18073 if distribution_type__.is_some() {
18074 return Err(serde::de::Error::duplicate_field("distributionType"));
18075 }
18076 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
18077 }
18078 GeneratedField::Actors => {
18079 if actors__.is_some() {
18080 return Err(serde::de::Error::duplicate_field("actors"));
18081 }
18082 actors__ = Some(map_.next_value()?);
18083 }
18084 GeneratedField::StateTableIds => {
18085 if state_table_ids__.is_some() {
18086 return Err(serde::de::Error::duplicate_field("stateTableIds"));
18087 }
18088 state_table_ids__ =
18089 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18090 .into_iter().map(|x| x.0).collect())
18091 ;
18092 }
18093 GeneratedField::UpstreamFragmentIds => {
18094 if upstream_fragment_ids__.is_some() {
18095 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
18096 }
18097 upstream_fragment_ids__ =
18098 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18099 .into_iter().map(|x| x.0).collect())
18100 ;
18101 }
18102 GeneratedField::MaybeVnodeCount => {
18103 if maybe_vnode_count__.is_some() {
18104 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
18105 }
18106 maybe_vnode_count__ =
18107 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18108 ;
18109 }
18110 GeneratedField::Nodes => {
18111 if nodes__.is_some() {
18112 return Err(serde::de::Error::duplicate_field("nodes"));
18113 }
18114 nodes__ = map_.next_value()?;
18115 }
18116 }
18117 }
18118 Ok(table_fragments::Fragment {
18119 fragment_id: fragment_id__.unwrap_or_default(),
18120 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
18121 distribution_type: distribution_type__.unwrap_or_default(),
18122 actors: actors__.unwrap_or_default(),
18123 state_table_ids: state_table_ids__.unwrap_or_default(),
18124 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
18125 maybe_vnode_count: maybe_vnode_count__,
18126 nodes: nodes__,
18127 })
18128 }
18129 }
18130 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
18131 }
18132}
18133impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
18134 #[allow(deprecated)]
18135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18136 where
18137 S: serde::Serializer,
18138 {
18139 let variant = match self {
18140 Self::Unspecified => "UNSPECIFIED",
18141 Self::Single => "SINGLE",
18142 Self::Hash => "HASH",
18143 };
18144 serializer.serialize_str(variant)
18145 }
18146}
18147impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
18148 #[allow(deprecated)]
18149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18150 where
18151 D: serde::Deserializer<'de>,
18152 {
18153 const FIELDS: &[&str] = &[
18154 "UNSPECIFIED",
18155 "SINGLE",
18156 "HASH",
18157 ];
18158
18159 struct GeneratedVisitor;
18160
18161 impl serde::de::Visitor<'_> for GeneratedVisitor {
18162 type Value = table_fragments::fragment::FragmentDistributionType;
18163
18164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18165 write!(formatter, "expected one of: {:?}", &FIELDS)
18166 }
18167
18168 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18169 where
18170 E: serde::de::Error,
18171 {
18172 i32::try_from(v)
18173 .ok()
18174 .and_then(|x| x.try_into().ok())
18175 .ok_or_else(|| {
18176 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18177 })
18178 }
18179
18180 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18181 where
18182 E: serde::de::Error,
18183 {
18184 i32::try_from(v)
18185 .ok()
18186 .and_then(|x| x.try_into().ok())
18187 .ok_or_else(|| {
18188 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18189 })
18190 }
18191
18192 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18193 where
18194 E: serde::de::Error,
18195 {
18196 match value {
18197 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
18198 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
18199 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
18200 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18201 }
18202 }
18203 }
18204 deserializer.deserialize_any(GeneratedVisitor)
18205 }
18206}
18207impl serde::Serialize for table_fragments::State {
18208 #[allow(deprecated)]
18209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18210 where
18211 S: serde::Serializer,
18212 {
18213 let variant = match self {
18214 Self::Unspecified => "UNSPECIFIED",
18215 Self::Initial => "INITIAL",
18216 Self::Creating => "CREATING",
18217 Self::Created => "CREATED",
18218 };
18219 serializer.serialize_str(variant)
18220 }
18221}
18222impl<'de> serde::Deserialize<'de> for table_fragments::State {
18223 #[allow(deprecated)]
18224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18225 where
18226 D: serde::Deserializer<'de>,
18227 {
18228 const FIELDS: &[&str] = &[
18229 "UNSPECIFIED",
18230 "INITIAL",
18231 "CREATING",
18232 "CREATED",
18233 ];
18234
18235 struct GeneratedVisitor;
18236
18237 impl serde::de::Visitor<'_> for GeneratedVisitor {
18238 type Value = table_fragments::State;
18239
18240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18241 write!(formatter, "expected one of: {:?}", &FIELDS)
18242 }
18243
18244 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18245 where
18246 E: serde::de::Error,
18247 {
18248 i32::try_from(v)
18249 .ok()
18250 .and_then(|x| x.try_into().ok())
18251 .ok_or_else(|| {
18252 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18253 })
18254 }
18255
18256 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18257 where
18258 E: serde::de::Error,
18259 {
18260 i32::try_from(v)
18261 .ok()
18262 .and_then(|x| x.try_into().ok())
18263 .ok_or_else(|| {
18264 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18265 })
18266 }
18267
18268 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18269 where
18270 E: serde::de::Error,
18271 {
18272 match value {
18273 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
18274 "INITIAL" => Ok(table_fragments::State::Initial),
18275 "CREATING" => Ok(table_fragments::State::Creating),
18276 "CREATED" => Ok(table_fragments::State::Created),
18277 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18278 }
18279 }
18280 }
18281 deserializer.deserialize_any(GeneratedVisitor)
18282 }
18283}
18284impl serde::Serialize for TableParallelism {
18285 #[allow(deprecated)]
18286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18287 where
18288 S: serde::Serializer,
18289 {
18290 use serde::ser::SerializeStruct;
18291 let mut len = 0;
18292 if self.parallelism.is_some() {
18293 len += 1;
18294 }
18295 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
18296 if let Some(v) = self.parallelism.as_ref() {
18297 match v {
18298 table_parallelism::Parallelism::Fixed(v) => {
18299 struct_ser.serialize_field("fixed", v)?;
18300 }
18301 table_parallelism::Parallelism::Auto(v) => {
18302 struct_ser.serialize_field("auto", v)?;
18303 }
18304 table_parallelism::Parallelism::Custom(v) => {
18305 struct_ser.serialize_field("custom", v)?;
18306 }
18307 table_parallelism::Parallelism::Adaptive(v) => {
18308 struct_ser.serialize_field("adaptive", v)?;
18309 }
18310 }
18311 }
18312 struct_ser.end()
18313 }
18314}
18315impl<'de> serde::Deserialize<'de> for TableParallelism {
18316 #[allow(deprecated)]
18317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18318 where
18319 D: serde::Deserializer<'de>,
18320 {
18321 const FIELDS: &[&str] = &[
18322 "fixed",
18323 "auto",
18324 "custom",
18325 "adaptive",
18326 ];
18327
18328 #[allow(clippy::enum_variant_names)]
18329 enum GeneratedField {
18330 Fixed,
18331 Auto,
18332 Custom,
18333 Adaptive,
18334 }
18335 impl<'de> serde::Deserialize<'de> for GeneratedField {
18336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18337 where
18338 D: serde::Deserializer<'de>,
18339 {
18340 struct GeneratedVisitor;
18341
18342 impl serde::de::Visitor<'_> for GeneratedVisitor {
18343 type Value = GeneratedField;
18344
18345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18346 write!(formatter, "expected one of: {:?}", &FIELDS)
18347 }
18348
18349 #[allow(unused_variables)]
18350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18351 where
18352 E: serde::de::Error,
18353 {
18354 match value {
18355 "fixed" => Ok(GeneratedField::Fixed),
18356 "auto" => Ok(GeneratedField::Auto),
18357 "custom" => Ok(GeneratedField::Custom),
18358 "adaptive" => Ok(GeneratedField::Adaptive),
18359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18360 }
18361 }
18362 }
18363 deserializer.deserialize_identifier(GeneratedVisitor)
18364 }
18365 }
18366 struct GeneratedVisitor;
18367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18368 type Value = TableParallelism;
18369
18370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18371 formatter.write_str("struct meta.TableParallelism")
18372 }
18373
18374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
18375 where
18376 V: serde::de::MapAccess<'de>,
18377 {
18378 let mut parallelism__ = None;
18379 while let Some(k) = map_.next_key()? {
18380 match k {
18381 GeneratedField::Fixed => {
18382 if parallelism__.is_some() {
18383 return Err(serde::de::Error::duplicate_field("fixed"));
18384 }
18385 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
18386;
18387 }
18388 GeneratedField::Auto => {
18389 if parallelism__.is_some() {
18390 return Err(serde::de::Error::duplicate_field("auto"));
18391 }
18392 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
18393;
18394 }
18395 GeneratedField::Custom => {
18396 if parallelism__.is_some() {
18397 return Err(serde::de::Error::duplicate_field("custom"));
18398 }
18399 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
18400;
18401 }
18402 GeneratedField::Adaptive => {
18403 if parallelism__.is_some() {
18404 return Err(serde::de::Error::duplicate_field("adaptive"));
18405 }
18406 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
18407;
18408 }
18409 }
18410 }
18411 Ok(TableParallelism {
18412 parallelism: parallelism__,
18413 })
18414 }
18415 }
18416 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
18417 }
18418}
18419impl serde::Serialize for table_parallelism::AdaptiveParallelism {
18420 #[allow(deprecated)]
18421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18422 where
18423 S: serde::Serializer,
18424 {
18425 use serde::ser::SerializeStruct;
18426 let len = 0;
18427 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
18428 struct_ser.end()
18429 }
18430}
18431impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
18432 #[allow(deprecated)]
18433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18434 where
18435 D: serde::Deserializer<'de>,
18436 {
18437 const FIELDS: &[&str] = &[
18438 ];
18439
18440 #[allow(clippy::enum_variant_names)]
18441 enum GeneratedField {
18442 }
18443 impl<'de> serde::Deserialize<'de> for GeneratedField {
18444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18445 where
18446 D: serde::Deserializer<'de>,
18447 {
18448 struct GeneratedVisitor;
18449
18450 impl serde::de::Visitor<'_> for GeneratedVisitor {
18451 type Value = GeneratedField;
18452
18453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18454 write!(formatter, "expected one of: {:?}", &FIELDS)
18455 }
18456
18457 #[allow(unused_variables)]
18458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18459 where
18460 E: serde::de::Error,
18461 {
18462 Err(serde::de::Error::unknown_field(value, FIELDS))
18463 }
18464 }
18465 deserializer.deserialize_identifier(GeneratedVisitor)
18466 }
18467 }
18468 struct GeneratedVisitor;
18469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18470 type Value = table_parallelism::AdaptiveParallelism;
18471
18472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18473 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
18474 }
18475
18476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
18477 where
18478 V: serde::de::MapAccess<'de>,
18479 {
18480 while map_.next_key::<GeneratedField>()?.is_some() {
18481 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18482 }
18483 Ok(table_parallelism::AdaptiveParallelism {
18484 })
18485 }
18486 }
18487 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
18488 }
18489}
18490impl serde::Serialize for table_parallelism::AutoParallelism {
18491 #[allow(deprecated)]
18492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18493 where
18494 S: serde::Serializer,
18495 {
18496 use serde::ser::SerializeStruct;
18497 let len = 0;
18498 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
18499 struct_ser.end()
18500 }
18501}
18502impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
18503 #[allow(deprecated)]
18504 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18505 where
18506 D: serde::Deserializer<'de>,
18507 {
18508 const FIELDS: &[&str] = &[
18509 ];
18510
18511 #[allow(clippy::enum_variant_names)]
18512 enum GeneratedField {
18513 }
18514 impl<'de> serde::Deserialize<'de> for GeneratedField {
18515 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18516 where
18517 D: serde::Deserializer<'de>,
18518 {
18519 struct GeneratedVisitor;
18520
18521 impl serde::de::Visitor<'_> for GeneratedVisitor {
18522 type Value = GeneratedField;
18523
18524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18525 write!(formatter, "expected one of: {:?}", &FIELDS)
18526 }
18527
18528 #[allow(unused_variables)]
18529 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18530 where
18531 E: serde::de::Error,
18532 {
18533 Err(serde::de::Error::unknown_field(value, FIELDS))
18534 }
18535 }
18536 deserializer.deserialize_identifier(GeneratedVisitor)
18537 }
18538 }
18539 struct GeneratedVisitor;
18540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18541 type Value = table_parallelism::AutoParallelism;
18542
18543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18544 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
18545 }
18546
18547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
18548 where
18549 V: serde::de::MapAccess<'de>,
18550 {
18551 while map_.next_key::<GeneratedField>()?.is_some() {
18552 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18553 }
18554 Ok(table_parallelism::AutoParallelism {
18555 })
18556 }
18557 }
18558 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
18559 }
18560}
18561impl serde::Serialize for table_parallelism::CustomParallelism {
18562 #[allow(deprecated)]
18563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18564 where
18565 S: serde::Serializer,
18566 {
18567 use serde::ser::SerializeStruct;
18568 let len = 0;
18569 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
18570 struct_ser.end()
18571 }
18572}
18573impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
18574 #[allow(deprecated)]
18575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18576 where
18577 D: serde::Deserializer<'de>,
18578 {
18579 const FIELDS: &[&str] = &[
18580 ];
18581
18582 #[allow(clippy::enum_variant_names)]
18583 enum GeneratedField {
18584 }
18585 impl<'de> serde::Deserialize<'de> for GeneratedField {
18586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18587 where
18588 D: serde::Deserializer<'de>,
18589 {
18590 struct GeneratedVisitor;
18591
18592 impl serde::de::Visitor<'_> for GeneratedVisitor {
18593 type Value = GeneratedField;
18594
18595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18596 write!(formatter, "expected one of: {:?}", &FIELDS)
18597 }
18598
18599 #[allow(unused_variables)]
18600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18601 where
18602 E: serde::de::Error,
18603 {
18604 Err(serde::de::Error::unknown_field(value, FIELDS))
18605 }
18606 }
18607 deserializer.deserialize_identifier(GeneratedVisitor)
18608 }
18609 }
18610 struct GeneratedVisitor;
18611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18612 type Value = table_parallelism::CustomParallelism;
18613
18614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18615 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
18616 }
18617
18618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
18619 where
18620 V: serde::de::MapAccess<'de>,
18621 {
18622 while map_.next_key::<GeneratedField>()?.is_some() {
18623 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18624 }
18625 Ok(table_parallelism::CustomParallelism {
18626 })
18627 }
18628 }
18629 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
18630 }
18631}
18632impl serde::Serialize for table_parallelism::FixedParallelism {
18633 #[allow(deprecated)]
18634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18635 where
18636 S: serde::Serializer,
18637 {
18638 use serde::ser::SerializeStruct;
18639 let mut len = 0;
18640 if self.parallelism != 0 {
18641 len += 1;
18642 }
18643 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
18644 if self.parallelism != 0 {
18645 struct_ser.serialize_field("parallelism", &self.parallelism)?;
18646 }
18647 struct_ser.end()
18648 }
18649}
18650impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
18651 #[allow(deprecated)]
18652 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18653 where
18654 D: serde::Deserializer<'de>,
18655 {
18656 const FIELDS: &[&str] = &[
18657 "parallelism",
18658 ];
18659
18660 #[allow(clippy::enum_variant_names)]
18661 enum GeneratedField {
18662 Parallelism,
18663 }
18664 impl<'de> serde::Deserialize<'de> for GeneratedField {
18665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18666 where
18667 D: serde::Deserializer<'de>,
18668 {
18669 struct GeneratedVisitor;
18670
18671 impl serde::de::Visitor<'_> for GeneratedVisitor {
18672 type Value = GeneratedField;
18673
18674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18675 write!(formatter, "expected one of: {:?}", &FIELDS)
18676 }
18677
18678 #[allow(unused_variables)]
18679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18680 where
18681 E: serde::de::Error,
18682 {
18683 match value {
18684 "parallelism" => Ok(GeneratedField::Parallelism),
18685 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18686 }
18687 }
18688 }
18689 deserializer.deserialize_identifier(GeneratedVisitor)
18690 }
18691 }
18692 struct GeneratedVisitor;
18693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18694 type Value = table_parallelism::FixedParallelism;
18695
18696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18697 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
18698 }
18699
18700 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
18701 where
18702 V: serde::de::MapAccess<'de>,
18703 {
18704 let mut parallelism__ = None;
18705 while let Some(k) = map_.next_key()? {
18706 match k {
18707 GeneratedField::Parallelism => {
18708 if parallelism__.is_some() {
18709 return Err(serde::de::Error::duplicate_field("parallelism"));
18710 }
18711 parallelism__ =
18712 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18713 ;
18714 }
18715 }
18716 }
18717 Ok(table_parallelism::FixedParallelism {
18718 parallelism: parallelism__.unwrap_or_default(),
18719 })
18720 }
18721 }
18722 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
18723 }
18724}
18725impl serde::Serialize for TelemetryInfoResponse {
18726 #[allow(deprecated)]
18727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18728 where
18729 S: serde::Serializer,
18730 {
18731 use serde::ser::SerializeStruct;
18732 let mut len = 0;
18733 if self.tracking_id.is_some() {
18734 len += 1;
18735 }
18736 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
18737 if let Some(v) = self.tracking_id.as_ref() {
18738 struct_ser.serialize_field("trackingId", v)?;
18739 }
18740 struct_ser.end()
18741 }
18742}
18743impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
18744 #[allow(deprecated)]
18745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18746 where
18747 D: serde::Deserializer<'de>,
18748 {
18749 const FIELDS: &[&str] = &[
18750 "tracking_id",
18751 "trackingId",
18752 ];
18753
18754 #[allow(clippy::enum_variant_names)]
18755 enum GeneratedField {
18756 TrackingId,
18757 }
18758 impl<'de> serde::Deserialize<'de> for GeneratedField {
18759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18760 where
18761 D: serde::Deserializer<'de>,
18762 {
18763 struct GeneratedVisitor;
18764
18765 impl serde::de::Visitor<'_> for GeneratedVisitor {
18766 type Value = GeneratedField;
18767
18768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18769 write!(formatter, "expected one of: {:?}", &FIELDS)
18770 }
18771
18772 #[allow(unused_variables)]
18773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18774 where
18775 E: serde::de::Error,
18776 {
18777 match value {
18778 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
18779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18780 }
18781 }
18782 }
18783 deserializer.deserialize_identifier(GeneratedVisitor)
18784 }
18785 }
18786 struct GeneratedVisitor;
18787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18788 type Value = TelemetryInfoResponse;
18789
18790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18791 formatter.write_str("struct meta.TelemetryInfoResponse")
18792 }
18793
18794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
18795 where
18796 V: serde::de::MapAccess<'de>,
18797 {
18798 let mut tracking_id__ = None;
18799 while let Some(k) = map_.next_key()? {
18800 match k {
18801 GeneratedField::TrackingId => {
18802 if tracking_id__.is_some() {
18803 return Err(serde::de::Error::duplicate_field("trackingId"));
18804 }
18805 tracking_id__ = map_.next_value()?;
18806 }
18807 }
18808 }
18809 Ok(TelemetryInfoResponse {
18810 tracking_id: tracking_id__,
18811 })
18812 }
18813 }
18814 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
18815 }
18816}
18817impl serde::Serialize for ThrottleTarget {
18818 #[allow(deprecated)]
18819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18820 where
18821 S: serde::Serializer,
18822 {
18823 let variant = match self {
18824 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
18825 Self::Source => "SOURCE",
18826 Self::Mv => "MV",
18827 Self::Table => "TABLE",
18828 Self::Sink => "SINK",
18829 Self::Fragment => "FRAGMENT",
18830 };
18831 serializer.serialize_str(variant)
18832 }
18833}
18834impl<'de> serde::Deserialize<'de> for ThrottleTarget {
18835 #[allow(deprecated)]
18836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18837 where
18838 D: serde::Deserializer<'de>,
18839 {
18840 const FIELDS: &[&str] = &[
18841 "THROTTLE_TARGET_UNSPECIFIED",
18842 "SOURCE",
18843 "MV",
18844 "TABLE",
18845 "SINK",
18846 "FRAGMENT",
18847 ];
18848
18849 struct GeneratedVisitor;
18850
18851 impl serde::de::Visitor<'_> for GeneratedVisitor {
18852 type Value = ThrottleTarget;
18853
18854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18855 write!(formatter, "expected one of: {:?}", &FIELDS)
18856 }
18857
18858 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18859 where
18860 E: serde::de::Error,
18861 {
18862 i32::try_from(v)
18863 .ok()
18864 .and_then(|x| x.try_into().ok())
18865 .ok_or_else(|| {
18866 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18867 })
18868 }
18869
18870 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18871 where
18872 E: serde::de::Error,
18873 {
18874 i32::try_from(v)
18875 .ok()
18876 .and_then(|x| x.try_into().ok())
18877 .ok_or_else(|| {
18878 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18879 })
18880 }
18881
18882 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18883 where
18884 E: serde::de::Error,
18885 {
18886 match value {
18887 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
18888 "SOURCE" => Ok(ThrottleTarget::Source),
18889 "MV" => Ok(ThrottleTarget::Mv),
18890 "TABLE" => Ok(ThrottleTarget::Table),
18891 "SINK" => Ok(ThrottleTarget::Sink),
18892 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
18893 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18894 }
18895 }
18896 }
18897 deserializer.deserialize_any(GeneratedVisitor)
18898 }
18899}
18900impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
18901 #[allow(deprecated)]
18902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18903 where
18904 S: serde::Serializer,
18905 {
18906 use serde::ser::SerializeStruct;
18907 let mut len = 0;
18908 if self.id != 0 {
18909 len += 1;
18910 }
18911 if !self.node_label.is_empty() {
18912 len += 1;
18913 }
18914 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
18915 if self.id != 0 {
18916 struct_ser.serialize_field("id", &self.id)?;
18917 }
18918 if !self.node_label.is_empty() {
18919 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18920 }
18921 struct_ser.end()
18922 }
18923}
18924impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
18925 #[allow(deprecated)]
18926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18927 where
18928 D: serde::Deserializer<'de>,
18929 {
18930 const FIELDS: &[&str] = &[
18931 "id",
18932 "node_label",
18933 "nodeLabel",
18934 ];
18935
18936 #[allow(clippy::enum_variant_names)]
18937 enum GeneratedField {
18938 Id,
18939 NodeLabel,
18940 }
18941 impl<'de> serde::Deserialize<'de> for GeneratedField {
18942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18943 where
18944 D: serde::Deserializer<'de>,
18945 {
18946 struct GeneratedVisitor;
18947
18948 impl serde::de::Visitor<'_> for GeneratedVisitor {
18949 type Value = GeneratedField;
18950
18951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18952 write!(formatter, "expected one of: {:?}", &FIELDS)
18953 }
18954
18955 #[allow(unused_variables)]
18956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18957 where
18958 E: serde::de::Error,
18959 {
18960 match value {
18961 "id" => Ok(GeneratedField::Id),
18962 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18964 }
18965 }
18966 }
18967 deserializer.deserialize_identifier(GeneratedVisitor)
18968 }
18969 }
18970 struct GeneratedVisitor;
18971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18972 type Value = UpdateStreamingJobNodeLabelsRequest;
18973
18974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18975 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
18976 }
18977
18978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
18979 where
18980 V: serde::de::MapAccess<'de>,
18981 {
18982 let mut id__ = None;
18983 let mut node_label__ = None;
18984 while let Some(k) = map_.next_key()? {
18985 match k {
18986 GeneratedField::Id => {
18987 if id__.is_some() {
18988 return Err(serde::de::Error::duplicate_field("id"));
18989 }
18990 id__ =
18991 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18992 ;
18993 }
18994 GeneratedField::NodeLabel => {
18995 if node_label__.is_some() {
18996 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18997 }
18998 node_label__ = Some(map_.next_value()?);
18999 }
19000 }
19001 }
19002 Ok(UpdateStreamingJobNodeLabelsRequest {
19003 id: id__.unwrap_or_default(),
19004 node_label: node_label__.unwrap_or_default(),
19005 })
19006 }
19007 }
19008 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
19009 }
19010}
19011impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
19012 #[allow(deprecated)]
19013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19014 where
19015 S: serde::Serializer,
19016 {
19017 use serde::ser::SerializeStruct;
19018 let len = 0;
19019 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
19020 struct_ser.end()
19021 }
19022}
19023impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
19024 #[allow(deprecated)]
19025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19026 where
19027 D: serde::Deserializer<'de>,
19028 {
19029 const FIELDS: &[&str] = &[
19030 ];
19031
19032 #[allow(clippy::enum_variant_names)]
19033 enum GeneratedField {
19034 }
19035 impl<'de> serde::Deserialize<'de> for GeneratedField {
19036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19037 where
19038 D: serde::Deserializer<'de>,
19039 {
19040 struct GeneratedVisitor;
19041
19042 impl serde::de::Visitor<'_> for GeneratedVisitor {
19043 type Value = GeneratedField;
19044
19045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19046 write!(formatter, "expected one of: {:?}", &FIELDS)
19047 }
19048
19049 #[allow(unused_variables)]
19050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19051 where
19052 E: serde::de::Error,
19053 {
19054 Err(serde::de::Error::unknown_field(value, FIELDS))
19055 }
19056 }
19057 deserializer.deserialize_identifier(GeneratedVisitor)
19058 }
19059 }
19060 struct GeneratedVisitor;
19061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19062 type Value = UpdateStreamingJobNodeLabelsResponse;
19063
19064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19065 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
19066 }
19067
19068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
19069 where
19070 V: serde::de::MapAccess<'de>,
19071 {
19072 while map_.next_key::<GeneratedField>()?.is_some() {
19073 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19074 }
19075 Ok(UpdateStreamingJobNodeLabelsResponse {
19076 })
19077 }
19078 }
19079 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
19080 }
19081}
19082impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
19083 #[allow(deprecated)]
19084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19085 where
19086 S: serde::Serializer,
19087 {
19088 use serde::ser::SerializeStruct;
19089 let mut len = 0;
19090 if !self.worker_ids.is_empty() {
19091 len += 1;
19092 }
19093 if self.schedulability != 0 {
19094 len += 1;
19095 }
19096 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
19097 if !self.worker_ids.is_empty() {
19098 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
19099 }
19100 if self.schedulability != 0 {
19101 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
19102 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
19103 struct_ser.serialize_field("schedulability", &v)?;
19104 }
19105 struct_ser.end()
19106 }
19107}
19108impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
19109 #[allow(deprecated)]
19110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19111 where
19112 D: serde::Deserializer<'de>,
19113 {
19114 const FIELDS: &[&str] = &[
19115 "worker_ids",
19116 "workerIds",
19117 "schedulability",
19118 ];
19119
19120 #[allow(clippy::enum_variant_names)]
19121 enum GeneratedField {
19122 WorkerIds,
19123 Schedulability,
19124 }
19125 impl<'de> serde::Deserialize<'de> for GeneratedField {
19126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19127 where
19128 D: serde::Deserializer<'de>,
19129 {
19130 struct GeneratedVisitor;
19131
19132 impl serde::de::Visitor<'_> for GeneratedVisitor {
19133 type Value = GeneratedField;
19134
19135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19136 write!(formatter, "expected one of: {:?}", &FIELDS)
19137 }
19138
19139 #[allow(unused_variables)]
19140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19141 where
19142 E: serde::de::Error,
19143 {
19144 match value {
19145 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
19146 "schedulability" => Ok(GeneratedField::Schedulability),
19147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19148 }
19149 }
19150 }
19151 deserializer.deserialize_identifier(GeneratedVisitor)
19152 }
19153 }
19154 struct GeneratedVisitor;
19155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19156 type Value = UpdateWorkerNodeSchedulabilityRequest;
19157
19158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19159 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
19160 }
19161
19162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
19163 where
19164 V: serde::de::MapAccess<'de>,
19165 {
19166 let mut worker_ids__ = None;
19167 let mut schedulability__ = None;
19168 while let Some(k) = map_.next_key()? {
19169 match k {
19170 GeneratedField::WorkerIds => {
19171 if worker_ids__.is_some() {
19172 return Err(serde::de::Error::duplicate_field("workerIds"));
19173 }
19174 worker_ids__ =
19175 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19176 .into_iter().map(|x| x.0).collect())
19177 ;
19178 }
19179 GeneratedField::Schedulability => {
19180 if schedulability__.is_some() {
19181 return Err(serde::de::Error::duplicate_field("schedulability"));
19182 }
19183 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
19184 }
19185 }
19186 }
19187 Ok(UpdateWorkerNodeSchedulabilityRequest {
19188 worker_ids: worker_ids__.unwrap_or_default(),
19189 schedulability: schedulability__.unwrap_or_default(),
19190 })
19191 }
19192 }
19193 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
19194 }
19195}
19196impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
19197 #[allow(deprecated)]
19198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19199 where
19200 S: serde::Serializer,
19201 {
19202 let variant = match self {
19203 Self::Unspecified => "UNSPECIFIED",
19204 Self::Schedulable => "SCHEDULABLE",
19205 Self::Unschedulable => "UNSCHEDULABLE",
19206 };
19207 serializer.serialize_str(variant)
19208 }
19209}
19210impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
19211 #[allow(deprecated)]
19212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19213 where
19214 D: serde::Deserializer<'de>,
19215 {
19216 const FIELDS: &[&str] = &[
19217 "UNSPECIFIED",
19218 "SCHEDULABLE",
19219 "UNSCHEDULABLE",
19220 ];
19221
19222 struct GeneratedVisitor;
19223
19224 impl serde::de::Visitor<'_> for GeneratedVisitor {
19225 type Value = update_worker_node_schedulability_request::Schedulability;
19226
19227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19228 write!(formatter, "expected one of: {:?}", &FIELDS)
19229 }
19230
19231 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19232 where
19233 E: serde::de::Error,
19234 {
19235 i32::try_from(v)
19236 .ok()
19237 .and_then(|x| x.try_into().ok())
19238 .ok_or_else(|| {
19239 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19240 })
19241 }
19242
19243 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19244 where
19245 E: serde::de::Error,
19246 {
19247 i32::try_from(v)
19248 .ok()
19249 .and_then(|x| x.try_into().ok())
19250 .ok_or_else(|| {
19251 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19252 })
19253 }
19254
19255 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19256 where
19257 E: serde::de::Error,
19258 {
19259 match value {
19260 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
19261 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
19262 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
19263 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19264 }
19265 }
19266 }
19267 deserializer.deserialize_any(GeneratedVisitor)
19268 }
19269}
19270impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
19271 #[allow(deprecated)]
19272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19273 where
19274 S: serde::Serializer,
19275 {
19276 use serde::ser::SerializeStruct;
19277 let mut len = 0;
19278 if self.status.is_some() {
19279 len += 1;
19280 }
19281 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
19282 if let Some(v) = self.status.as_ref() {
19283 struct_ser.serialize_field("status", v)?;
19284 }
19285 struct_ser.end()
19286 }
19287}
19288impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
19289 #[allow(deprecated)]
19290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19291 where
19292 D: serde::Deserializer<'de>,
19293 {
19294 const FIELDS: &[&str] = &[
19295 "status",
19296 ];
19297
19298 #[allow(clippy::enum_variant_names)]
19299 enum GeneratedField {
19300 Status,
19301 }
19302 impl<'de> serde::Deserialize<'de> for GeneratedField {
19303 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19304 where
19305 D: serde::Deserializer<'de>,
19306 {
19307 struct GeneratedVisitor;
19308
19309 impl serde::de::Visitor<'_> for GeneratedVisitor {
19310 type Value = GeneratedField;
19311
19312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19313 write!(formatter, "expected one of: {:?}", &FIELDS)
19314 }
19315
19316 #[allow(unused_variables)]
19317 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19318 where
19319 E: serde::de::Error,
19320 {
19321 match value {
19322 "status" => Ok(GeneratedField::Status),
19323 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19324 }
19325 }
19326 }
19327 deserializer.deserialize_identifier(GeneratedVisitor)
19328 }
19329 }
19330 struct GeneratedVisitor;
19331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19332 type Value = UpdateWorkerNodeSchedulabilityResponse;
19333
19334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19335 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
19336 }
19337
19338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
19339 where
19340 V: serde::de::MapAccess<'de>,
19341 {
19342 let mut status__ = None;
19343 while let Some(k) = map_.next_key()? {
19344 match k {
19345 GeneratedField::Status => {
19346 if status__.is_some() {
19347 return Err(serde::de::Error::duplicate_field("status"));
19348 }
19349 status__ = map_.next_value()?;
19350 }
19351 }
19352 }
19353 Ok(UpdateWorkerNodeSchedulabilityResponse {
19354 status: status__,
19355 })
19356 }
19357 }
19358 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
19359 }
19360}
19361impl serde::Serialize for WorkerReschedule {
19362 #[allow(deprecated)]
19363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19364 where
19365 S: serde::Serializer,
19366 {
19367 use serde::ser::SerializeStruct;
19368 let mut len = 0;
19369 if !self.worker_actor_diff.is_empty() {
19370 len += 1;
19371 }
19372 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
19373 if !self.worker_actor_diff.is_empty() {
19374 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
19375 }
19376 struct_ser.end()
19377 }
19378}
19379impl<'de> serde::Deserialize<'de> for WorkerReschedule {
19380 #[allow(deprecated)]
19381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19382 where
19383 D: serde::Deserializer<'de>,
19384 {
19385 const FIELDS: &[&str] = &[
19386 "worker_actor_diff",
19387 "workerActorDiff",
19388 ];
19389
19390 #[allow(clippy::enum_variant_names)]
19391 enum GeneratedField {
19392 WorkerActorDiff,
19393 }
19394 impl<'de> serde::Deserialize<'de> for GeneratedField {
19395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19396 where
19397 D: serde::Deserializer<'de>,
19398 {
19399 struct GeneratedVisitor;
19400
19401 impl serde::de::Visitor<'_> for GeneratedVisitor {
19402 type Value = GeneratedField;
19403
19404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19405 write!(formatter, "expected one of: {:?}", &FIELDS)
19406 }
19407
19408 #[allow(unused_variables)]
19409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19410 where
19411 E: serde::de::Error,
19412 {
19413 match value {
19414 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
19415 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19416 }
19417 }
19418 }
19419 deserializer.deserialize_identifier(GeneratedVisitor)
19420 }
19421 }
19422 struct GeneratedVisitor;
19423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19424 type Value = WorkerReschedule;
19425
19426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19427 formatter.write_str("struct meta.WorkerReschedule")
19428 }
19429
19430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
19431 where
19432 V: serde::de::MapAccess<'de>,
19433 {
19434 let mut worker_actor_diff__ = None;
19435 while let Some(k) = map_.next_key()? {
19436 match k {
19437 GeneratedField::WorkerActorDiff => {
19438 if worker_actor_diff__.is_some() {
19439 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
19440 }
19441 worker_actor_diff__ = Some(
19442 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
19443 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
19444 );
19445 }
19446 }
19447 }
19448 Ok(WorkerReschedule {
19449 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
19450 })
19451 }
19452 }
19453 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
19454 }
19455}