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 if self.database_id != 0 {
3311 len += 1;
3312 }
3313 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3314 if self.prev_epoch != 0 {
3315 #[allow(clippy::needless_borrow)]
3316 #[allow(clippy::needless_borrows_for_generic_args)]
3317 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3318 }
3319 if self.cur_epoch != 0 {
3320 #[allow(clippy::needless_borrow)]
3321 #[allow(clippy::needless_borrows_for_generic_args)]
3322 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3323 }
3324 if self.duration_sec != 0. {
3325 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3326 }
3327 if !self.command.is_empty() {
3328 struct_ser.serialize_field("command", &self.command)?;
3329 }
3330 if !self.barrier_kind.is_empty() {
3331 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3332 }
3333 if self.database_id != 0 {
3334 struct_ser.serialize_field("databaseId", &self.database_id)?;
3335 }
3336 struct_ser.end()
3337 }
3338}
3339impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3340 #[allow(deprecated)]
3341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3342 where
3343 D: serde::Deserializer<'de>,
3344 {
3345 const FIELDS: &[&str] = &[
3346 "prev_epoch",
3347 "prevEpoch",
3348 "cur_epoch",
3349 "curEpoch",
3350 "duration_sec",
3351 "durationSec",
3352 "command",
3353 "barrier_kind",
3354 "barrierKind",
3355 "database_id",
3356 "databaseId",
3357 ];
3358
3359 #[allow(clippy::enum_variant_names)]
3360 enum GeneratedField {
3361 PrevEpoch,
3362 CurEpoch,
3363 DurationSec,
3364 Command,
3365 BarrierKind,
3366 DatabaseId,
3367 }
3368 impl<'de> serde::Deserialize<'de> for GeneratedField {
3369 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3370 where
3371 D: serde::Deserializer<'de>,
3372 {
3373 struct GeneratedVisitor;
3374
3375 impl serde::de::Visitor<'_> for GeneratedVisitor {
3376 type Value = GeneratedField;
3377
3378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3379 write!(formatter, "expected one of: {:?}", &FIELDS)
3380 }
3381
3382 #[allow(unused_variables)]
3383 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3384 where
3385 E: serde::de::Error,
3386 {
3387 match value {
3388 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3389 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3390 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3391 "command" => Ok(GeneratedField::Command),
3392 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3393 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3395 }
3396 }
3397 }
3398 deserializer.deserialize_identifier(GeneratedVisitor)
3399 }
3400 }
3401 struct GeneratedVisitor;
3402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3403 type Value = event_log::EventBarrierComplete;
3404
3405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3406 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3407 }
3408
3409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3410 where
3411 V: serde::de::MapAccess<'de>,
3412 {
3413 let mut prev_epoch__ = None;
3414 let mut cur_epoch__ = None;
3415 let mut duration_sec__ = None;
3416 let mut command__ = None;
3417 let mut barrier_kind__ = None;
3418 let mut database_id__ = None;
3419 while let Some(k) = map_.next_key()? {
3420 match k {
3421 GeneratedField::PrevEpoch => {
3422 if prev_epoch__.is_some() {
3423 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3424 }
3425 prev_epoch__ =
3426 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3427 ;
3428 }
3429 GeneratedField::CurEpoch => {
3430 if cur_epoch__.is_some() {
3431 return Err(serde::de::Error::duplicate_field("curEpoch"));
3432 }
3433 cur_epoch__ =
3434 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3435 ;
3436 }
3437 GeneratedField::DurationSec => {
3438 if duration_sec__.is_some() {
3439 return Err(serde::de::Error::duplicate_field("durationSec"));
3440 }
3441 duration_sec__ =
3442 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3443 ;
3444 }
3445 GeneratedField::Command => {
3446 if command__.is_some() {
3447 return Err(serde::de::Error::duplicate_field("command"));
3448 }
3449 command__ = Some(map_.next_value()?);
3450 }
3451 GeneratedField::BarrierKind => {
3452 if barrier_kind__.is_some() {
3453 return Err(serde::de::Error::duplicate_field("barrierKind"));
3454 }
3455 barrier_kind__ = Some(map_.next_value()?);
3456 }
3457 GeneratedField::DatabaseId => {
3458 if database_id__.is_some() {
3459 return Err(serde::de::Error::duplicate_field("databaseId"));
3460 }
3461 database_id__ =
3462 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3463 ;
3464 }
3465 }
3466 }
3467 Ok(event_log::EventBarrierComplete {
3468 prev_epoch: prev_epoch__.unwrap_or_default(),
3469 cur_epoch: cur_epoch__.unwrap_or_default(),
3470 duration_sec: duration_sec__.unwrap_or_default(),
3471 command: command__.unwrap_or_default(),
3472 barrier_kind: barrier_kind__.unwrap_or_default(),
3473 database_id: database_id__.unwrap_or_default(),
3474 })
3475 }
3476 }
3477 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3478 }
3479}
3480impl serde::Serialize for event_log::EventCollectBarrierFail {
3481 #[allow(deprecated)]
3482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3483 where
3484 S: serde::Serializer,
3485 {
3486 use serde::ser::SerializeStruct;
3487 let mut len = 0;
3488 if !self.error.is_empty() {
3489 len += 1;
3490 }
3491 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3492 if !self.error.is_empty() {
3493 struct_ser.serialize_field("error", &self.error)?;
3494 }
3495 struct_ser.end()
3496 }
3497}
3498impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3499 #[allow(deprecated)]
3500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3501 where
3502 D: serde::Deserializer<'de>,
3503 {
3504 const FIELDS: &[&str] = &[
3505 "error",
3506 ];
3507
3508 #[allow(clippy::enum_variant_names)]
3509 enum GeneratedField {
3510 Error,
3511 }
3512 impl<'de> serde::Deserialize<'de> for GeneratedField {
3513 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3514 where
3515 D: serde::Deserializer<'de>,
3516 {
3517 struct GeneratedVisitor;
3518
3519 impl serde::de::Visitor<'_> for GeneratedVisitor {
3520 type Value = GeneratedField;
3521
3522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3523 write!(formatter, "expected one of: {:?}", &FIELDS)
3524 }
3525
3526 #[allow(unused_variables)]
3527 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3528 where
3529 E: serde::de::Error,
3530 {
3531 match value {
3532 "error" => Ok(GeneratedField::Error),
3533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3534 }
3535 }
3536 }
3537 deserializer.deserialize_identifier(GeneratedVisitor)
3538 }
3539 }
3540 struct GeneratedVisitor;
3541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3542 type Value = event_log::EventCollectBarrierFail;
3543
3544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3545 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3546 }
3547
3548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3549 where
3550 V: serde::de::MapAccess<'de>,
3551 {
3552 let mut error__ = None;
3553 while let Some(k) = map_.next_key()? {
3554 match k {
3555 GeneratedField::Error => {
3556 if error__.is_some() {
3557 return Err(serde::de::Error::duplicate_field("error"));
3558 }
3559 error__ = Some(map_.next_value()?);
3560 }
3561 }
3562 }
3563 Ok(event_log::EventCollectBarrierFail {
3564 error: error__.unwrap_or_default(),
3565 })
3566 }
3567 }
3568 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3569 }
3570}
3571impl serde::Serialize for event_log::EventCreateStreamJobFail {
3572 #[allow(deprecated)]
3573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3574 where
3575 S: serde::Serializer,
3576 {
3577 use serde::ser::SerializeStruct;
3578 let mut len = 0;
3579 if self.id != 0 {
3580 len += 1;
3581 }
3582 if !self.name.is_empty() {
3583 len += 1;
3584 }
3585 if !self.definition.is_empty() {
3586 len += 1;
3587 }
3588 if !self.error.is_empty() {
3589 len += 1;
3590 }
3591 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3592 if self.id != 0 {
3593 struct_ser.serialize_field("id", &self.id)?;
3594 }
3595 if !self.name.is_empty() {
3596 struct_ser.serialize_field("name", &self.name)?;
3597 }
3598 if !self.definition.is_empty() {
3599 struct_ser.serialize_field("definition", &self.definition)?;
3600 }
3601 if !self.error.is_empty() {
3602 struct_ser.serialize_field("error", &self.error)?;
3603 }
3604 struct_ser.end()
3605 }
3606}
3607impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3608 #[allow(deprecated)]
3609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3610 where
3611 D: serde::Deserializer<'de>,
3612 {
3613 const FIELDS: &[&str] = &[
3614 "id",
3615 "name",
3616 "definition",
3617 "error",
3618 ];
3619
3620 #[allow(clippy::enum_variant_names)]
3621 enum GeneratedField {
3622 Id,
3623 Name,
3624 Definition,
3625 Error,
3626 }
3627 impl<'de> serde::Deserialize<'de> for GeneratedField {
3628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3629 where
3630 D: serde::Deserializer<'de>,
3631 {
3632 struct GeneratedVisitor;
3633
3634 impl serde::de::Visitor<'_> for GeneratedVisitor {
3635 type Value = GeneratedField;
3636
3637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3638 write!(formatter, "expected one of: {:?}", &FIELDS)
3639 }
3640
3641 #[allow(unused_variables)]
3642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3643 where
3644 E: serde::de::Error,
3645 {
3646 match value {
3647 "id" => Ok(GeneratedField::Id),
3648 "name" => Ok(GeneratedField::Name),
3649 "definition" => Ok(GeneratedField::Definition),
3650 "error" => Ok(GeneratedField::Error),
3651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3652 }
3653 }
3654 }
3655 deserializer.deserialize_identifier(GeneratedVisitor)
3656 }
3657 }
3658 struct GeneratedVisitor;
3659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3660 type Value = event_log::EventCreateStreamJobFail;
3661
3662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3663 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3664 }
3665
3666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3667 where
3668 V: serde::de::MapAccess<'de>,
3669 {
3670 let mut id__ = None;
3671 let mut name__ = None;
3672 let mut definition__ = None;
3673 let mut error__ = None;
3674 while let Some(k) = map_.next_key()? {
3675 match k {
3676 GeneratedField::Id => {
3677 if id__.is_some() {
3678 return Err(serde::de::Error::duplicate_field("id"));
3679 }
3680 id__ =
3681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3682 ;
3683 }
3684 GeneratedField::Name => {
3685 if name__.is_some() {
3686 return Err(serde::de::Error::duplicate_field("name"));
3687 }
3688 name__ = Some(map_.next_value()?);
3689 }
3690 GeneratedField::Definition => {
3691 if definition__.is_some() {
3692 return Err(serde::de::Error::duplicate_field("definition"));
3693 }
3694 definition__ = Some(map_.next_value()?);
3695 }
3696 GeneratedField::Error => {
3697 if error__.is_some() {
3698 return Err(serde::de::Error::duplicate_field("error"));
3699 }
3700 error__ = Some(map_.next_value()?);
3701 }
3702 }
3703 }
3704 Ok(event_log::EventCreateStreamJobFail {
3705 id: id__.unwrap_or_default(),
3706 name: name__.unwrap_or_default(),
3707 definition: definition__.unwrap_or_default(),
3708 error: error__.unwrap_or_default(),
3709 })
3710 }
3711 }
3712 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3713 }
3714}
3715impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3716 #[allow(deprecated)]
3717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3718 where
3719 S: serde::Serializer,
3720 {
3721 use serde::ser::SerializeStruct;
3722 let mut len = 0;
3723 if self.id != 0 {
3724 len += 1;
3725 }
3726 if !self.name.is_empty() {
3727 len += 1;
3728 }
3729 if !self.definition.is_empty() {
3730 len += 1;
3731 }
3732 if !self.error.is_empty() {
3733 len += 1;
3734 }
3735 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3736 if self.id != 0 {
3737 struct_ser.serialize_field("id", &self.id)?;
3738 }
3739 if !self.name.is_empty() {
3740 struct_ser.serialize_field("name", &self.name)?;
3741 }
3742 if !self.definition.is_empty() {
3743 struct_ser.serialize_field("definition", &self.definition)?;
3744 }
3745 if !self.error.is_empty() {
3746 struct_ser.serialize_field("error", &self.error)?;
3747 }
3748 struct_ser.end()
3749 }
3750}
3751impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3752 #[allow(deprecated)]
3753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3754 where
3755 D: serde::Deserializer<'de>,
3756 {
3757 const FIELDS: &[&str] = &[
3758 "id",
3759 "name",
3760 "definition",
3761 "error",
3762 ];
3763
3764 #[allow(clippy::enum_variant_names)]
3765 enum GeneratedField {
3766 Id,
3767 Name,
3768 Definition,
3769 Error,
3770 }
3771 impl<'de> serde::Deserialize<'de> for GeneratedField {
3772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3773 where
3774 D: serde::Deserializer<'de>,
3775 {
3776 struct GeneratedVisitor;
3777
3778 impl serde::de::Visitor<'_> for GeneratedVisitor {
3779 type Value = GeneratedField;
3780
3781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3782 write!(formatter, "expected one of: {:?}", &FIELDS)
3783 }
3784
3785 #[allow(unused_variables)]
3786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3787 where
3788 E: serde::de::Error,
3789 {
3790 match value {
3791 "id" => Ok(GeneratedField::Id),
3792 "name" => Ok(GeneratedField::Name),
3793 "definition" => Ok(GeneratedField::Definition),
3794 "error" => Ok(GeneratedField::Error),
3795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3796 }
3797 }
3798 }
3799 deserializer.deserialize_identifier(GeneratedVisitor)
3800 }
3801 }
3802 struct GeneratedVisitor;
3803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3804 type Value = event_log::EventDirtyStreamJobClear;
3805
3806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3807 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3808 }
3809
3810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3811 where
3812 V: serde::de::MapAccess<'de>,
3813 {
3814 let mut id__ = None;
3815 let mut name__ = None;
3816 let mut definition__ = None;
3817 let mut error__ = None;
3818 while let Some(k) = map_.next_key()? {
3819 match k {
3820 GeneratedField::Id => {
3821 if id__.is_some() {
3822 return Err(serde::de::Error::duplicate_field("id"));
3823 }
3824 id__ =
3825 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3826 ;
3827 }
3828 GeneratedField::Name => {
3829 if name__.is_some() {
3830 return Err(serde::de::Error::duplicate_field("name"));
3831 }
3832 name__ = Some(map_.next_value()?);
3833 }
3834 GeneratedField::Definition => {
3835 if definition__.is_some() {
3836 return Err(serde::de::Error::duplicate_field("definition"));
3837 }
3838 definition__ = Some(map_.next_value()?);
3839 }
3840 GeneratedField::Error => {
3841 if error__.is_some() {
3842 return Err(serde::de::Error::duplicate_field("error"));
3843 }
3844 error__ = Some(map_.next_value()?);
3845 }
3846 }
3847 }
3848 Ok(event_log::EventDirtyStreamJobClear {
3849 id: id__.unwrap_or_default(),
3850 name: name__.unwrap_or_default(),
3851 definition: definition__.unwrap_or_default(),
3852 error: error__.unwrap_or_default(),
3853 })
3854 }
3855 }
3856 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3857 }
3858}
3859impl serde::Serialize for event_log::EventInjectBarrierFail {
3860 #[allow(deprecated)]
3861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3862 where
3863 S: serde::Serializer,
3864 {
3865 use serde::ser::SerializeStruct;
3866 let mut len = 0;
3867 if self.prev_epoch != 0 {
3868 len += 1;
3869 }
3870 if self.cur_epoch != 0 {
3871 len += 1;
3872 }
3873 if !self.error.is_empty() {
3874 len += 1;
3875 }
3876 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3877 if self.prev_epoch != 0 {
3878 #[allow(clippy::needless_borrow)]
3879 #[allow(clippy::needless_borrows_for_generic_args)]
3880 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3881 }
3882 if self.cur_epoch != 0 {
3883 #[allow(clippy::needless_borrow)]
3884 #[allow(clippy::needless_borrows_for_generic_args)]
3885 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3886 }
3887 if !self.error.is_empty() {
3888 struct_ser.serialize_field("error", &self.error)?;
3889 }
3890 struct_ser.end()
3891 }
3892}
3893impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3894 #[allow(deprecated)]
3895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3896 where
3897 D: serde::Deserializer<'de>,
3898 {
3899 const FIELDS: &[&str] = &[
3900 "prev_epoch",
3901 "prevEpoch",
3902 "cur_epoch",
3903 "curEpoch",
3904 "error",
3905 ];
3906
3907 #[allow(clippy::enum_variant_names)]
3908 enum GeneratedField {
3909 PrevEpoch,
3910 CurEpoch,
3911 Error,
3912 }
3913 impl<'de> serde::Deserialize<'de> for GeneratedField {
3914 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3915 where
3916 D: serde::Deserializer<'de>,
3917 {
3918 struct GeneratedVisitor;
3919
3920 impl serde::de::Visitor<'_> for GeneratedVisitor {
3921 type Value = GeneratedField;
3922
3923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3924 write!(formatter, "expected one of: {:?}", &FIELDS)
3925 }
3926
3927 #[allow(unused_variables)]
3928 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3929 where
3930 E: serde::de::Error,
3931 {
3932 match value {
3933 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3934 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3935 "error" => Ok(GeneratedField::Error),
3936 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3937 }
3938 }
3939 }
3940 deserializer.deserialize_identifier(GeneratedVisitor)
3941 }
3942 }
3943 struct GeneratedVisitor;
3944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3945 type Value = event_log::EventInjectBarrierFail;
3946
3947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3948 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3949 }
3950
3951 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3952 where
3953 V: serde::de::MapAccess<'de>,
3954 {
3955 let mut prev_epoch__ = None;
3956 let mut cur_epoch__ = None;
3957 let mut error__ = None;
3958 while let Some(k) = map_.next_key()? {
3959 match k {
3960 GeneratedField::PrevEpoch => {
3961 if prev_epoch__.is_some() {
3962 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3963 }
3964 prev_epoch__ =
3965 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3966 ;
3967 }
3968 GeneratedField::CurEpoch => {
3969 if cur_epoch__.is_some() {
3970 return Err(serde::de::Error::duplicate_field("curEpoch"));
3971 }
3972 cur_epoch__ =
3973 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3974 ;
3975 }
3976 GeneratedField::Error => {
3977 if error__.is_some() {
3978 return Err(serde::de::Error::duplicate_field("error"));
3979 }
3980 error__ = Some(map_.next_value()?);
3981 }
3982 }
3983 }
3984 Ok(event_log::EventInjectBarrierFail {
3985 prev_epoch: prev_epoch__.unwrap_or_default(),
3986 cur_epoch: cur_epoch__.unwrap_or_default(),
3987 error: error__.unwrap_or_default(),
3988 })
3989 }
3990 }
3991 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3992 }
3993}
3994impl serde::Serialize for event_log::EventMetaNodeStart {
3995 #[allow(deprecated)]
3996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3997 where
3998 S: serde::Serializer,
3999 {
4000 use serde::ser::SerializeStruct;
4001 let mut len = 0;
4002 if !self.advertise_addr.is_empty() {
4003 len += 1;
4004 }
4005 if !self.listen_addr.is_empty() {
4006 len += 1;
4007 }
4008 if !self.opts.is_empty() {
4009 len += 1;
4010 }
4011 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
4012 if !self.advertise_addr.is_empty() {
4013 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
4014 }
4015 if !self.listen_addr.is_empty() {
4016 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
4017 }
4018 if !self.opts.is_empty() {
4019 struct_ser.serialize_field("opts", &self.opts)?;
4020 }
4021 struct_ser.end()
4022 }
4023}
4024impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
4025 #[allow(deprecated)]
4026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4027 where
4028 D: serde::Deserializer<'de>,
4029 {
4030 const FIELDS: &[&str] = &[
4031 "advertise_addr",
4032 "advertiseAddr",
4033 "listen_addr",
4034 "listenAddr",
4035 "opts",
4036 ];
4037
4038 #[allow(clippy::enum_variant_names)]
4039 enum GeneratedField {
4040 AdvertiseAddr,
4041 ListenAddr,
4042 Opts,
4043 }
4044 impl<'de> serde::Deserialize<'de> for GeneratedField {
4045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4046 where
4047 D: serde::Deserializer<'de>,
4048 {
4049 struct GeneratedVisitor;
4050
4051 impl serde::de::Visitor<'_> for GeneratedVisitor {
4052 type Value = GeneratedField;
4053
4054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4055 write!(formatter, "expected one of: {:?}", &FIELDS)
4056 }
4057
4058 #[allow(unused_variables)]
4059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4060 where
4061 E: serde::de::Error,
4062 {
4063 match value {
4064 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
4065 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
4066 "opts" => Ok(GeneratedField::Opts),
4067 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4068 }
4069 }
4070 }
4071 deserializer.deserialize_identifier(GeneratedVisitor)
4072 }
4073 }
4074 struct GeneratedVisitor;
4075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4076 type Value = event_log::EventMetaNodeStart;
4077
4078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4079 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
4080 }
4081
4082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
4083 where
4084 V: serde::de::MapAccess<'de>,
4085 {
4086 let mut advertise_addr__ = None;
4087 let mut listen_addr__ = None;
4088 let mut opts__ = None;
4089 while let Some(k) = map_.next_key()? {
4090 match k {
4091 GeneratedField::AdvertiseAddr => {
4092 if advertise_addr__.is_some() {
4093 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
4094 }
4095 advertise_addr__ = Some(map_.next_value()?);
4096 }
4097 GeneratedField::ListenAddr => {
4098 if listen_addr__.is_some() {
4099 return Err(serde::de::Error::duplicate_field("listenAddr"));
4100 }
4101 listen_addr__ = Some(map_.next_value()?);
4102 }
4103 GeneratedField::Opts => {
4104 if opts__.is_some() {
4105 return Err(serde::de::Error::duplicate_field("opts"));
4106 }
4107 opts__ = Some(map_.next_value()?);
4108 }
4109 }
4110 }
4111 Ok(event_log::EventMetaNodeStart {
4112 advertise_addr: advertise_addr__.unwrap_or_default(),
4113 listen_addr: listen_addr__.unwrap_or_default(),
4114 opts: opts__.unwrap_or_default(),
4115 })
4116 }
4117 }
4118 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
4119 }
4120}
4121impl serde::Serialize for event_log::EventRecovery {
4122 #[allow(deprecated)]
4123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4124 where
4125 S: serde::Serializer,
4126 {
4127 use serde::ser::SerializeStruct;
4128 let mut len = 0;
4129 if self.recovery_event.is_some() {
4130 len += 1;
4131 }
4132 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
4133 if let Some(v) = self.recovery_event.as_ref() {
4134 match v {
4135 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
4136 struct_ser.serialize_field("globalStart", v)?;
4137 }
4138 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
4139 struct_ser.serialize_field("globalSuccess", v)?;
4140 }
4141 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
4142 struct_ser.serialize_field("globalFailure", v)?;
4143 }
4144 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
4145 struct_ser.serialize_field("databaseStart", v)?;
4146 }
4147 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
4148 struct_ser.serialize_field("databaseFailure", v)?;
4149 }
4150 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
4151 struct_ser.serialize_field("databaseSuccess", v)?;
4152 }
4153 }
4154 }
4155 struct_ser.end()
4156 }
4157}
4158impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
4159 #[allow(deprecated)]
4160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4161 where
4162 D: serde::Deserializer<'de>,
4163 {
4164 const FIELDS: &[&str] = &[
4165 "global_start",
4166 "globalStart",
4167 "global_success",
4168 "globalSuccess",
4169 "global_failure",
4170 "globalFailure",
4171 "database_start",
4172 "databaseStart",
4173 "database_failure",
4174 "databaseFailure",
4175 "database_success",
4176 "databaseSuccess",
4177 ];
4178
4179 #[allow(clippy::enum_variant_names)]
4180 enum GeneratedField {
4181 GlobalStart,
4182 GlobalSuccess,
4183 GlobalFailure,
4184 DatabaseStart,
4185 DatabaseFailure,
4186 DatabaseSuccess,
4187 }
4188 impl<'de> serde::Deserialize<'de> for GeneratedField {
4189 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4190 where
4191 D: serde::Deserializer<'de>,
4192 {
4193 struct GeneratedVisitor;
4194
4195 impl serde::de::Visitor<'_> for GeneratedVisitor {
4196 type Value = GeneratedField;
4197
4198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4199 write!(formatter, "expected one of: {:?}", &FIELDS)
4200 }
4201
4202 #[allow(unused_variables)]
4203 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4204 where
4205 E: serde::de::Error,
4206 {
4207 match value {
4208 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
4209 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
4210 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
4211 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
4212 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
4213 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
4214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4215 }
4216 }
4217 }
4218 deserializer.deserialize_identifier(GeneratedVisitor)
4219 }
4220 }
4221 struct GeneratedVisitor;
4222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4223 type Value = event_log::EventRecovery;
4224
4225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4226 formatter.write_str("struct meta.EventLog.EventRecovery")
4227 }
4228
4229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
4230 where
4231 V: serde::de::MapAccess<'de>,
4232 {
4233 let mut recovery_event__ = None;
4234 while let Some(k) = map_.next_key()? {
4235 match k {
4236 GeneratedField::GlobalStart => {
4237 if recovery_event__.is_some() {
4238 return Err(serde::de::Error::duplicate_field("globalStart"));
4239 }
4240 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
4241;
4242 }
4243 GeneratedField::GlobalSuccess => {
4244 if recovery_event__.is_some() {
4245 return Err(serde::de::Error::duplicate_field("globalSuccess"));
4246 }
4247 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
4248;
4249 }
4250 GeneratedField::GlobalFailure => {
4251 if recovery_event__.is_some() {
4252 return Err(serde::de::Error::duplicate_field("globalFailure"));
4253 }
4254 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
4255;
4256 }
4257 GeneratedField::DatabaseStart => {
4258 if recovery_event__.is_some() {
4259 return Err(serde::de::Error::duplicate_field("databaseStart"));
4260 }
4261 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
4262;
4263 }
4264 GeneratedField::DatabaseFailure => {
4265 if recovery_event__.is_some() {
4266 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4267 }
4268 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4269;
4270 }
4271 GeneratedField::DatabaseSuccess => {
4272 if recovery_event__.is_some() {
4273 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4274 }
4275 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4276;
4277 }
4278 }
4279 }
4280 Ok(event_log::EventRecovery {
4281 recovery_event: recovery_event__,
4282 })
4283 }
4284 }
4285 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4286 }
4287}
4288impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4289 #[allow(deprecated)]
4290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4291 where
4292 S: serde::Serializer,
4293 {
4294 use serde::ser::SerializeStruct;
4295 let mut len = 0;
4296 if self.database_id != 0 {
4297 len += 1;
4298 }
4299 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4300 if self.database_id != 0 {
4301 struct_ser.serialize_field("databaseId", &self.database_id)?;
4302 }
4303 struct_ser.end()
4304 }
4305}
4306impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4307 #[allow(deprecated)]
4308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4309 where
4310 D: serde::Deserializer<'de>,
4311 {
4312 const FIELDS: &[&str] = &[
4313 "database_id",
4314 "databaseId",
4315 ];
4316
4317 #[allow(clippy::enum_variant_names)]
4318 enum GeneratedField {
4319 DatabaseId,
4320 }
4321 impl<'de> serde::Deserialize<'de> for GeneratedField {
4322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4323 where
4324 D: serde::Deserializer<'de>,
4325 {
4326 struct GeneratedVisitor;
4327
4328 impl serde::de::Visitor<'_> for GeneratedVisitor {
4329 type Value = GeneratedField;
4330
4331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4332 write!(formatter, "expected one of: {:?}", &FIELDS)
4333 }
4334
4335 #[allow(unused_variables)]
4336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4337 where
4338 E: serde::de::Error,
4339 {
4340 match value {
4341 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4343 }
4344 }
4345 }
4346 deserializer.deserialize_identifier(GeneratedVisitor)
4347 }
4348 }
4349 struct GeneratedVisitor;
4350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4351 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4352
4353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4354 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4355 }
4356
4357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4358 where
4359 V: serde::de::MapAccess<'de>,
4360 {
4361 let mut database_id__ = None;
4362 while let Some(k) = map_.next_key()? {
4363 match k {
4364 GeneratedField::DatabaseId => {
4365 if database_id__.is_some() {
4366 return Err(serde::de::Error::duplicate_field("databaseId"));
4367 }
4368 database_id__ =
4369 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4370 ;
4371 }
4372 }
4373 }
4374 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4375 database_id: database_id__.unwrap_or_default(),
4376 })
4377 }
4378 }
4379 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4380 }
4381}
4382impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4383 #[allow(deprecated)]
4384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4385 where
4386 S: serde::Serializer,
4387 {
4388 use serde::ser::SerializeStruct;
4389 let mut len = 0;
4390 if self.database_id != 0 {
4391 len += 1;
4392 }
4393 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4394 if self.database_id != 0 {
4395 struct_ser.serialize_field("databaseId", &self.database_id)?;
4396 }
4397 struct_ser.end()
4398 }
4399}
4400impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4401 #[allow(deprecated)]
4402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4403 where
4404 D: serde::Deserializer<'de>,
4405 {
4406 const FIELDS: &[&str] = &[
4407 "database_id",
4408 "databaseId",
4409 ];
4410
4411 #[allow(clippy::enum_variant_names)]
4412 enum GeneratedField {
4413 DatabaseId,
4414 }
4415 impl<'de> serde::Deserialize<'de> for GeneratedField {
4416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4417 where
4418 D: serde::Deserializer<'de>,
4419 {
4420 struct GeneratedVisitor;
4421
4422 impl serde::de::Visitor<'_> for GeneratedVisitor {
4423 type Value = GeneratedField;
4424
4425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4426 write!(formatter, "expected one of: {:?}", &FIELDS)
4427 }
4428
4429 #[allow(unused_variables)]
4430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4431 where
4432 E: serde::de::Error,
4433 {
4434 match value {
4435 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4437 }
4438 }
4439 }
4440 deserializer.deserialize_identifier(GeneratedVisitor)
4441 }
4442 }
4443 struct GeneratedVisitor;
4444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4445 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4446
4447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4448 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4449 }
4450
4451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4452 where
4453 V: serde::de::MapAccess<'de>,
4454 {
4455 let mut database_id__ = None;
4456 while let Some(k) = map_.next_key()? {
4457 match k {
4458 GeneratedField::DatabaseId => {
4459 if database_id__.is_some() {
4460 return Err(serde::de::Error::duplicate_field("databaseId"));
4461 }
4462 database_id__ =
4463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4464 ;
4465 }
4466 }
4467 }
4468 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4469 database_id: database_id__.unwrap_or_default(),
4470 })
4471 }
4472 }
4473 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4474 }
4475}
4476impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4477 #[allow(deprecated)]
4478 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4479 where
4480 S: serde::Serializer,
4481 {
4482 use serde::ser::SerializeStruct;
4483 let mut len = 0;
4484 if self.database_id != 0 {
4485 len += 1;
4486 }
4487 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4488 if self.database_id != 0 {
4489 struct_ser.serialize_field("databaseId", &self.database_id)?;
4490 }
4491 struct_ser.end()
4492 }
4493}
4494impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4495 #[allow(deprecated)]
4496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4497 where
4498 D: serde::Deserializer<'de>,
4499 {
4500 const FIELDS: &[&str] = &[
4501 "database_id",
4502 "databaseId",
4503 ];
4504
4505 #[allow(clippy::enum_variant_names)]
4506 enum GeneratedField {
4507 DatabaseId,
4508 }
4509 impl<'de> serde::Deserialize<'de> for GeneratedField {
4510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4511 where
4512 D: serde::Deserializer<'de>,
4513 {
4514 struct GeneratedVisitor;
4515
4516 impl serde::de::Visitor<'_> for GeneratedVisitor {
4517 type Value = GeneratedField;
4518
4519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4520 write!(formatter, "expected one of: {:?}", &FIELDS)
4521 }
4522
4523 #[allow(unused_variables)]
4524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4525 where
4526 E: serde::de::Error,
4527 {
4528 match value {
4529 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4531 }
4532 }
4533 }
4534 deserializer.deserialize_identifier(GeneratedVisitor)
4535 }
4536 }
4537 struct GeneratedVisitor;
4538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4539 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4540
4541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4542 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4543 }
4544
4545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4546 where
4547 V: serde::de::MapAccess<'de>,
4548 {
4549 let mut database_id__ = None;
4550 while let Some(k) = map_.next_key()? {
4551 match k {
4552 GeneratedField::DatabaseId => {
4553 if database_id__.is_some() {
4554 return Err(serde::de::Error::duplicate_field("databaseId"));
4555 }
4556 database_id__ =
4557 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4558 ;
4559 }
4560 }
4561 }
4562 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4563 database_id: database_id__.unwrap_or_default(),
4564 })
4565 }
4566 }
4567 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4568 }
4569}
4570impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4571 #[allow(deprecated)]
4572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4573 where
4574 S: serde::Serializer,
4575 {
4576 use serde::ser::SerializeStruct;
4577 let mut len = 0;
4578 if !self.reason.is_empty() {
4579 len += 1;
4580 }
4581 if !self.error.is_empty() {
4582 len += 1;
4583 }
4584 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4585 if !self.reason.is_empty() {
4586 struct_ser.serialize_field("reason", &self.reason)?;
4587 }
4588 if !self.error.is_empty() {
4589 struct_ser.serialize_field("error", &self.error)?;
4590 }
4591 struct_ser.end()
4592 }
4593}
4594impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4595 #[allow(deprecated)]
4596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4597 where
4598 D: serde::Deserializer<'de>,
4599 {
4600 const FIELDS: &[&str] = &[
4601 "reason",
4602 "error",
4603 ];
4604
4605 #[allow(clippy::enum_variant_names)]
4606 enum GeneratedField {
4607 Reason,
4608 Error,
4609 }
4610 impl<'de> serde::Deserialize<'de> for GeneratedField {
4611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4612 where
4613 D: serde::Deserializer<'de>,
4614 {
4615 struct GeneratedVisitor;
4616
4617 impl serde::de::Visitor<'_> for GeneratedVisitor {
4618 type Value = GeneratedField;
4619
4620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4621 write!(formatter, "expected one of: {:?}", &FIELDS)
4622 }
4623
4624 #[allow(unused_variables)]
4625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4626 where
4627 E: serde::de::Error,
4628 {
4629 match value {
4630 "reason" => Ok(GeneratedField::Reason),
4631 "error" => Ok(GeneratedField::Error),
4632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4633 }
4634 }
4635 }
4636 deserializer.deserialize_identifier(GeneratedVisitor)
4637 }
4638 }
4639 struct GeneratedVisitor;
4640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4641 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4642
4643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4644 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4645 }
4646
4647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4648 where
4649 V: serde::de::MapAccess<'de>,
4650 {
4651 let mut reason__ = None;
4652 let mut error__ = None;
4653 while let Some(k) = map_.next_key()? {
4654 match k {
4655 GeneratedField::Reason => {
4656 if reason__.is_some() {
4657 return Err(serde::de::Error::duplicate_field("reason"));
4658 }
4659 reason__ = Some(map_.next_value()?);
4660 }
4661 GeneratedField::Error => {
4662 if error__.is_some() {
4663 return Err(serde::de::Error::duplicate_field("error"));
4664 }
4665 error__ = Some(map_.next_value()?);
4666 }
4667 }
4668 }
4669 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4670 reason: reason__.unwrap_or_default(),
4671 error: error__.unwrap_or_default(),
4672 })
4673 }
4674 }
4675 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4676 }
4677}
4678impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4679 #[allow(deprecated)]
4680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4681 where
4682 S: serde::Serializer,
4683 {
4684 use serde::ser::SerializeStruct;
4685 let mut len = 0;
4686 if !self.reason.is_empty() {
4687 len += 1;
4688 }
4689 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4690 if !self.reason.is_empty() {
4691 struct_ser.serialize_field("reason", &self.reason)?;
4692 }
4693 struct_ser.end()
4694 }
4695}
4696impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4697 #[allow(deprecated)]
4698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4699 where
4700 D: serde::Deserializer<'de>,
4701 {
4702 const FIELDS: &[&str] = &[
4703 "reason",
4704 ];
4705
4706 #[allow(clippy::enum_variant_names)]
4707 enum GeneratedField {
4708 Reason,
4709 }
4710 impl<'de> serde::Deserialize<'de> for GeneratedField {
4711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4712 where
4713 D: serde::Deserializer<'de>,
4714 {
4715 struct GeneratedVisitor;
4716
4717 impl serde::de::Visitor<'_> for GeneratedVisitor {
4718 type Value = GeneratedField;
4719
4720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4721 write!(formatter, "expected one of: {:?}", &FIELDS)
4722 }
4723
4724 #[allow(unused_variables)]
4725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4726 where
4727 E: serde::de::Error,
4728 {
4729 match value {
4730 "reason" => Ok(GeneratedField::Reason),
4731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4732 }
4733 }
4734 }
4735 deserializer.deserialize_identifier(GeneratedVisitor)
4736 }
4737 }
4738 struct GeneratedVisitor;
4739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4740 type Value = event_log::event_recovery::GlobalRecoveryStart;
4741
4742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4743 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4744 }
4745
4746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4747 where
4748 V: serde::de::MapAccess<'de>,
4749 {
4750 let mut reason__ = None;
4751 while let Some(k) = map_.next_key()? {
4752 match k {
4753 GeneratedField::Reason => {
4754 if reason__.is_some() {
4755 return Err(serde::de::Error::duplicate_field("reason"));
4756 }
4757 reason__ = Some(map_.next_value()?);
4758 }
4759 }
4760 }
4761 Ok(event_log::event_recovery::GlobalRecoveryStart {
4762 reason: reason__.unwrap_or_default(),
4763 })
4764 }
4765 }
4766 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4767 }
4768}
4769impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4770 #[allow(deprecated)]
4771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4772 where
4773 S: serde::Serializer,
4774 {
4775 use serde::ser::SerializeStruct;
4776 let mut len = 0;
4777 if !self.reason.is_empty() {
4778 len += 1;
4779 }
4780 if self.duration_secs != 0. {
4781 len += 1;
4782 }
4783 if !self.running_database_ids.is_empty() {
4784 len += 1;
4785 }
4786 if !self.recovering_database_ids.is_empty() {
4787 len += 1;
4788 }
4789 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4790 if !self.reason.is_empty() {
4791 struct_ser.serialize_field("reason", &self.reason)?;
4792 }
4793 if self.duration_secs != 0. {
4794 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4795 }
4796 if !self.running_database_ids.is_empty() {
4797 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4798 }
4799 if !self.recovering_database_ids.is_empty() {
4800 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4801 }
4802 struct_ser.end()
4803 }
4804}
4805impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4806 #[allow(deprecated)]
4807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4808 where
4809 D: serde::Deserializer<'de>,
4810 {
4811 const FIELDS: &[&str] = &[
4812 "reason",
4813 "duration_secs",
4814 "durationSecs",
4815 "running_database_ids",
4816 "runningDatabaseIds",
4817 "recovering_database_ids",
4818 "recoveringDatabaseIds",
4819 ];
4820
4821 #[allow(clippy::enum_variant_names)]
4822 enum GeneratedField {
4823 Reason,
4824 DurationSecs,
4825 RunningDatabaseIds,
4826 RecoveringDatabaseIds,
4827 }
4828 impl<'de> serde::Deserialize<'de> for GeneratedField {
4829 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4830 where
4831 D: serde::Deserializer<'de>,
4832 {
4833 struct GeneratedVisitor;
4834
4835 impl serde::de::Visitor<'_> for GeneratedVisitor {
4836 type Value = GeneratedField;
4837
4838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4839 write!(formatter, "expected one of: {:?}", &FIELDS)
4840 }
4841
4842 #[allow(unused_variables)]
4843 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4844 where
4845 E: serde::de::Error,
4846 {
4847 match value {
4848 "reason" => Ok(GeneratedField::Reason),
4849 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4850 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4851 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4852 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4853 }
4854 }
4855 }
4856 deserializer.deserialize_identifier(GeneratedVisitor)
4857 }
4858 }
4859 struct GeneratedVisitor;
4860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4861 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4862
4863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4864 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4865 }
4866
4867 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4868 where
4869 V: serde::de::MapAccess<'de>,
4870 {
4871 let mut reason__ = None;
4872 let mut duration_secs__ = None;
4873 let mut running_database_ids__ = None;
4874 let mut recovering_database_ids__ = None;
4875 while let Some(k) = map_.next_key()? {
4876 match k {
4877 GeneratedField::Reason => {
4878 if reason__.is_some() {
4879 return Err(serde::de::Error::duplicate_field("reason"));
4880 }
4881 reason__ = Some(map_.next_value()?);
4882 }
4883 GeneratedField::DurationSecs => {
4884 if duration_secs__.is_some() {
4885 return Err(serde::de::Error::duplicate_field("durationSecs"));
4886 }
4887 duration_secs__ =
4888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4889 ;
4890 }
4891 GeneratedField::RunningDatabaseIds => {
4892 if running_database_ids__.is_some() {
4893 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4894 }
4895 running_database_ids__ =
4896 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4897 .into_iter().map(|x| x.0).collect())
4898 ;
4899 }
4900 GeneratedField::RecoveringDatabaseIds => {
4901 if recovering_database_ids__.is_some() {
4902 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4903 }
4904 recovering_database_ids__ =
4905 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4906 .into_iter().map(|x| x.0).collect())
4907 ;
4908 }
4909 }
4910 }
4911 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4912 reason: reason__.unwrap_or_default(),
4913 duration_secs: duration_secs__.unwrap_or_default(),
4914 running_database_ids: running_database_ids__.unwrap_or_default(),
4915 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4916 })
4917 }
4918 }
4919 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4920 }
4921}
4922impl serde::Serialize for event_log::EventSinkFail {
4923 #[allow(deprecated)]
4924 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4925 where
4926 S: serde::Serializer,
4927 {
4928 use serde::ser::SerializeStruct;
4929 let mut len = 0;
4930 if self.sink_id != 0 {
4931 len += 1;
4932 }
4933 if !self.sink_name.is_empty() {
4934 len += 1;
4935 }
4936 if !self.connector.is_empty() {
4937 len += 1;
4938 }
4939 if !self.error.is_empty() {
4940 len += 1;
4941 }
4942 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4943 if self.sink_id != 0 {
4944 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4945 }
4946 if !self.sink_name.is_empty() {
4947 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4948 }
4949 if !self.connector.is_empty() {
4950 struct_ser.serialize_field("connector", &self.connector)?;
4951 }
4952 if !self.error.is_empty() {
4953 struct_ser.serialize_field("error", &self.error)?;
4954 }
4955 struct_ser.end()
4956 }
4957}
4958impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4959 #[allow(deprecated)]
4960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4961 where
4962 D: serde::Deserializer<'de>,
4963 {
4964 const FIELDS: &[&str] = &[
4965 "sink_id",
4966 "sinkId",
4967 "sink_name",
4968 "sinkName",
4969 "connector",
4970 "error",
4971 ];
4972
4973 #[allow(clippy::enum_variant_names)]
4974 enum GeneratedField {
4975 SinkId,
4976 SinkName,
4977 Connector,
4978 Error,
4979 }
4980 impl<'de> serde::Deserialize<'de> for GeneratedField {
4981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4982 where
4983 D: serde::Deserializer<'de>,
4984 {
4985 struct GeneratedVisitor;
4986
4987 impl serde::de::Visitor<'_> for GeneratedVisitor {
4988 type Value = GeneratedField;
4989
4990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4991 write!(formatter, "expected one of: {:?}", &FIELDS)
4992 }
4993
4994 #[allow(unused_variables)]
4995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4996 where
4997 E: serde::de::Error,
4998 {
4999 match value {
5000 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
5001 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
5002 "connector" => Ok(GeneratedField::Connector),
5003 "error" => Ok(GeneratedField::Error),
5004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5005 }
5006 }
5007 }
5008 deserializer.deserialize_identifier(GeneratedVisitor)
5009 }
5010 }
5011 struct GeneratedVisitor;
5012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5013 type Value = event_log::EventSinkFail;
5014
5015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5016 formatter.write_str("struct meta.EventLog.EventSinkFail")
5017 }
5018
5019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
5020 where
5021 V: serde::de::MapAccess<'de>,
5022 {
5023 let mut sink_id__ = None;
5024 let mut sink_name__ = None;
5025 let mut connector__ = None;
5026 let mut error__ = None;
5027 while let Some(k) = map_.next_key()? {
5028 match k {
5029 GeneratedField::SinkId => {
5030 if sink_id__.is_some() {
5031 return Err(serde::de::Error::duplicate_field("sinkId"));
5032 }
5033 sink_id__ =
5034 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5035 ;
5036 }
5037 GeneratedField::SinkName => {
5038 if sink_name__.is_some() {
5039 return Err(serde::de::Error::duplicate_field("sinkName"));
5040 }
5041 sink_name__ = Some(map_.next_value()?);
5042 }
5043 GeneratedField::Connector => {
5044 if connector__.is_some() {
5045 return Err(serde::de::Error::duplicate_field("connector"));
5046 }
5047 connector__ = Some(map_.next_value()?);
5048 }
5049 GeneratedField::Error => {
5050 if error__.is_some() {
5051 return Err(serde::de::Error::duplicate_field("error"));
5052 }
5053 error__ = Some(map_.next_value()?);
5054 }
5055 }
5056 }
5057 Ok(event_log::EventSinkFail {
5058 sink_id: sink_id__.unwrap_or_default(),
5059 sink_name: sink_name__.unwrap_or_default(),
5060 connector: connector__.unwrap_or_default(),
5061 error: error__.unwrap_or_default(),
5062 })
5063 }
5064 }
5065 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
5066 }
5067}
5068impl serde::Serialize for event_log::EventWorkerNodePanic {
5069 #[allow(deprecated)]
5070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5071 where
5072 S: serde::Serializer,
5073 {
5074 use serde::ser::SerializeStruct;
5075 let mut len = 0;
5076 if self.worker_id != 0 {
5077 len += 1;
5078 }
5079 if self.worker_type != 0 {
5080 len += 1;
5081 }
5082 if self.host_addr.is_some() {
5083 len += 1;
5084 }
5085 if !self.panic_info.is_empty() {
5086 len += 1;
5087 }
5088 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
5089 if self.worker_id != 0 {
5090 struct_ser.serialize_field("workerId", &self.worker_id)?;
5091 }
5092 if self.worker_type != 0 {
5093 let v = super::common::WorkerType::try_from(self.worker_type)
5094 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
5095 struct_ser.serialize_field("workerType", &v)?;
5096 }
5097 if let Some(v) = self.host_addr.as_ref() {
5098 struct_ser.serialize_field("hostAddr", v)?;
5099 }
5100 if !self.panic_info.is_empty() {
5101 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
5102 }
5103 struct_ser.end()
5104 }
5105}
5106impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
5107 #[allow(deprecated)]
5108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5109 where
5110 D: serde::Deserializer<'de>,
5111 {
5112 const FIELDS: &[&str] = &[
5113 "worker_id",
5114 "workerId",
5115 "worker_type",
5116 "workerType",
5117 "host_addr",
5118 "hostAddr",
5119 "panic_info",
5120 "panicInfo",
5121 ];
5122
5123 #[allow(clippy::enum_variant_names)]
5124 enum GeneratedField {
5125 WorkerId,
5126 WorkerType,
5127 HostAddr,
5128 PanicInfo,
5129 }
5130 impl<'de> serde::Deserialize<'de> for GeneratedField {
5131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5132 where
5133 D: serde::Deserializer<'de>,
5134 {
5135 struct GeneratedVisitor;
5136
5137 impl serde::de::Visitor<'_> for GeneratedVisitor {
5138 type Value = GeneratedField;
5139
5140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5141 write!(formatter, "expected one of: {:?}", &FIELDS)
5142 }
5143
5144 #[allow(unused_variables)]
5145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5146 where
5147 E: serde::de::Error,
5148 {
5149 match value {
5150 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
5151 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
5152 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
5153 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
5154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5155 }
5156 }
5157 }
5158 deserializer.deserialize_identifier(GeneratedVisitor)
5159 }
5160 }
5161 struct GeneratedVisitor;
5162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5163 type Value = event_log::EventWorkerNodePanic;
5164
5165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5166 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
5167 }
5168
5169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
5170 where
5171 V: serde::de::MapAccess<'de>,
5172 {
5173 let mut worker_id__ = None;
5174 let mut worker_type__ = None;
5175 let mut host_addr__ = None;
5176 let mut panic_info__ = None;
5177 while let Some(k) = map_.next_key()? {
5178 match k {
5179 GeneratedField::WorkerId => {
5180 if worker_id__.is_some() {
5181 return Err(serde::de::Error::duplicate_field("workerId"));
5182 }
5183 worker_id__ =
5184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5185 ;
5186 }
5187 GeneratedField::WorkerType => {
5188 if worker_type__.is_some() {
5189 return Err(serde::de::Error::duplicate_field("workerType"));
5190 }
5191 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
5192 }
5193 GeneratedField::HostAddr => {
5194 if host_addr__.is_some() {
5195 return Err(serde::de::Error::duplicate_field("hostAddr"));
5196 }
5197 host_addr__ = map_.next_value()?;
5198 }
5199 GeneratedField::PanicInfo => {
5200 if panic_info__.is_some() {
5201 return Err(serde::de::Error::duplicate_field("panicInfo"));
5202 }
5203 panic_info__ = Some(map_.next_value()?);
5204 }
5205 }
5206 }
5207 Ok(event_log::EventWorkerNodePanic {
5208 worker_id: worker_id__.unwrap_or_default(),
5209 worker_type: worker_type__.unwrap_or_default(),
5210 host_addr: host_addr__,
5211 panic_info: panic_info__.unwrap_or_default(),
5212 })
5213 }
5214 }
5215 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
5216 }
5217}
5218impl serde::Serialize for FlushRequest {
5219 #[allow(deprecated)]
5220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5221 where
5222 S: serde::Serializer,
5223 {
5224 use serde::ser::SerializeStruct;
5225 let mut len = 0;
5226 if self.database_id != 0 {
5227 len += 1;
5228 }
5229 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
5230 if self.database_id != 0 {
5231 struct_ser.serialize_field("databaseId", &self.database_id)?;
5232 }
5233 struct_ser.end()
5234 }
5235}
5236impl<'de> serde::Deserialize<'de> for FlushRequest {
5237 #[allow(deprecated)]
5238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5239 where
5240 D: serde::Deserializer<'de>,
5241 {
5242 const FIELDS: &[&str] = &[
5243 "database_id",
5244 "databaseId",
5245 ];
5246
5247 #[allow(clippy::enum_variant_names)]
5248 enum GeneratedField {
5249 DatabaseId,
5250 }
5251 impl<'de> serde::Deserialize<'de> for GeneratedField {
5252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5253 where
5254 D: serde::Deserializer<'de>,
5255 {
5256 struct GeneratedVisitor;
5257
5258 impl serde::de::Visitor<'_> for GeneratedVisitor {
5259 type Value = GeneratedField;
5260
5261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5262 write!(formatter, "expected one of: {:?}", &FIELDS)
5263 }
5264
5265 #[allow(unused_variables)]
5266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5267 where
5268 E: serde::de::Error,
5269 {
5270 match value {
5271 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5272 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5273 }
5274 }
5275 }
5276 deserializer.deserialize_identifier(GeneratedVisitor)
5277 }
5278 }
5279 struct GeneratedVisitor;
5280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5281 type Value = FlushRequest;
5282
5283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5284 formatter.write_str("struct meta.FlushRequest")
5285 }
5286
5287 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5288 where
5289 V: serde::de::MapAccess<'de>,
5290 {
5291 let mut database_id__ = None;
5292 while let Some(k) = map_.next_key()? {
5293 match k {
5294 GeneratedField::DatabaseId => {
5295 if database_id__.is_some() {
5296 return Err(serde::de::Error::duplicate_field("databaseId"));
5297 }
5298 database_id__ =
5299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5300 ;
5301 }
5302 }
5303 }
5304 Ok(FlushRequest {
5305 database_id: database_id__.unwrap_or_default(),
5306 })
5307 }
5308 }
5309 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5310 }
5311}
5312impl serde::Serialize for FlushResponse {
5313 #[allow(deprecated)]
5314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5315 where
5316 S: serde::Serializer,
5317 {
5318 use serde::ser::SerializeStruct;
5319 let mut len = 0;
5320 if self.status.is_some() {
5321 len += 1;
5322 }
5323 if self.hummock_version_id != 0 {
5324 len += 1;
5325 }
5326 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5327 if let Some(v) = self.status.as_ref() {
5328 struct_ser.serialize_field("status", v)?;
5329 }
5330 if self.hummock_version_id != 0 {
5331 #[allow(clippy::needless_borrow)]
5332 #[allow(clippy::needless_borrows_for_generic_args)]
5333 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5334 }
5335 struct_ser.end()
5336 }
5337}
5338impl<'de> serde::Deserialize<'de> for FlushResponse {
5339 #[allow(deprecated)]
5340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5341 where
5342 D: serde::Deserializer<'de>,
5343 {
5344 const FIELDS: &[&str] = &[
5345 "status",
5346 "hummock_version_id",
5347 "hummockVersionId",
5348 ];
5349
5350 #[allow(clippy::enum_variant_names)]
5351 enum GeneratedField {
5352 Status,
5353 HummockVersionId,
5354 }
5355 impl<'de> serde::Deserialize<'de> for GeneratedField {
5356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5357 where
5358 D: serde::Deserializer<'de>,
5359 {
5360 struct GeneratedVisitor;
5361
5362 impl serde::de::Visitor<'_> for GeneratedVisitor {
5363 type Value = GeneratedField;
5364
5365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5366 write!(formatter, "expected one of: {:?}", &FIELDS)
5367 }
5368
5369 #[allow(unused_variables)]
5370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5371 where
5372 E: serde::de::Error,
5373 {
5374 match value {
5375 "status" => Ok(GeneratedField::Status),
5376 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5377 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5378 }
5379 }
5380 }
5381 deserializer.deserialize_identifier(GeneratedVisitor)
5382 }
5383 }
5384 struct GeneratedVisitor;
5385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5386 type Value = FlushResponse;
5387
5388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5389 formatter.write_str("struct meta.FlushResponse")
5390 }
5391
5392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5393 where
5394 V: serde::de::MapAccess<'de>,
5395 {
5396 let mut status__ = None;
5397 let mut hummock_version_id__ = None;
5398 while let Some(k) = map_.next_key()? {
5399 match k {
5400 GeneratedField::Status => {
5401 if status__.is_some() {
5402 return Err(serde::de::Error::duplicate_field("status"));
5403 }
5404 status__ = map_.next_value()?;
5405 }
5406 GeneratedField::HummockVersionId => {
5407 if hummock_version_id__.is_some() {
5408 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5409 }
5410 hummock_version_id__ =
5411 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5412 ;
5413 }
5414 }
5415 }
5416 Ok(FlushResponse {
5417 status: status__,
5418 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5419 })
5420 }
5421 }
5422 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5423 }
5424}
5425impl serde::Serialize for FragmentDistribution {
5426 #[allow(deprecated)]
5427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5428 where
5429 S: serde::Serializer,
5430 {
5431 use serde::ser::SerializeStruct;
5432 let mut len = 0;
5433 if self.fragment_id != 0 {
5434 len += 1;
5435 }
5436 if self.table_id != 0 {
5437 len += 1;
5438 }
5439 if self.distribution_type != 0 {
5440 len += 1;
5441 }
5442 if !self.state_table_ids.is_empty() {
5443 len += 1;
5444 }
5445 if !self.upstream_fragment_ids.is_empty() {
5446 len += 1;
5447 }
5448 if self.fragment_type_mask != 0 {
5449 len += 1;
5450 }
5451 if self.parallelism != 0 {
5452 len += 1;
5453 }
5454 if self.vnode_count != 0 {
5455 len += 1;
5456 }
5457 if self.node.is_some() {
5458 len += 1;
5459 }
5460 if !self.parallelism_policy.is_empty() {
5461 len += 1;
5462 }
5463 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5464 if self.fragment_id != 0 {
5465 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5466 }
5467 if self.table_id != 0 {
5468 struct_ser.serialize_field("tableId", &self.table_id)?;
5469 }
5470 if self.distribution_type != 0 {
5471 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5472 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5473 struct_ser.serialize_field("distributionType", &v)?;
5474 }
5475 if !self.state_table_ids.is_empty() {
5476 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5477 }
5478 if !self.upstream_fragment_ids.is_empty() {
5479 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5480 }
5481 if self.fragment_type_mask != 0 {
5482 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5483 }
5484 if self.parallelism != 0 {
5485 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5486 }
5487 if self.vnode_count != 0 {
5488 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5489 }
5490 if let Some(v) = self.node.as_ref() {
5491 struct_ser.serialize_field("node", v)?;
5492 }
5493 if !self.parallelism_policy.is_empty() {
5494 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5495 }
5496 struct_ser.end()
5497 }
5498}
5499impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5500 #[allow(deprecated)]
5501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5502 where
5503 D: serde::Deserializer<'de>,
5504 {
5505 const FIELDS: &[&str] = &[
5506 "fragment_id",
5507 "fragmentId",
5508 "table_id",
5509 "tableId",
5510 "distribution_type",
5511 "distributionType",
5512 "state_table_ids",
5513 "stateTableIds",
5514 "upstream_fragment_ids",
5515 "upstreamFragmentIds",
5516 "fragment_type_mask",
5517 "fragmentTypeMask",
5518 "parallelism",
5519 "vnode_count",
5520 "vnodeCount",
5521 "node",
5522 "parallelism_policy",
5523 "parallelismPolicy",
5524 ];
5525
5526 #[allow(clippy::enum_variant_names)]
5527 enum GeneratedField {
5528 FragmentId,
5529 TableId,
5530 DistributionType,
5531 StateTableIds,
5532 UpstreamFragmentIds,
5533 FragmentTypeMask,
5534 Parallelism,
5535 VnodeCount,
5536 Node,
5537 ParallelismPolicy,
5538 }
5539 impl<'de> serde::Deserialize<'de> for GeneratedField {
5540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5541 where
5542 D: serde::Deserializer<'de>,
5543 {
5544 struct GeneratedVisitor;
5545
5546 impl serde::de::Visitor<'_> for GeneratedVisitor {
5547 type Value = GeneratedField;
5548
5549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5550 write!(formatter, "expected one of: {:?}", &FIELDS)
5551 }
5552
5553 #[allow(unused_variables)]
5554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5555 where
5556 E: serde::de::Error,
5557 {
5558 match value {
5559 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5560 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5561 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5562 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5563 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5564 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5565 "parallelism" => Ok(GeneratedField::Parallelism),
5566 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5567 "node" => Ok(GeneratedField::Node),
5568 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5570 }
5571 }
5572 }
5573 deserializer.deserialize_identifier(GeneratedVisitor)
5574 }
5575 }
5576 struct GeneratedVisitor;
5577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5578 type Value = FragmentDistribution;
5579
5580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5581 formatter.write_str("struct meta.FragmentDistribution")
5582 }
5583
5584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5585 where
5586 V: serde::de::MapAccess<'de>,
5587 {
5588 let mut fragment_id__ = None;
5589 let mut table_id__ = None;
5590 let mut distribution_type__ = None;
5591 let mut state_table_ids__ = None;
5592 let mut upstream_fragment_ids__ = None;
5593 let mut fragment_type_mask__ = None;
5594 let mut parallelism__ = None;
5595 let mut vnode_count__ = None;
5596 let mut node__ = None;
5597 let mut parallelism_policy__ = None;
5598 while let Some(k) = map_.next_key()? {
5599 match k {
5600 GeneratedField::FragmentId => {
5601 if fragment_id__.is_some() {
5602 return Err(serde::de::Error::duplicate_field("fragmentId"));
5603 }
5604 fragment_id__ =
5605 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5606 ;
5607 }
5608 GeneratedField::TableId => {
5609 if table_id__.is_some() {
5610 return Err(serde::de::Error::duplicate_field("tableId"));
5611 }
5612 table_id__ =
5613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5614 ;
5615 }
5616 GeneratedField::DistributionType => {
5617 if distribution_type__.is_some() {
5618 return Err(serde::de::Error::duplicate_field("distributionType"));
5619 }
5620 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5621 }
5622 GeneratedField::StateTableIds => {
5623 if state_table_ids__.is_some() {
5624 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5625 }
5626 state_table_ids__ =
5627 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5628 .into_iter().map(|x| x.0).collect())
5629 ;
5630 }
5631 GeneratedField::UpstreamFragmentIds => {
5632 if upstream_fragment_ids__.is_some() {
5633 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5634 }
5635 upstream_fragment_ids__ =
5636 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5637 .into_iter().map(|x| x.0).collect())
5638 ;
5639 }
5640 GeneratedField::FragmentTypeMask => {
5641 if fragment_type_mask__.is_some() {
5642 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5643 }
5644 fragment_type_mask__ =
5645 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5646 ;
5647 }
5648 GeneratedField::Parallelism => {
5649 if parallelism__.is_some() {
5650 return Err(serde::de::Error::duplicate_field("parallelism"));
5651 }
5652 parallelism__ =
5653 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5654 ;
5655 }
5656 GeneratedField::VnodeCount => {
5657 if vnode_count__.is_some() {
5658 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5659 }
5660 vnode_count__ =
5661 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5662 ;
5663 }
5664 GeneratedField::Node => {
5665 if node__.is_some() {
5666 return Err(serde::de::Error::duplicate_field("node"));
5667 }
5668 node__ = map_.next_value()?;
5669 }
5670 GeneratedField::ParallelismPolicy => {
5671 if parallelism_policy__.is_some() {
5672 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5673 }
5674 parallelism_policy__ = Some(map_.next_value()?);
5675 }
5676 }
5677 }
5678 Ok(FragmentDistribution {
5679 fragment_id: fragment_id__.unwrap_or_default(),
5680 table_id: table_id__.unwrap_or_default(),
5681 distribution_type: distribution_type__.unwrap_or_default(),
5682 state_table_ids: state_table_ids__.unwrap_or_default(),
5683 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5684 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5685 parallelism: parallelism__.unwrap_or_default(),
5686 vnode_count: vnode_count__.unwrap_or_default(),
5687 node: node__,
5688 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5689 })
5690 }
5691 }
5692 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5693 }
5694}
5695impl serde::Serialize for FragmentIdToActorIdMap {
5696 #[allow(deprecated)]
5697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5698 where
5699 S: serde::Serializer,
5700 {
5701 use serde::ser::SerializeStruct;
5702 let mut len = 0;
5703 if !self.map.is_empty() {
5704 len += 1;
5705 }
5706 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5707 if !self.map.is_empty() {
5708 struct_ser.serialize_field("map", &self.map)?;
5709 }
5710 struct_ser.end()
5711 }
5712}
5713impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5714 #[allow(deprecated)]
5715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5716 where
5717 D: serde::Deserializer<'de>,
5718 {
5719 const FIELDS: &[&str] = &[
5720 "map",
5721 ];
5722
5723 #[allow(clippy::enum_variant_names)]
5724 enum GeneratedField {
5725 Map,
5726 }
5727 impl<'de> serde::Deserialize<'de> for GeneratedField {
5728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5729 where
5730 D: serde::Deserializer<'de>,
5731 {
5732 struct GeneratedVisitor;
5733
5734 impl serde::de::Visitor<'_> for GeneratedVisitor {
5735 type Value = GeneratedField;
5736
5737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5738 write!(formatter, "expected one of: {:?}", &FIELDS)
5739 }
5740
5741 #[allow(unused_variables)]
5742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5743 where
5744 E: serde::de::Error,
5745 {
5746 match value {
5747 "map" => Ok(GeneratedField::Map),
5748 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5749 }
5750 }
5751 }
5752 deserializer.deserialize_identifier(GeneratedVisitor)
5753 }
5754 }
5755 struct GeneratedVisitor;
5756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5757 type Value = FragmentIdToActorIdMap;
5758
5759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5760 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5761 }
5762
5763 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5764 where
5765 V: serde::de::MapAccess<'de>,
5766 {
5767 let mut map__ = None;
5768 while let Some(k) = map_.next_key()? {
5769 match k {
5770 GeneratedField::Map => {
5771 if map__.is_some() {
5772 return Err(serde::de::Error::duplicate_field("map"));
5773 }
5774 map__ = Some(
5775 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5776 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5777 );
5778 }
5779 }
5780 }
5781 Ok(FragmentIdToActorIdMap {
5782 map: map__.unwrap_or_default(),
5783 })
5784 }
5785 }
5786 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5787 }
5788}
5789impl serde::Serialize for FragmentToRelationMap {
5790 #[allow(deprecated)]
5791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5792 where
5793 S: serde::Serializer,
5794 {
5795 use serde::ser::SerializeStruct;
5796 let mut len = 0;
5797 if !self.fragment_to_relation_map.is_empty() {
5798 len += 1;
5799 }
5800 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5801 if !self.fragment_to_relation_map.is_empty() {
5802 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5803 }
5804 struct_ser.end()
5805 }
5806}
5807impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5808 #[allow(deprecated)]
5809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5810 where
5811 D: serde::Deserializer<'de>,
5812 {
5813 const FIELDS: &[&str] = &[
5814 "fragment_to_relation_map",
5815 "fragmentToRelationMap",
5816 ];
5817
5818 #[allow(clippy::enum_variant_names)]
5819 enum GeneratedField {
5820 FragmentToRelationMap,
5821 }
5822 impl<'de> serde::Deserialize<'de> for GeneratedField {
5823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5824 where
5825 D: serde::Deserializer<'de>,
5826 {
5827 struct GeneratedVisitor;
5828
5829 impl serde::de::Visitor<'_> for GeneratedVisitor {
5830 type Value = GeneratedField;
5831
5832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5833 write!(formatter, "expected one of: {:?}", &FIELDS)
5834 }
5835
5836 #[allow(unused_variables)]
5837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5838 where
5839 E: serde::de::Error,
5840 {
5841 match value {
5842 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5844 }
5845 }
5846 }
5847 deserializer.deserialize_identifier(GeneratedVisitor)
5848 }
5849 }
5850 struct GeneratedVisitor;
5851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5852 type Value = FragmentToRelationMap;
5853
5854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5855 formatter.write_str("struct meta.FragmentToRelationMap")
5856 }
5857
5858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5859 where
5860 V: serde::de::MapAccess<'de>,
5861 {
5862 let mut fragment_to_relation_map__ = None;
5863 while let Some(k) = map_.next_key()? {
5864 match k {
5865 GeneratedField::FragmentToRelationMap => {
5866 if fragment_to_relation_map__.is_some() {
5867 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5868 }
5869 fragment_to_relation_map__ = Some(
5870 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5871 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
5872 );
5873 }
5874 }
5875 }
5876 Ok(FragmentToRelationMap {
5877 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5878 })
5879 }
5880 }
5881 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5882 }
5883}
5884impl serde::Serialize for FragmentWorkerSlotMapping {
5885 #[allow(deprecated)]
5886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5887 where
5888 S: serde::Serializer,
5889 {
5890 use serde::ser::SerializeStruct;
5891 let mut len = 0;
5892 if self.fragment_id != 0 {
5893 len += 1;
5894 }
5895 if self.mapping.is_some() {
5896 len += 1;
5897 }
5898 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5899 if self.fragment_id != 0 {
5900 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5901 }
5902 if let Some(v) = self.mapping.as_ref() {
5903 struct_ser.serialize_field("mapping", v)?;
5904 }
5905 struct_ser.end()
5906 }
5907}
5908impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5909 #[allow(deprecated)]
5910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5911 where
5912 D: serde::Deserializer<'de>,
5913 {
5914 const FIELDS: &[&str] = &[
5915 "fragment_id",
5916 "fragmentId",
5917 "mapping",
5918 ];
5919
5920 #[allow(clippy::enum_variant_names)]
5921 enum GeneratedField {
5922 FragmentId,
5923 Mapping,
5924 }
5925 impl<'de> serde::Deserialize<'de> for GeneratedField {
5926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5927 where
5928 D: serde::Deserializer<'de>,
5929 {
5930 struct GeneratedVisitor;
5931
5932 impl serde::de::Visitor<'_> for GeneratedVisitor {
5933 type Value = GeneratedField;
5934
5935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5936 write!(formatter, "expected one of: {:?}", &FIELDS)
5937 }
5938
5939 #[allow(unused_variables)]
5940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5941 where
5942 E: serde::de::Error,
5943 {
5944 match value {
5945 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5946 "mapping" => Ok(GeneratedField::Mapping),
5947 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5948 }
5949 }
5950 }
5951 deserializer.deserialize_identifier(GeneratedVisitor)
5952 }
5953 }
5954 struct GeneratedVisitor;
5955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5956 type Value = FragmentWorkerSlotMapping;
5957
5958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5959 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5960 }
5961
5962 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5963 where
5964 V: serde::de::MapAccess<'de>,
5965 {
5966 let mut fragment_id__ = None;
5967 let mut mapping__ = None;
5968 while let Some(k) = map_.next_key()? {
5969 match k {
5970 GeneratedField::FragmentId => {
5971 if fragment_id__.is_some() {
5972 return Err(serde::de::Error::duplicate_field("fragmentId"));
5973 }
5974 fragment_id__ =
5975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5976 ;
5977 }
5978 GeneratedField::Mapping => {
5979 if mapping__.is_some() {
5980 return Err(serde::de::Error::duplicate_field("mapping"));
5981 }
5982 mapping__ = map_.next_value()?;
5983 }
5984 }
5985 }
5986 Ok(FragmentWorkerSlotMapping {
5987 fragment_id: fragment_id__.unwrap_or_default(),
5988 mapping: mapping__,
5989 })
5990 }
5991 }
5992 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5993 }
5994}
5995impl serde::Serialize for FragmentWorkerSlotMappings {
5996 #[allow(deprecated)]
5997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5998 where
5999 S: serde::Serializer,
6000 {
6001 use serde::ser::SerializeStruct;
6002 let mut len = 0;
6003 if !self.mappings.is_empty() {
6004 len += 1;
6005 }
6006 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
6007 if !self.mappings.is_empty() {
6008 struct_ser.serialize_field("mappings", &self.mappings)?;
6009 }
6010 struct_ser.end()
6011 }
6012}
6013impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
6014 #[allow(deprecated)]
6015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6016 where
6017 D: serde::Deserializer<'de>,
6018 {
6019 const FIELDS: &[&str] = &[
6020 "mappings",
6021 ];
6022
6023 #[allow(clippy::enum_variant_names)]
6024 enum GeneratedField {
6025 Mappings,
6026 }
6027 impl<'de> serde::Deserialize<'de> for GeneratedField {
6028 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6029 where
6030 D: serde::Deserializer<'de>,
6031 {
6032 struct GeneratedVisitor;
6033
6034 impl serde::de::Visitor<'_> for GeneratedVisitor {
6035 type Value = GeneratedField;
6036
6037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6038 write!(formatter, "expected one of: {:?}", &FIELDS)
6039 }
6040
6041 #[allow(unused_variables)]
6042 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6043 where
6044 E: serde::de::Error,
6045 {
6046 match value {
6047 "mappings" => Ok(GeneratedField::Mappings),
6048 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6049 }
6050 }
6051 }
6052 deserializer.deserialize_identifier(GeneratedVisitor)
6053 }
6054 }
6055 struct GeneratedVisitor;
6056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6057 type Value = FragmentWorkerSlotMappings;
6058
6059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6060 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
6061 }
6062
6063 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
6064 where
6065 V: serde::de::MapAccess<'de>,
6066 {
6067 let mut mappings__ = None;
6068 while let Some(k) = map_.next_key()? {
6069 match k {
6070 GeneratedField::Mappings => {
6071 if mappings__.is_some() {
6072 return Err(serde::de::Error::duplicate_field("mappings"));
6073 }
6074 mappings__ = Some(map_.next_value()?);
6075 }
6076 }
6077 }
6078 Ok(FragmentWorkerSlotMappings {
6079 mappings: mappings__.unwrap_or_default(),
6080 })
6081 }
6082 }
6083 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
6084 }
6085}
6086impl serde::Serialize for GetActorVnodesRequest {
6087 #[allow(deprecated)]
6088 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6089 where
6090 S: serde::Serializer,
6091 {
6092 use serde::ser::SerializeStruct;
6093 let mut len = 0;
6094 if self.actor_id != 0 {
6095 len += 1;
6096 }
6097 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
6098 if self.actor_id != 0 {
6099 struct_ser.serialize_field("actorId", &self.actor_id)?;
6100 }
6101 struct_ser.end()
6102 }
6103}
6104impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
6105 #[allow(deprecated)]
6106 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6107 where
6108 D: serde::Deserializer<'de>,
6109 {
6110 const FIELDS: &[&str] = &[
6111 "actor_id",
6112 "actorId",
6113 ];
6114
6115 #[allow(clippy::enum_variant_names)]
6116 enum GeneratedField {
6117 ActorId,
6118 }
6119 impl<'de> serde::Deserialize<'de> for GeneratedField {
6120 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6121 where
6122 D: serde::Deserializer<'de>,
6123 {
6124 struct GeneratedVisitor;
6125
6126 impl serde::de::Visitor<'_> for GeneratedVisitor {
6127 type Value = GeneratedField;
6128
6129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6130 write!(formatter, "expected one of: {:?}", &FIELDS)
6131 }
6132
6133 #[allow(unused_variables)]
6134 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6135 where
6136 E: serde::de::Error,
6137 {
6138 match value {
6139 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
6140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6141 }
6142 }
6143 }
6144 deserializer.deserialize_identifier(GeneratedVisitor)
6145 }
6146 }
6147 struct GeneratedVisitor;
6148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6149 type Value = GetActorVnodesRequest;
6150
6151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6152 formatter.write_str("struct meta.GetActorVnodesRequest")
6153 }
6154
6155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
6156 where
6157 V: serde::de::MapAccess<'de>,
6158 {
6159 let mut actor_id__ = None;
6160 while let Some(k) = map_.next_key()? {
6161 match k {
6162 GeneratedField::ActorId => {
6163 if actor_id__.is_some() {
6164 return Err(serde::de::Error::duplicate_field("actorId"));
6165 }
6166 actor_id__ =
6167 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6168 ;
6169 }
6170 }
6171 }
6172 Ok(GetActorVnodesRequest {
6173 actor_id: actor_id__.unwrap_or_default(),
6174 })
6175 }
6176 }
6177 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
6178 }
6179}
6180impl serde::Serialize for GetActorVnodesResponse {
6181 #[allow(deprecated)]
6182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6183 where
6184 S: serde::Serializer,
6185 {
6186 use serde::ser::SerializeStruct;
6187 let mut len = 0;
6188 if !self.vnode_indices.is_empty() {
6189 len += 1;
6190 }
6191 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
6192 if !self.vnode_indices.is_empty() {
6193 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6194 }
6195 struct_ser.end()
6196 }
6197}
6198impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
6199 #[allow(deprecated)]
6200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6201 where
6202 D: serde::Deserializer<'de>,
6203 {
6204 const FIELDS: &[&str] = &[
6205 "vnode_indices",
6206 "vnodeIndices",
6207 ];
6208
6209 #[allow(clippy::enum_variant_names)]
6210 enum GeneratedField {
6211 VnodeIndices,
6212 }
6213 impl<'de> serde::Deserialize<'de> for GeneratedField {
6214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6215 where
6216 D: serde::Deserializer<'de>,
6217 {
6218 struct GeneratedVisitor;
6219
6220 impl serde::de::Visitor<'_> for GeneratedVisitor {
6221 type Value = GeneratedField;
6222
6223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6224 write!(formatter, "expected one of: {:?}", &FIELDS)
6225 }
6226
6227 #[allow(unused_variables)]
6228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6229 where
6230 E: serde::de::Error,
6231 {
6232 match value {
6233 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
6234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6235 }
6236 }
6237 }
6238 deserializer.deserialize_identifier(GeneratedVisitor)
6239 }
6240 }
6241 struct GeneratedVisitor;
6242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243 type Value = GetActorVnodesResponse;
6244
6245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246 formatter.write_str("struct meta.GetActorVnodesResponse")
6247 }
6248
6249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
6250 where
6251 V: serde::de::MapAccess<'de>,
6252 {
6253 let mut vnode_indices__ = None;
6254 while let Some(k) = map_.next_key()? {
6255 match k {
6256 GeneratedField::VnodeIndices => {
6257 if vnode_indices__.is_some() {
6258 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
6259 }
6260 vnode_indices__ =
6261 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6262 .into_iter().map(|x| x.0).collect())
6263 ;
6264 }
6265 }
6266 }
6267 Ok(GetActorVnodesResponse {
6268 vnode_indices: vnode_indices__.unwrap_or_default(),
6269 })
6270 }
6271 }
6272 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6273 }
6274}
6275impl serde::Serialize for GetClusterInfoRequest {
6276 #[allow(deprecated)]
6277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6278 where
6279 S: serde::Serializer,
6280 {
6281 use serde::ser::SerializeStruct;
6282 let len = 0;
6283 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6284 struct_ser.end()
6285 }
6286}
6287impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6288 #[allow(deprecated)]
6289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6290 where
6291 D: serde::Deserializer<'de>,
6292 {
6293 const FIELDS: &[&str] = &[
6294 ];
6295
6296 #[allow(clippy::enum_variant_names)]
6297 enum GeneratedField {
6298 }
6299 impl<'de> serde::Deserialize<'de> for GeneratedField {
6300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6301 where
6302 D: serde::Deserializer<'de>,
6303 {
6304 struct GeneratedVisitor;
6305
6306 impl serde::de::Visitor<'_> for GeneratedVisitor {
6307 type Value = GeneratedField;
6308
6309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6310 write!(formatter, "expected one of: {:?}", &FIELDS)
6311 }
6312
6313 #[allow(unused_variables)]
6314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6315 where
6316 E: serde::de::Error,
6317 {
6318 Err(serde::de::Error::unknown_field(value, FIELDS))
6319 }
6320 }
6321 deserializer.deserialize_identifier(GeneratedVisitor)
6322 }
6323 }
6324 struct GeneratedVisitor;
6325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6326 type Value = GetClusterInfoRequest;
6327
6328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6329 formatter.write_str("struct meta.GetClusterInfoRequest")
6330 }
6331
6332 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6333 where
6334 V: serde::de::MapAccess<'de>,
6335 {
6336 while map_.next_key::<GeneratedField>()?.is_some() {
6337 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6338 }
6339 Ok(GetClusterInfoRequest {
6340 })
6341 }
6342 }
6343 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6344 }
6345}
6346impl serde::Serialize for GetClusterInfoResponse {
6347 #[allow(deprecated)]
6348 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6349 where
6350 S: serde::Serializer,
6351 {
6352 use serde::ser::SerializeStruct;
6353 let mut len = 0;
6354 if !self.worker_nodes.is_empty() {
6355 len += 1;
6356 }
6357 if !self.table_fragments.is_empty() {
6358 len += 1;
6359 }
6360 if !self.actor_splits.is_empty() {
6361 len += 1;
6362 }
6363 if !self.source_infos.is_empty() {
6364 len += 1;
6365 }
6366 if self.revision != 0 {
6367 len += 1;
6368 }
6369 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6370 if !self.worker_nodes.is_empty() {
6371 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6372 }
6373 if !self.table_fragments.is_empty() {
6374 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6375 }
6376 if !self.actor_splits.is_empty() {
6377 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6378 }
6379 if !self.source_infos.is_empty() {
6380 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6381 }
6382 if self.revision != 0 {
6383 #[allow(clippy::needless_borrow)]
6384 #[allow(clippy::needless_borrows_for_generic_args)]
6385 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6386 }
6387 struct_ser.end()
6388 }
6389}
6390impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6391 #[allow(deprecated)]
6392 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6393 where
6394 D: serde::Deserializer<'de>,
6395 {
6396 const FIELDS: &[&str] = &[
6397 "worker_nodes",
6398 "workerNodes",
6399 "table_fragments",
6400 "tableFragments",
6401 "actor_splits",
6402 "actorSplits",
6403 "source_infos",
6404 "sourceInfos",
6405 "revision",
6406 ];
6407
6408 #[allow(clippy::enum_variant_names)]
6409 enum GeneratedField {
6410 WorkerNodes,
6411 TableFragments,
6412 ActorSplits,
6413 SourceInfos,
6414 Revision,
6415 }
6416 impl<'de> serde::Deserialize<'de> for GeneratedField {
6417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6418 where
6419 D: serde::Deserializer<'de>,
6420 {
6421 struct GeneratedVisitor;
6422
6423 impl serde::de::Visitor<'_> for GeneratedVisitor {
6424 type Value = GeneratedField;
6425
6426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6427 write!(formatter, "expected one of: {:?}", &FIELDS)
6428 }
6429
6430 #[allow(unused_variables)]
6431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6432 where
6433 E: serde::de::Error,
6434 {
6435 match value {
6436 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6437 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6438 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6439 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6440 "revision" => Ok(GeneratedField::Revision),
6441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6442 }
6443 }
6444 }
6445 deserializer.deserialize_identifier(GeneratedVisitor)
6446 }
6447 }
6448 struct GeneratedVisitor;
6449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6450 type Value = GetClusterInfoResponse;
6451
6452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6453 formatter.write_str("struct meta.GetClusterInfoResponse")
6454 }
6455
6456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6457 where
6458 V: serde::de::MapAccess<'de>,
6459 {
6460 let mut worker_nodes__ = None;
6461 let mut table_fragments__ = None;
6462 let mut actor_splits__ = None;
6463 let mut source_infos__ = None;
6464 let mut revision__ = None;
6465 while let Some(k) = map_.next_key()? {
6466 match k {
6467 GeneratedField::WorkerNodes => {
6468 if worker_nodes__.is_some() {
6469 return Err(serde::de::Error::duplicate_field("workerNodes"));
6470 }
6471 worker_nodes__ = Some(map_.next_value()?);
6472 }
6473 GeneratedField::TableFragments => {
6474 if table_fragments__.is_some() {
6475 return Err(serde::de::Error::duplicate_field("tableFragments"));
6476 }
6477 table_fragments__ = Some(map_.next_value()?);
6478 }
6479 GeneratedField::ActorSplits => {
6480 if actor_splits__.is_some() {
6481 return Err(serde::de::Error::duplicate_field("actorSplits"));
6482 }
6483 actor_splits__ = Some(
6484 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6485 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6486 );
6487 }
6488 GeneratedField::SourceInfos => {
6489 if source_infos__.is_some() {
6490 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6491 }
6492 source_infos__ = Some(
6493 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6494 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6495 );
6496 }
6497 GeneratedField::Revision => {
6498 if revision__.is_some() {
6499 return Err(serde::de::Error::duplicate_field("revision"));
6500 }
6501 revision__ =
6502 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6503 ;
6504 }
6505 }
6506 }
6507 Ok(GetClusterInfoResponse {
6508 worker_nodes: worker_nodes__.unwrap_or_default(),
6509 table_fragments: table_fragments__.unwrap_or_default(),
6510 actor_splits: actor_splits__.unwrap_or_default(),
6511 source_infos: source_infos__.unwrap_or_default(),
6512 revision: revision__.unwrap_or_default(),
6513 })
6514 }
6515 }
6516 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6517 }
6518}
6519impl serde::Serialize for GetClusterLimitsRequest {
6520 #[allow(deprecated)]
6521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6522 where
6523 S: serde::Serializer,
6524 {
6525 use serde::ser::SerializeStruct;
6526 let len = 0;
6527 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6528 struct_ser.end()
6529 }
6530}
6531impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6532 #[allow(deprecated)]
6533 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6534 where
6535 D: serde::Deserializer<'de>,
6536 {
6537 const FIELDS: &[&str] = &[
6538 ];
6539
6540 #[allow(clippy::enum_variant_names)]
6541 enum GeneratedField {
6542 }
6543 impl<'de> serde::Deserialize<'de> for GeneratedField {
6544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6545 where
6546 D: serde::Deserializer<'de>,
6547 {
6548 struct GeneratedVisitor;
6549
6550 impl serde::de::Visitor<'_> for GeneratedVisitor {
6551 type Value = GeneratedField;
6552
6553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6554 write!(formatter, "expected one of: {:?}", &FIELDS)
6555 }
6556
6557 #[allow(unused_variables)]
6558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6559 where
6560 E: serde::de::Error,
6561 {
6562 Err(serde::de::Error::unknown_field(value, FIELDS))
6563 }
6564 }
6565 deserializer.deserialize_identifier(GeneratedVisitor)
6566 }
6567 }
6568 struct GeneratedVisitor;
6569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6570 type Value = GetClusterLimitsRequest;
6571
6572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6573 formatter.write_str("struct meta.GetClusterLimitsRequest")
6574 }
6575
6576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6577 where
6578 V: serde::de::MapAccess<'de>,
6579 {
6580 while map_.next_key::<GeneratedField>()?.is_some() {
6581 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6582 }
6583 Ok(GetClusterLimitsRequest {
6584 })
6585 }
6586 }
6587 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6588 }
6589}
6590impl serde::Serialize for GetClusterLimitsResponse {
6591 #[allow(deprecated)]
6592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6593 where
6594 S: serde::Serializer,
6595 {
6596 use serde::ser::SerializeStruct;
6597 let mut len = 0;
6598 if !self.active_limits.is_empty() {
6599 len += 1;
6600 }
6601 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6602 if !self.active_limits.is_empty() {
6603 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6604 }
6605 struct_ser.end()
6606 }
6607}
6608impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6609 #[allow(deprecated)]
6610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6611 where
6612 D: serde::Deserializer<'de>,
6613 {
6614 const FIELDS: &[&str] = &[
6615 "active_limits",
6616 "activeLimits",
6617 ];
6618
6619 #[allow(clippy::enum_variant_names)]
6620 enum GeneratedField {
6621 ActiveLimits,
6622 }
6623 impl<'de> serde::Deserialize<'de> for GeneratedField {
6624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6625 where
6626 D: serde::Deserializer<'de>,
6627 {
6628 struct GeneratedVisitor;
6629
6630 impl serde::de::Visitor<'_> for GeneratedVisitor {
6631 type Value = GeneratedField;
6632
6633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6634 write!(formatter, "expected one of: {:?}", &FIELDS)
6635 }
6636
6637 #[allow(unused_variables)]
6638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6639 where
6640 E: serde::de::Error,
6641 {
6642 match value {
6643 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6644 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6645 }
6646 }
6647 }
6648 deserializer.deserialize_identifier(GeneratedVisitor)
6649 }
6650 }
6651 struct GeneratedVisitor;
6652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6653 type Value = GetClusterLimitsResponse;
6654
6655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6656 formatter.write_str("struct meta.GetClusterLimitsResponse")
6657 }
6658
6659 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6660 where
6661 V: serde::de::MapAccess<'de>,
6662 {
6663 let mut active_limits__ = None;
6664 while let Some(k) = map_.next_key()? {
6665 match k {
6666 GeneratedField::ActiveLimits => {
6667 if active_limits__.is_some() {
6668 return Err(serde::de::Error::duplicate_field("activeLimits"));
6669 }
6670 active_limits__ = Some(map_.next_value()?);
6671 }
6672 }
6673 }
6674 Ok(GetClusterLimitsResponse {
6675 active_limits: active_limits__.unwrap_or_default(),
6676 })
6677 }
6678 }
6679 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6680 }
6681}
6682impl serde::Serialize for GetClusterRecoveryStatusRequest {
6683 #[allow(deprecated)]
6684 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6685 where
6686 S: serde::Serializer,
6687 {
6688 use serde::ser::SerializeStruct;
6689 let len = 0;
6690 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6691 struct_ser.end()
6692 }
6693}
6694impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6695 #[allow(deprecated)]
6696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6697 where
6698 D: serde::Deserializer<'de>,
6699 {
6700 const FIELDS: &[&str] = &[
6701 ];
6702
6703 #[allow(clippy::enum_variant_names)]
6704 enum GeneratedField {
6705 }
6706 impl<'de> serde::Deserialize<'de> for GeneratedField {
6707 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6708 where
6709 D: serde::Deserializer<'de>,
6710 {
6711 struct GeneratedVisitor;
6712
6713 impl serde::de::Visitor<'_> for GeneratedVisitor {
6714 type Value = GeneratedField;
6715
6716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6717 write!(formatter, "expected one of: {:?}", &FIELDS)
6718 }
6719
6720 #[allow(unused_variables)]
6721 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6722 where
6723 E: serde::de::Error,
6724 {
6725 Err(serde::de::Error::unknown_field(value, FIELDS))
6726 }
6727 }
6728 deserializer.deserialize_identifier(GeneratedVisitor)
6729 }
6730 }
6731 struct GeneratedVisitor;
6732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6733 type Value = GetClusterRecoveryStatusRequest;
6734
6735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6736 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6737 }
6738
6739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6740 where
6741 V: serde::de::MapAccess<'de>,
6742 {
6743 while map_.next_key::<GeneratedField>()?.is_some() {
6744 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6745 }
6746 Ok(GetClusterRecoveryStatusRequest {
6747 })
6748 }
6749 }
6750 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6751 }
6752}
6753impl serde::Serialize for GetClusterRecoveryStatusResponse {
6754 #[allow(deprecated)]
6755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6756 where
6757 S: serde::Serializer,
6758 {
6759 use serde::ser::SerializeStruct;
6760 let mut len = 0;
6761 if self.status != 0 {
6762 len += 1;
6763 }
6764 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6765 if self.status != 0 {
6766 let v = RecoveryStatus::try_from(self.status)
6767 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6768 struct_ser.serialize_field("status", &v)?;
6769 }
6770 struct_ser.end()
6771 }
6772}
6773impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6774 #[allow(deprecated)]
6775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6776 where
6777 D: serde::Deserializer<'de>,
6778 {
6779 const FIELDS: &[&str] = &[
6780 "status",
6781 ];
6782
6783 #[allow(clippy::enum_variant_names)]
6784 enum GeneratedField {
6785 Status,
6786 }
6787 impl<'de> serde::Deserialize<'de> for GeneratedField {
6788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6789 where
6790 D: serde::Deserializer<'de>,
6791 {
6792 struct GeneratedVisitor;
6793
6794 impl serde::de::Visitor<'_> for GeneratedVisitor {
6795 type Value = GeneratedField;
6796
6797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6798 write!(formatter, "expected one of: {:?}", &FIELDS)
6799 }
6800
6801 #[allow(unused_variables)]
6802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6803 where
6804 E: serde::de::Error,
6805 {
6806 match value {
6807 "status" => Ok(GeneratedField::Status),
6808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6809 }
6810 }
6811 }
6812 deserializer.deserialize_identifier(GeneratedVisitor)
6813 }
6814 }
6815 struct GeneratedVisitor;
6816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6817 type Value = GetClusterRecoveryStatusResponse;
6818
6819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6820 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6821 }
6822
6823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6824 where
6825 V: serde::de::MapAccess<'de>,
6826 {
6827 let mut status__ = None;
6828 while let Some(k) = map_.next_key()? {
6829 match k {
6830 GeneratedField::Status => {
6831 if status__.is_some() {
6832 return Err(serde::de::Error::duplicate_field("status"));
6833 }
6834 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6835 }
6836 }
6837 }
6838 Ok(GetClusterRecoveryStatusResponse {
6839 status: status__.unwrap_or_default(),
6840 })
6841 }
6842 }
6843 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6844 }
6845}
6846impl serde::Serialize for GetFragmentByIdRequest {
6847 #[allow(deprecated)]
6848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6849 where
6850 S: serde::Serializer,
6851 {
6852 use serde::ser::SerializeStruct;
6853 let mut len = 0;
6854 if self.fragment_id != 0 {
6855 len += 1;
6856 }
6857 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6858 if self.fragment_id != 0 {
6859 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6860 }
6861 struct_ser.end()
6862 }
6863}
6864impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6865 #[allow(deprecated)]
6866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6867 where
6868 D: serde::Deserializer<'de>,
6869 {
6870 const FIELDS: &[&str] = &[
6871 "fragment_id",
6872 "fragmentId",
6873 ];
6874
6875 #[allow(clippy::enum_variant_names)]
6876 enum GeneratedField {
6877 FragmentId,
6878 }
6879 impl<'de> serde::Deserialize<'de> for GeneratedField {
6880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6881 where
6882 D: serde::Deserializer<'de>,
6883 {
6884 struct GeneratedVisitor;
6885
6886 impl serde::de::Visitor<'_> for GeneratedVisitor {
6887 type Value = GeneratedField;
6888
6889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6890 write!(formatter, "expected one of: {:?}", &FIELDS)
6891 }
6892
6893 #[allow(unused_variables)]
6894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6895 where
6896 E: serde::de::Error,
6897 {
6898 match value {
6899 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6901 }
6902 }
6903 }
6904 deserializer.deserialize_identifier(GeneratedVisitor)
6905 }
6906 }
6907 struct GeneratedVisitor;
6908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6909 type Value = GetFragmentByIdRequest;
6910
6911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6912 formatter.write_str("struct meta.GetFragmentByIdRequest")
6913 }
6914
6915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6916 where
6917 V: serde::de::MapAccess<'de>,
6918 {
6919 let mut fragment_id__ = None;
6920 while let Some(k) = map_.next_key()? {
6921 match k {
6922 GeneratedField::FragmentId => {
6923 if fragment_id__.is_some() {
6924 return Err(serde::de::Error::duplicate_field("fragmentId"));
6925 }
6926 fragment_id__ =
6927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6928 ;
6929 }
6930 }
6931 }
6932 Ok(GetFragmentByIdRequest {
6933 fragment_id: fragment_id__.unwrap_or_default(),
6934 })
6935 }
6936 }
6937 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6938 }
6939}
6940impl serde::Serialize for GetFragmentByIdResponse {
6941 #[allow(deprecated)]
6942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6943 where
6944 S: serde::Serializer,
6945 {
6946 use serde::ser::SerializeStruct;
6947 let mut len = 0;
6948 if self.distribution.is_some() {
6949 len += 1;
6950 }
6951 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6952 if let Some(v) = self.distribution.as_ref() {
6953 struct_ser.serialize_field("distribution", v)?;
6954 }
6955 struct_ser.end()
6956 }
6957}
6958impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6959 #[allow(deprecated)]
6960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6961 where
6962 D: serde::Deserializer<'de>,
6963 {
6964 const FIELDS: &[&str] = &[
6965 "distribution",
6966 ];
6967
6968 #[allow(clippy::enum_variant_names)]
6969 enum GeneratedField {
6970 Distribution,
6971 }
6972 impl<'de> serde::Deserialize<'de> for GeneratedField {
6973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6974 where
6975 D: serde::Deserializer<'de>,
6976 {
6977 struct GeneratedVisitor;
6978
6979 impl serde::de::Visitor<'_> for GeneratedVisitor {
6980 type Value = GeneratedField;
6981
6982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6983 write!(formatter, "expected one of: {:?}", &FIELDS)
6984 }
6985
6986 #[allow(unused_variables)]
6987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6988 where
6989 E: serde::de::Error,
6990 {
6991 match value {
6992 "distribution" => Ok(GeneratedField::Distribution),
6993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6994 }
6995 }
6996 }
6997 deserializer.deserialize_identifier(GeneratedVisitor)
6998 }
6999 }
7000 struct GeneratedVisitor;
7001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7002 type Value = GetFragmentByIdResponse;
7003
7004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7005 formatter.write_str("struct meta.GetFragmentByIdResponse")
7006 }
7007
7008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
7009 where
7010 V: serde::de::MapAccess<'de>,
7011 {
7012 let mut distribution__ = None;
7013 while let Some(k) = map_.next_key()? {
7014 match k {
7015 GeneratedField::Distribution => {
7016 if distribution__.is_some() {
7017 return Err(serde::de::Error::duplicate_field("distribution"));
7018 }
7019 distribution__ = map_.next_value()?;
7020 }
7021 }
7022 }
7023 Ok(GetFragmentByIdResponse {
7024 distribution: distribution__,
7025 })
7026 }
7027 }
7028 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
7029 }
7030}
7031impl serde::Serialize for GetFragmentVnodesRequest {
7032 #[allow(deprecated)]
7033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7034 where
7035 S: serde::Serializer,
7036 {
7037 use serde::ser::SerializeStruct;
7038 let mut len = 0;
7039 if self.fragment_id != 0 {
7040 len += 1;
7041 }
7042 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
7043 if self.fragment_id != 0 {
7044 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7045 }
7046 struct_ser.end()
7047 }
7048}
7049impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
7050 #[allow(deprecated)]
7051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7052 where
7053 D: serde::Deserializer<'de>,
7054 {
7055 const FIELDS: &[&str] = &[
7056 "fragment_id",
7057 "fragmentId",
7058 ];
7059
7060 #[allow(clippy::enum_variant_names)]
7061 enum GeneratedField {
7062 FragmentId,
7063 }
7064 impl<'de> serde::Deserialize<'de> for GeneratedField {
7065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7066 where
7067 D: serde::Deserializer<'de>,
7068 {
7069 struct GeneratedVisitor;
7070
7071 impl serde::de::Visitor<'_> for GeneratedVisitor {
7072 type Value = GeneratedField;
7073
7074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7075 write!(formatter, "expected one of: {:?}", &FIELDS)
7076 }
7077
7078 #[allow(unused_variables)]
7079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7080 where
7081 E: serde::de::Error,
7082 {
7083 match value {
7084 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7085 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7086 }
7087 }
7088 }
7089 deserializer.deserialize_identifier(GeneratedVisitor)
7090 }
7091 }
7092 struct GeneratedVisitor;
7093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7094 type Value = GetFragmentVnodesRequest;
7095
7096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7097 formatter.write_str("struct meta.GetFragmentVnodesRequest")
7098 }
7099
7100 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
7101 where
7102 V: serde::de::MapAccess<'de>,
7103 {
7104 let mut fragment_id__ = None;
7105 while let Some(k) = map_.next_key()? {
7106 match k {
7107 GeneratedField::FragmentId => {
7108 if fragment_id__.is_some() {
7109 return Err(serde::de::Error::duplicate_field("fragmentId"));
7110 }
7111 fragment_id__ =
7112 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7113 ;
7114 }
7115 }
7116 }
7117 Ok(GetFragmentVnodesRequest {
7118 fragment_id: fragment_id__.unwrap_or_default(),
7119 })
7120 }
7121 }
7122 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
7123 }
7124}
7125impl serde::Serialize for GetFragmentVnodesResponse {
7126 #[allow(deprecated)]
7127 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7128 where
7129 S: serde::Serializer,
7130 {
7131 use serde::ser::SerializeStruct;
7132 let mut len = 0;
7133 if !self.actor_vnodes.is_empty() {
7134 len += 1;
7135 }
7136 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
7137 if !self.actor_vnodes.is_empty() {
7138 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
7139 }
7140 struct_ser.end()
7141 }
7142}
7143impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
7144 #[allow(deprecated)]
7145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7146 where
7147 D: serde::Deserializer<'de>,
7148 {
7149 const FIELDS: &[&str] = &[
7150 "actor_vnodes",
7151 "actorVnodes",
7152 ];
7153
7154 #[allow(clippy::enum_variant_names)]
7155 enum GeneratedField {
7156 ActorVnodes,
7157 }
7158 impl<'de> serde::Deserialize<'de> for GeneratedField {
7159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7160 where
7161 D: serde::Deserializer<'de>,
7162 {
7163 struct GeneratedVisitor;
7164
7165 impl serde::de::Visitor<'_> for GeneratedVisitor {
7166 type Value = GeneratedField;
7167
7168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7169 write!(formatter, "expected one of: {:?}", &FIELDS)
7170 }
7171
7172 #[allow(unused_variables)]
7173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7174 where
7175 E: serde::de::Error,
7176 {
7177 match value {
7178 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
7179 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7180 }
7181 }
7182 }
7183 deserializer.deserialize_identifier(GeneratedVisitor)
7184 }
7185 }
7186 struct GeneratedVisitor;
7187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7188 type Value = GetFragmentVnodesResponse;
7189
7190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7191 formatter.write_str("struct meta.GetFragmentVnodesResponse")
7192 }
7193
7194 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
7195 where
7196 V: serde::de::MapAccess<'de>,
7197 {
7198 let mut actor_vnodes__ = None;
7199 while let Some(k) = map_.next_key()? {
7200 match k {
7201 GeneratedField::ActorVnodes => {
7202 if actor_vnodes__.is_some() {
7203 return Err(serde::de::Error::duplicate_field("actorVnodes"));
7204 }
7205 actor_vnodes__ = Some(map_.next_value()?);
7206 }
7207 }
7208 }
7209 Ok(GetFragmentVnodesResponse {
7210 actor_vnodes: actor_vnodes__.unwrap_or_default(),
7211 })
7212 }
7213 }
7214 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
7215 }
7216}
7217impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
7218 #[allow(deprecated)]
7219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7220 where
7221 S: serde::Serializer,
7222 {
7223 use serde::ser::SerializeStruct;
7224 let mut len = 0;
7225 if self.actor_id != 0 {
7226 len += 1;
7227 }
7228 if !self.vnode_indices.is_empty() {
7229 len += 1;
7230 }
7231 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
7232 if self.actor_id != 0 {
7233 struct_ser.serialize_field("actorId", &self.actor_id)?;
7234 }
7235 if !self.vnode_indices.is_empty() {
7236 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
7237 }
7238 struct_ser.end()
7239 }
7240}
7241impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
7242 #[allow(deprecated)]
7243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7244 where
7245 D: serde::Deserializer<'de>,
7246 {
7247 const FIELDS: &[&str] = &[
7248 "actor_id",
7249 "actorId",
7250 "vnode_indices",
7251 "vnodeIndices",
7252 ];
7253
7254 #[allow(clippy::enum_variant_names)]
7255 enum GeneratedField {
7256 ActorId,
7257 VnodeIndices,
7258 }
7259 impl<'de> serde::Deserialize<'de> for GeneratedField {
7260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7261 where
7262 D: serde::Deserializer<'de>,
7263 {
7264 struct GeneratedVisitor;
7265
7266 impl serde::de::Visitor<'_> for GeneratedVisitor {
7267 type Value = GeneratedField;
7268
7269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7270 write!(formatter, "expected one of: {:?}", &FIELDS)
7271 }
7272
7273 #[allow(unused_variables)]
7274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7275 where
7276 E: serde::de::Error,
7277 {
7278 match value {
7279 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7280 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7282 }
7283 }
7284 }
7285 deserializer.deserialize_identifier(GeneratedVisitor)
7286 }
7287 }
7288 struct GeneratedVisitor;
7289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7290 type Value = get_fragment_vnodes_response::ActorVnodes;
7291
7292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7293 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7294 }
7295
7296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7297 where
7298 V: serde::de::MapAccess<'de>,
7299 {
7300 let mut actor_id__ = None;
7301 let mut vnode_indices__ = None;
7302 while let Some(k) = map_.next_key()? {
7303 match k {
7304 GeneratedField::ActorId => {
7305 if actor_id__.is_some() {
7306 return Err(serde::de::Error::duplicate_field("actorId"));
7307 }
7308 actor_id__ =
7309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7310 ;
7311 }
7312 GeneratedField::VnodeIndices => {
7313 if vnode_indices__.is_some() {
7314 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7315 }
7316 vnode_indices__ =
7317 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7318 .into_iter().map(|x| x.0).collect())
7319 ;
7320 }
7321 }
7322 }
7323 Ok(get_fragment_vnodes_response::ActorVnodes {
7324 actor_id: actor_id__.unwrap_or_default(),
7325 vnode_indices: vnode_indices__.unwrap_or_default(),
7326 })
7327 }
7328 }
7329 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7330 }
7331}
7332impl serde::Serialize for GetMetaStoreInfoRequest {
7333 #[allow(deprecated)]
7334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7335 where
7336 S: serde::Serializer,
7337 {
7338 use serde::ser::SerializeStruct;
7339 let len = 0;
7340 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7341 struct_ser.end()
7342 }
7343}
7344impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7345 #[allow(deprecated)]
7346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7347 where
7348 D: serde::Deserializer<'de>,
7349 {
7350 const FIELDS: &[&str] = &[
7351 ];
7352
7353 #[allow(clippy::enum_variant_names)]
7354 enum GeneratedField {
7355 }
7356 impl<'de> serde::Deserialize<'de> for GeneratedField {
7357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7358 where
7359 D: serde::Deserializer<'de>,
7360 {
7361 struct GeneratedVisitor;
7362
7363 impl serde::de::Visitor<'_> for GeneratedVisitor {
7364 type Value = GeneratedField;
7365
7366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7367 write!(formatter, "expected one of: {:?}", &FIELDS)
7368 }
7369
7370 #[allow(unused_variables)]
7371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7372 where
7373 E: serde::de::Error,
7374 {
7375 Err(serde::de::Error::unknown_field(value, FIELDS))
7376 }
7377 }
7378 deserializer.deserialize_identifier(GeneratedVisitor)
7379 }
7380 }
7381 struct GeneratedVisitor;
7382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7383 type Value = GetMetaStoreInfoRequest;
7384
7385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7386 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7387 }
7388
7389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7390 where
7391 V: serde::de::MapAccess<'de>,
7392 {
7393 while map_.next_key::<GeneratedField>()?.is_some() {
7394 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7395 }
7396 Ok(GetMetaStoreInfoRequest {
7397 })
7398 }
7399 }
7400 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7401 }
7402}
7403impl serde::Serialize for GetMetaStoreInfoResponse {
7404 #[allow(deprecated)]
7405 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7406 where
7407 S: serde::Serializer,
7408 {
7409 use serde::ser::SerializeStruct;
7410 let mut len = 0;
7411 if !self.meta_store_endpoint.is_empty() {
7412 len += 1;
7413 }
7414 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7415 if !self.meta_store_endpoint.is_empty() {
7416 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7417 }
7418 struct_ser.end()
7419 }
7420}
7421impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7422 #[allow(deprecated)]
7423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7424 where
7425 D: serde::Deserializer<'de>,
7426 {
7427 const FIELDS: &[&str] = &[
7428 "meta_store_endpoint",
7429 "metaStoreEndpoint",
7430 ];
7431
7432 #[allow(clippy::enum_variant_names)]
7433 enum GeneratedField {
7434 MetaStoreEndpoint,
7435 }
7436 impl<'de> serde::Deserialize<'de> for GeneratedField {
7437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7438 where
7439 D: serde::Deserializer<'de>,
7440 {
7441 struct GeneratedVisitor;
7442
7443 impl serde::de::Visitor<'_> for GeneratedVisitor {
7444 type Value = GeneratedField;
7445
7446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7447 write!(formatter, "expected one of: {:?}", &FIELDS)
7448 }
7449
7450 #[allow(unused_variables)]
7451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7452 where
7453 E: serde::de::Error,
7454 {
7455 match value {
7456 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7457 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7458 }
7459 }
7460 }
7461 deserializer.deserialize_identifier(GeneratedVisitor)
7462 }
7463 }
7464 struct GeneratedVisitor;
7465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7466 type Value = GetMetaStoreInfoResponse;
7467
7468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7469 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7470 }
7471
7472 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7473 where
7474 V: serde::de::MapAccess<'de>,
7475 {
7476 let mut meta_store_endpoint__ = None;
7477 while let Some(k) = map_.next_key()? {
7478 match k {
7479 GeneratedField::MetaStoreEndpoint => {
7480 if meta_store_endpoint__.is_some() {
7481 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7482 }
7483 meta_store_endpoint__ = Some(map_.next_value()?);
7484 }
7485 }
7486 }
7487 Ok(GetMetaStoreInfoResponse {
7488 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7489 })
7490 }
7491 }
7492 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7493 }
7494}
7495impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7496 #[allow(deprecated)]
7497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7498 where
7499 S: serde::Serializer,
7500 {
7501 use serde::ser::SerializeStruct;
7502 let len = 0;
7503 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7504 struct_ser.end()
7505 }
7506}
7507impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
7508 #[allow(deprecated)]
7509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7510 where
7511 D: serde::Deserializer<'de>,
7512 {
7513 const FIELDS: &[&str] = &[
7514 ];
7515
7516 #[allow(clippy::enum_variant_names)]
7517 enum GeneratedField {
7518 }
7519 impl<'de> serde::Deserialize<'de> for GeneratedField {
7520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7521 where
7522 D: serde::Deserializer<'de>,
7523 {
7524 struct GeneratedVisitor;
7525
7526 impl serde::de::Visitor<'_> for GeneratedVisitor {
7527 type Value = GeneratedField;
7528
7529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7530 write!(formatter, "expected one of: {:?}", &FIELDS)
7531 }
7532
7533 #[allow(unused_variables)]
7534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7535 where
7536 E: serde::de::Error,
7537 {
7538 Err(serde::de::Error::unknown_field(value, FIELDS))
7539 }
7540 }
7541 deserializer.deserialize_identifier(GeneratedVisitor)
7542 }
7543 }
7544 struct GeneratedVisitor;
7545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7546 type Value = GetServerlessStreamingJobsStatusRequest;
7547
7548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7549 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7550 }
7551
7552 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7553 where
7554 V: serde::de::MapAccess<'de>,
7555 {
7556 while map_.next_key::<GeneratedField>()?.is_some() {
7557 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7558 }
7559 Ok(GetServerlessStreamingJobsStatusRequest {
7560 })
7561 }
7562 }
7563 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7564 }
7565}
7566impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
7567 #[allow(deprecated)]
7568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7569 where
7570 S: serde::Serializer,
7571 {
7572 use serde::ser::SerializeStruct;
7573 let mut len = 0;
7574 if !self.streaming_job_statuses.is_empty() {
7575 len += 1;
7576 }
7577 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7578 if !self.streaming_job_statuses.is_empty() {
7579 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7580 }
7581 struct_ser.end()
7582 }
7583}
7584impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7585 #[allow(deprecated)]
7586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7587 where
7588 D: serde::Deserializer<'de>,
7589 {
7590 const FIELDS: &[&str] = &[
7591 "streaming_job_statuses",
7592 "streamingJobStatuses",
7593 ];
7594
7595 #[allow(clippy::enum_variant_names)]
7596 enum GeneratedField {
7597 StreamingJobStatuses,
7598 }
7599 impl<'de> serde::Deserialize<'de> for GeneratedField {
7600 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7601 where
7602 D: serde::Deserializer<'de>,
7603 {
7604 struct GeneratedVisitor;
7605
7606 impl serde::de::Visitor<'_> for GeneratedVisitor {
7607 type Value = GeneratedField;
7608
7609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7610 write!(formatter, "expected one of: {:?}", &FIELDS)
7611 }
7612
7613 #[allow(unused_variables)]
7614 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7615 where
7616 E: serde::de::Error,
7617 {
7618 match value {
7619 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7620 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7621 }
7622 }
7623 }
7624 deserializer.deserialize_identifier(GeneratedVisitor)
7625 }
7626 }
7627 struct GeneratedVisitor;
7628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7629 type Value = GetServerlessStreamingJobsStatusResponse;
7630
7631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7632 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7633 }
7634
7635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7636 where
7637 V: serde::de::MapAccess<'de>,
7638 {
7639 let mut streaming_job_statuses__ = None;
7640 while let Some(k) = map_.next_key()? {
7641 match k {
7642 GeneratedField::StreamingJobStatuses => {
7643 if streaming_job_statuses__.is_some() {
7644 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7645 }
7646 streaming_job_statuses__ = Some(map_.next_value()?);
7647 }
7648 }
7649 }
7650 Ok(GetServerlessStreamingJobsStatusResponse {
7651 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7652 })
7653 }
7654 }
7655 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7656 }
7657}
7658impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7659 #[allow(deprecated)]
7660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7661 where
7662 S: serde::Serializer,
7663 {
7664 use serde::ser::SerializeStruct;
7665 let mut len = 0;
7666 if self.table_id != 0 {
7667 len += 1;
7668 }
7669 if !self.node_label.is_empty() {
7670 len += 1;
7671 }
7672 if self.backfill_done {
7673 len += 1;
7674 }
7675 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7676 if self.table_id != 0 {
7677 struct_ser.serialize_field("tableId", &self.table_id)?;
7678 }
7679 if !self.node_label.is_empty() {
7680 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7681 }
7682 if self.backfill_done {
7683 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7684 }
7685 struct_ser.end()
7686 }
7687}
7688impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7689 #[allow(deprecated)]
7690 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7691 where
7692 D: serde::Deserializer<'de>,
7693 {
7694 const FIELDS: &[&str] = &[
7695 "table_id",
7696 "tableId",
7697 "node_label",
7698 "nodeLabel",
7699 "backfill_done",
7700 "backfillDone",
7701 ];
7702
7703 #[allow(clippy::enum_variant_names)]
7704 enum GeneratedField {
7705 TableId,
7706 NodeLabel,
7707 BackfillDone,
7708 }
7709 impl<'de> serde::Deserialize<'de> for GeneratedField {
7710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7711 where
7712 D: serde::Deserializer<'de>,
7713 {
7714 struct GeneratedVisitor;
7715
7716 impl serde::de::Visitor<'_> for GeneratedVisitor {
7717 type Value = GeneratedField;
7718
7719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7720 write!(formatter, "expected one of: {:?}", &FIELDS)
7721 }
7722
7723 #[allow(unused_variables)]
7724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7725 where
7726 E: serde::de::Error,
7727 {
7728 match value {
7729 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7730 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7731 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7733 }
7734 }
7735 }
7736 deserializer.deserialize_identifier(GeneratedVisitor)
7737 }
7738 }
7739 struct GeneratedVisitor;
7740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7741 type Value = get_serverless_streaming_jobs_status_response::Status;
7742
7743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7744 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7745 }
7746
7747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7748 where
7749 V: serde::de::MapAccess<'de>,
7750 {
7751 let mut table_id__ = None;
7752 let mut node_label__ = None;
7753 let mut backfill_done__ = None;
7754 while let Some(k) = map_.next_key()? {
7755 match k {
7756 GeneratedField::TableId => {
7757 if table_id__.is_some() {
7758 return Err(serde::de::Error::duplicate_field("tableId"));
7759 }
7760 table_id__ =
7761 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7762 ;
7763 }
7764 GeneratedField::NodeLabel => {
7765 if node_label__.is_some() {
7766 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7767 }
7768 node_label__ = Some(map_.next_value()?);
7769 }
7770 GeneratedField::BackfillDone => {
7771 if backfill_done__.is_some() {
7772 return Err(serde::de::Error::duplicate_field("backfillDone"));
7773 }
7774 backfill_done__ = Some(map_.next_value()?);
7775 }
7776 }
7777 }
7778 Ok(get_serverless_streaming_jobs_status_response::Status {
7779 table_id: table_id__.unwrap_or_default(),
7780 node_label: node_label__.unwrap_or_default(),
7781 backfill_done: backfill_done__.unwrap_or_default(),
7782 })
7783 }
7784 }
7785 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7786 }
7787}
7788impl serde::Serialize for GetServingVnodeMappingsRequest {
7789 #[allow(deprecated)]
7790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7791 where
7792 S: serde::Serializer,
7793 {
7794 use serde::ser::SerializeStruct;
7795 let len = 0;
7796 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7797 struct_ser.end()
7798 }
7799}
7800impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7801 #[allow(deprecated)]
7802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7803 where
7804 D: serde::Deserializer<'de>,
7805 {
7806 const FIELDS: &[&str] = &[
7807 ];
7808
7809 #[allow(clippy::enum_variant_names)]
7810 enum GeneratedField {
7811 }
7812 impl<'de> serde::Deserialize<'de> for GeneratedField {
7813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7814 where
7815 D: serde::Deserializer<'de>,
7816 {
7817 struct GeneratedVisitor;
7818
7819 impl serde::de::Visitor<'_> for GeneratedVisitor {
7820 type Value = GeneratedField;
7821
7822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7823 write!(formatter, "expected one of: {:?}", &FIELDS)
7824 }
7825
7826 #[allow(unused_variables)]
7827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7828 where
7829 E: serde::de::Error,
7830 {
7831 Err(serde::de::Error::unknown_field(value, FIELDS))
7832 }
7833 }
7834 deserializer.deserialize_identifier(GeneratedVisitor)
7835 }
7836 }
7837 struct GeneratedVisitor;
7838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7839 type Value = GetServingVnodeMappingsRequest;
7840
7841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7842 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7843 }
7844
7845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7846 where
7847 V: serde::de::MapAccess<'de>,
7848 {
7849 while map_.next_key::<GeneratedField>()?.is_some() {
7850 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7851 }
7852 Ok(GetServingVnodeMappingsRequest {
7853 })
7854 }
7855 }
7856 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7857 }
7858}
7859impl serde::Serialize for GetServingVnodeMappingsResponse {
7860 #[allow(deprecated)]
7861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7862 where
7863 S: serde::Serializer,
7864 {
7865 use serde::ser::SerializeStruct;
7866 let mut len = 0;
7867 if !self.fragment_to_table.is_empty() {
7868 len += 1;
7869 }
7870 if !self.worker_slot_mappings.is_empty() {
7871 len += 1;
7872 }
7873 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7874 if !self.fragment_to_table.is_empty() {
7875 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7876 }
7877 if !self.worker_slot_mappings.is_empty() {
7878 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7879 }
7880 struct_ser.end()
7881 }
7882}
7883impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7884 #[allow(deprecated)]
7885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7886 where
7887 D: serde::Deserializer<'de>,
7888 {
7889 const FIELDS: &[&str] = &[
7890 "fragment_to_table",
7891 "fragmentToTable",
7892 "worker_slot_mappings",
7893 "workerSlotMappings",
7894 ];
7895
7896 #[allow(clippy::enum_variant_names)]
7897 enum GeneratedField {
7898 FragmentToTable,
7899 WorkerSlotMappings,
7900 }
7901 impl<'de> serde::Deserialize<'de> for GeneratedField {
7902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7903 where
7904 D: serde::Deserializer<'de>,
7905 {
7906 struct GeneratedVisitor;
7907
7908 impl serde::de::Visitor<'_> for GeneratedVisitor {
7909 type Value = GeneratedField;
7910
7911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7912 write!(formatter, "expected one of: {:?}", &FIELDS)
7913 }
7914
7915 #[allow(unused_variables)]
7916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7917 where
7918 E: serde::de::Error,
7919 {
7920 match value {
7921 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7922 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7924 }
7925 }
7926 }
7927 deserializer.deserialize_identifier(GeneratedVisitor)
7928 }
7929 }
7930 struct GeneratedVisitor;
7931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7932 type Value = GetServingVnodeMappingsResponse;
7933
7934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7935 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7936 }
7937
7938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7939 where
7940 V: serde::de::MapAccess<'de>,
7941 {
7942 let mut fragment_to_table__ = None;
7943 let mut worker_slot_mappings__ = None;
7944 while let Some(k) = map_.next_key()? {
7945 match k {
7946 GeneratedField::FragmentToTable => {
7947 if fragment_to_table__.is_some() {
7948 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7949 }
7950 fragment_to_table__ = Some(
7951 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7952 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
7953 );
7954 }
7955 GeneratedField::WorkerSlotMappings => {
7956 if worker_slot_mappings__.is_some() {
7957 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7958 }
7959 worker_slot_mappings__ = Some(map_.next_value()?);
7960 }
7961 }
7962 }
7963 Ok(GetServingVnodeMappingsResponse {
7964 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7965 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7966 })
7967 }
7968 }
7969 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7970 }
7971}
7972impl serde::Serialize for GetSessionParamsRequest {
7973 #[allow(deprecated)]
7974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7975 where
7976 S: serde::Serializer,
7977 {
7978 use serde::ser::SerializeStruct;
7979 let len = 0;
7980 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7981 struct_ser.end()
7982 }
7983}
7984impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7985 #[allow(deprecated)]
7986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7987 where
7988 D: serde::Deserializer<'de>,
7989 {
7990 const FIELDS: &[&str] = &[
7991 ];
7992
7993 #[allow(clippy::enum_variant_names)]
7994 enum GeneratedField {
7995 }
7996 impl<'de> serde::Deserialize<'de> for GeneratedField {
7997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7998 where
7999 D: serde::Deserializer<'de>,
8000 {
8001 struct GeneratedVisitor;
8002
8003 impl serde::de::Visitor<'_> for GeneratedVisitor {
8004 type Value = GeneratedField;
8005
8006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8007 write!(formatter, "expected one of: {:?}", &FIELDS)
8008 }
8009
8010 #[allow(unused_variables)]
8011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8012 where
8013 E: serde::de::Error,
8014 {
8015 Err(serde::de::Error::unknown_field(value, FIELDS))
8016 }
8017 }
8018 deserializer.deserialize_identifier(GeneratedVisitor)
8019 }
8020 }
8021 struct GeneratedVisitor;
8022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8023 type Value = GetSessionParamsRequest;
8024
8025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8026 formatter.write_str("struct meta.GetSessionParamsRequest")
8027 }
8028
8029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
8030 where
8031 V: serde::de::MapAccess<'de>,
8032 {
8033 while map_.next_key::<GeneratedField>()?.is_some() {
8034 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8035 }
8036 Ok(GetSessionParamsRequest {
8037 })
8038 }
8039 }
8040 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
8041 }
8042}
8043impl serde::Serialize for GetSessionParamsResponse {
8044 #[allow(deprecated)]
8045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8046 where
8047 S: serde::Serializer,
8048 {
8049 use serde::ser::SerializeStruct;
8050 let mut len = 0;
8051 if !self.params.is_empty() {
8052 len += 1;
8053 }
8054 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
8055 if !self.params.is_empty() {
8056 struct_ser.serialize_field("params", &self.params)?;
8057 }
8058 struct_ser.end()
8059 }
8060}
8061impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
8062 #[allow(deprecated)]
8063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8064 where
8065 D: serde::Deserializer<'de>,
8066 {
8067 const FIELDS: &[&str] = &[
8068 "params",
8069 ];
8070
8071 #[allow(clippy::enum_variant_names)]
8072 enum GeneratedField {
8073 Params,
8074 }
8075 impl<'de> serde::Deserialize<'de> for GeneratedField {
8076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8077 where
8078 D: serde::Deserializer<'de>,
8079 {
8080 struct GeneratedVisitor;
8081
8082 impl serde::de::Visitor<'_> for GeneratedVisitor {
8083 type Value = GeneratedField;
8084
8085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8086 write!(formatter, "expected one of: {:?}", &FIELDS)
8087 }
8088
8089 #[allow(unused_variables)]
8090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8091 where
8092 E: serde::de::Error,
8093 {
8094 match value {
8095 "params" => Ok(GeneratedField::Params),
8096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8097 }
8098 }
8099 }
8100 deserializer.deserialize_identifier(GeneratedVisitor)
8101 }
8102 }
8103 struct GeneratedVisitor;
8104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8105 type Value = GetSessionParamsResponse;
8106
8107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8108 formatter.write_str("struct meta.GetSessionParamsResponse")
8109 }
8110
8111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
8112 where
8113 V: serde::de::MapAccess<'de>,
8114 {
8115 let mut params__ = None;
8116 while let Some(k) = map_.next_key()? {
8117 match k {
8118 GeneratedField::Params => {
8119 if params__.is_some() {
8120 return Err(serde::de::Error::duplicate_field("params"));
8121 }
8122 params__ = Some(map_.next_value()?);
8123 }
8124 }
8125 }
8126 Ok(GetSessionParamsResponse {
8127 params: params__.unwrap_or_default(),
8128 })
8129 }
8130 }
8131 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
8132 }
8133}
8134impl serde::Serialize for GetSystemParamsRequest {
8135 #[allow(deprecated)]
8136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8137 where
8138 S: serde::Serializer,
8139 {
8140 use serde::ser::SerializeStruct;
8141 let len = 0;
8142 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
8143 struct_ser.end()
8144 }
8145}
8146impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
8147 #[allow(deprecated)]
8148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8149 where
8150 D: serde::Deserializer<'de>,
8151 {
8152 const FIELDS: &[&str] = &[
8153 ];
8154
8155 #[allow(clippy::enum_variant_names)]
8156 enum GeneratedField {
8157 }
8158 impl<'de> serde::Deserialize<'de> for GeneratedField {
8159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8160 where
8161 D: serde::Deserializer<'de>,
8162 {
8163 struct GeneratedVisitor;
8164
8165 impl serde::de::Visitor<'_> for GeneratedVisitor {
8166 type Value = GeneratedField;
8167
8168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8169 write!(formatter, "expected one of: {:?}", &FIELDS)
8170 }
8171
8172 #[allow(unused_variables)]
8173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8174 where
8175 E: serde::de::Error,
8176 {
8177 Err(serde::de::Error::unknown_field(value, FIELDS))
8178 }
8179 }
8180 deserializer.deserialize_identifier(GeneratedVisitor)
8181 }
8182 }
8183 struct GeneratedVisitor;
8184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8185 type Value = GetSystemParamsRequest;
8186
8187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8188 formatter.write_str("struct meta.GetSystemParamsRequest")
8189 }
8190
8191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
8192 where
8193 V: serde::de::MapAccess<'de>,
8194 {
8195 while map_.next_key::<GeneratedField>()?.is_some() {
8196 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8197 }
8198 Ok(GetSystemParamsRequest {
8199 })
8200 }
8201 }
8202 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
8203 }
8204}
8205impl serde::Serialize for GetSystemParamsResponse {
8206 #[allow(deprecated)]
8207 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8208 where
8209 S: serde::Serializer,
8210 {
8211 use serde::ser::SerializeStruct;
8212 let mut len = 0;
8213 if self.params.is_some() {
8214 len += 1;
8215 }
8216 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
8217 if let Some(v) = self.params.as_ref() {
8218 struct_ser.serialize_field("params", v)?;
8219 }
8220 struct_ser.end()
8221 }
8222}
8223impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
8224 #[allow(deprecated)]
8225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8226 where
8227 D: serde::Deserializer<'de>,
8228 {
8229 const FIELDS: &[&str] = &[
8230 "params",
8231 ];
8232
8233 #[allow(clippy::enum_variant_names)]
8234 enum GeneratedField {
8235 Params,
8236 }
8237 impl<'de> serde::Deserialize<'de> for GeneratedField {
8238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8239 where
8240 D: serde::Deserializer<'de>,
8241 {
8242 struct GeneratedVisitor;
8243
8244 impl serde::de::Visitor<'_> for GeneratedVisitor {
8245 type Value = GeneratedField;
8246
8247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8248 write!(formatter, "expected one of: {:?}", &FIELDS)
8249 }
8250
8251 #[allow(unused_variables)]
8252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8253 where
8254 E: serde::de::Error,
8255 {
8256 match value {
8257 "params" => Ok(GeneratedField::Params),
8258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8259 }
8260 }
8261 }
8262 deserializer.deserialize_identifier(GeneratedVisitor)
8263 }
8264 }
8265 struct GeneratedVisitor;
8266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8267 type Value = GetSystemParamsResponse;
8268
8269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8270 formatter.write_str("struct meta.GetSystemParamsResponse")
8271 }
8272
8273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8274 where
8275 V: serde::de::MapAccess<'de>,
8276 {
8277 let mut params__ = None;
8278 while let Some(k) = map_.next_key()? {
8279 match k {
8280 GeneratedField::Params => {
8281 if params__.is_some() {
8282 return Err(serde::de::Error::duplicate_field("params"));
8283 }
8284 params__ = map_.next_value()?;
8285 }
8286 }
8287 }
8288 Ok(GetSystemParamsResponse {
8289 params: params__,
8290 })
8291 }
8292 }
8293 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8294 }
8295}
8296impl serde::Serialize for GetTelemetryInfoRequest {
8297 #[allow(deprecated)]
8298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8299 where
8300 S: serde::Serializer,
8301 {
8302 use serde::ser::SerializeStruct;
8303 let len = 0;
8304 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8305 struct_ser.end()
8306 }
8307}
8308impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8309 #[allow(deprecated)]
8310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8311 where
8312 D: serde::Deserializer<'de>,
8313 {
8314 const FIELDS: &[&str] = &[
8315 ];
8316
8317 #[allow(clippy::enum_variant_names)]
8318 enum GeneratedField {
8319 }
8320 impl<'de> serde::Deserialize<'de> for GeneratedField {
8321 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8322 where
8323 D: serde::Deserializer<'de>,
8324 {
8325 struct GeneratedVisitor;
8326
8327 impl serde::de::Visitor<'_> for GeneratedVisitor {
8328 type Value = GeneratedField;
8329
8330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8331 write!(formatter, "expected one of: {:?}", &FIELDS)
8332 }
8333
8334 #[allow(unused_variables)]
8335 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8336 where
8337 E: serde::de::Error,
8338 {
8339 Err(serde::de::Error::unknown_field(value, FIELDS))
8340 }
8341 }
8342 deserializer.deserialize_identifier(GeneratedVisitor)
8343 }
8344 }
8345 struct GeneratedVisitor;
8346 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8347 type Value = GetTelemetryInfoRequest;
8348
8349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8350 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8351 }
8352
8353 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8354 where
8355 V: serde::de::MapAccess<'de>,
8356 {
8357 while map_.next_key::<GeneratedField>()?.is_some() {
8358 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8359 }
8360 Ok(GetTelemetryInfoRequest {
8361 })
8362 }
8363 }
8364 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8365 }
8366}
8367impl serde::Serialize for HeartbeatRequest {
8368 #[allow(deprecated)]
8369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8370 where
8371 S: serde::Serializer,
8372 {
8373 use serde::ser::SerializeStruct;
8374 let mut len = 0;
8375 if self.node_id != 0 {
8376 len += 1;
8377 }
8378 if self.resource.is_some() {
8379 len += 1;
8380 }
8381 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8382 if self.node_id != 0 {
8383 struct_ser.serialize_field("nodeId", &self.node_id)?;
8384 }
8385 if let Some(v) = self.resource.as_ref() {
8386 struct_ser.serialize_field("resource", v)?;
8387 }
8388 struct_ser.end()
8389 }
8390}
8391impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8392 #[allow(deprecated)]
8393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8394 where
8395 D: serde::Deserializer<'de>,
8396 {
8397 const FIELDS: &[&str] = &[
8398 "node_id",
8399 "nodeId",
8400 "resource",
8401 ];
8402
8403 #[allow(clippy::enum_variant_names)]
8404 enum GeneratedField {
8405 NodeId,
8406 Resource,
8407 }
8408 impl<'de> serde::Deserialize<'de> for GeneratedField {
8409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8410 where
8411 D: serde::Deserializer<'de>,
8412 {
8413 struct GeneratedVisitor;
8414
8415 impl serde::de::Visitor<'_> for GeneratedVisitor {
8416 type Value = GeneratedField;
8417
8418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8419 write!(formatter, "expected one of: {:?}", &FIELDS)
8420 }
8421
8422 #[allow(unused_variables)]
8423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8424 where
8425 E: serde::de::Error,
8426 {
8427 match value {
8428 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8429 "resource" => Ok(GeneratedField::Resource),
8430 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8431 }
8432 }
8433 }
8434 deserializer.deserialize_identifier(GeneratedVisitor)
8435 }
8436 }
8437 struct GeneratedVisitor;
8438 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8439 type Value = HeartbeatRequest;
8440
8441 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8442 formatter.write_str("struct meta.HeartbeatRequest")
8443 }
8444
8445 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8446 where
8447 V: serde::de::MapAccess<'de>,
8448 {
8449 let mut node_id__ = None;
8450 let mut resource__ = None;
8451 while let Some(k) = map_.next_key()? {
8452 match k {
8453 GeneratedField::NodeId => {
8454 if node_id__.is_some() {
8455 return Err(serde::de::Error::duplicate_field("nodeId"));
8456 }
8457 node_id__ =
8458 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8459 ;
8460 }
8461 GeneratedField::Resource => {
8462 if resource__.is_some() {
8463 return Err(serde::de::Error::duplicate_field("resource"));
8464 }
8465 resource__ = map_.next_value()?;
8466 }
8467 }
8468 }
8469 Ok(HeartbeatRequest {
8470 node_id: node_id__.unwrap_or_default(),
8471 resource: resource__,
8472 })
8473 }
8474 }
8475 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8476 }
8477}
8478impl serde::Serialize for HeartbeatResponse {
8479 #[allow(deprecated)]
8480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8481 where
8482 S: serde::Serializer,
8483 {
8484 use serde::ser::SerializeStruct;
8485 let mut len = 0;
8486 if self.status.is_some() {
8487 len += 1;
8488 }
8489 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8490 if let Some(v) = self.status.as_ref() {
8491 struct_ser.serialize_field("status", v)?;
8492 }
8493 struct_ser.end()
8494 }
8495}
8496impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8497 #[allow(deprecated)]
8498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8499 where
8500 D: serde::Deserializer<'de>,
8501 {
8502 const FIELDS: &[&str] = &[
8503 "status",
8504 ];
8505
8506 #[allow(clippy::enum_variant_names)]
8507 enum GeneratedField {
8508 Status,
8509 }
8510 impl<'de> serde::Deserialize<'de> for GeneratedField {
8511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8512 where
8513 D: serde::Deserializer<'de>,
8514 {
8515 struct GeneratedVisitor;
8516
8517 impl serde::de::Visitor<'_> for GeneratedVisitor {
8518 type Value = GeneratedField;
8519
8520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8521 write!(formatter, "expected one of: {:?}", &FIELDS)
8522 }
8523
8524 #[allow(unused_variables)]
8525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8526 where
8527 E: serde::de::Error,
8528 {
8529 match value {
8530 "status" => Ok(GeneratedField::Status),
8531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8532 }
8533 }
8534 }
8535 deserializer.deserialize_identifier(GeneratedVisitor)
8536 }
8537 }
8538 struct GeneratedVisitor;
8539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8540 type Value = HeartbeatResponse;
8541
8542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8543 formatter.write_str("struct meta.HeartbeatResponse")
8544 }
8545
8546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8547 where
8548 V: serde::de::MapAccess<'de>,
8549 {
8550 let mut status__ = None;
8551 while let Some(k) = map_.next_key()? {
8552 match k {
8553 GeneratedField::Status => {
8554 if status__.is_some() {
8555 return Err(serde::de::Error::duplicate_field("status"));
8556 }
8557 status__ = map_.next_value()?;
8558 }
8559 }
8560 }
8561 Ok(HeartbeatResponse {
8562 status: status__,
8563 })
8564 }
8565 }
8566 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8567 }
8568}
8569impl serde::Serialize for InjectSourceOffsetsRequest {
8570 #[allow(deprecated)]
8571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8572 where
8573 S: serde::Serializer,
8574 {
8575 use serde::ser::SerializeStruct;
8576 let mut len = 0;
8577 if self.source_id != 0 {
8578 len += 1;
8579 }
8580 if !self.split_offsets.is_empty() {
8581 len += 1;
8582 }
8583 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsRequest", len)?;
8584 if self.source_id != 0 {
8585 struct_ser.serialize_field("sourceId", &self.source_id)?;
8586 }
8587 if !self.split_offsets.is_empty() {
8588 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
8589 }
8590 struct_ser.end()
8591 }
8592}
8593impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsRequest {
8594 #[allow(deprecated)]
8595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8596 where
8597 D: serde::Deserializer<'de>,
8598 {
8599 const FIELDS: &[&str] = &[
8600 "source_id",
8601 "sourceId",
8602 "split_offsets",
8603 "splitOffsets",
8604 ];
8605
8606 #[allow(clippy::enum_variant_names)]
8607 enum GeneratedField {
8608 SourceId,
8609 SplitOffsets,
8610 }
8611 impl<'de> serde::Deserialize<'de> for GeneratedField {
8612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8613 where
8614 D: serde::Deserializer<'de>,
8615 {
8616 struct GeneratedVisitor;
8617
8618 impl serde::de::Visitor<'_> for GeneratedVisitor {
8619 type Value = GeneratedField;
8620
8621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8622 write!(formatter, "expected one of: {:?}", &FIELDS)
8623 }
8624
8625 #[allow(unused_variables)]
8626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8627 where
8628 E: serde::de::Error,
8629 {
8630 match value {
8631 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8632 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
8633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8634 }
8635 }
8636 }
8637 deserializer.deserialize_identifier(GeneratedVisitor)
8638 }
8639 }
8640 struct GeneratedVisitor;
8641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8642 type Value = InjectSourceOffsetsRequest;
8643
8644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8645 formatter.write_str("struct meta.InjectSourceOffsetsRequest")
8646 }
8647
8648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsRequest, V::Error>
8649 where
8650 V: serde::de::MapAccess<'de>,
8651 {
8652 let mut source_id__ = None;
8653 let mut split_offsets__ = None;
8654 while let Some(k) = map_.next_key()? {
8655 match k {
8656 GeneratedField::SourceId => {
8657 if source_id__.is_some() {
8658 return Err(serde::de::Error::duplicate_field("sourceId"));
8659 }
8660 source_id__ =
8661 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8662 ;
8663 }
8664 GeneratedField::SplitOffsets => {
8665 if split_offsets__.is_some() {
8666 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8667 }
8668 split_offsets__ = Some(
8669 map_.next_value::<std::collections::HashMap<_, _>>()?
8670 );
8671 }
8672 }
8673 }
8674 Ok(InjectSourceOffsetsRequest {
8675 source_id: source_id__.unwrap_or_default(),
8676 split_offsets: split_offsets__.unwrap_or_default(),
8677 })
8678 }
8679 }
8680 deserializer.deserialize_struct("meta.InjectSourceOffsetsRequest", FIELDS, GeneratedVisitor)
8681 }
8682}
8683impl serde::Serialize for InjectSourceOffsetsResponse {
8684 #[allow(deprecated)]
8685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8686 where
8687 S: serde::Serializer,
8688 {
8689 use serde::ser::SerializeStruct;
8690 let mut len = 0;
8691 if !self.applied_split_ids.is_empty() {
8692 len += 1;
8693 }
8694 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsResponse", len)?;
8695 if !self.applied_split_ids.is_empty() {
8696 struct_ser.serialize_field("appliedSplitIds", &self.applied_split_ids)?;
8697 }
8698 struct_ser.end()
8699 }
8700}
8701impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsResponse {
8702 #[allow(deprecated)]
8703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8704 where
8705 D: serde::Deserializer<'de>,
8706 {
8707 const FIELDS: &[&str] = &[
8708 "applied_split_ids",
8709 "appliedSplitIds",
8710 ];
8711
8712 #[allow(clippy::enum_variant_names)]
8713 enum GeneratedField {
8714 AppliedSplitIds,
8715 }
8716 impl<'de> serde::Deserialize<'de> for GeneratedField {
8717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8718 where
8719 D: serde::Deserializer<'de>,
8720 {
8721 struct GeneratedVisitor;
8722
8723 impl serde::de::Visitor<'_> for GeneratedVisitor {
8724 type Value = GeneratedField;
8725
8726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8727 write!(formatter, "expected one of: {:?}", &FIELDS)
8728 }
8729
8730 #[allow(unused_variables)]
8731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8732 where
8733 E: serde::de::Error,
8734 {
8735 match value {
8736 "appliedSplitIds" | "applied_split_ids" => Ok(GeneratedField::AppliedSplitIds),
8737 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8738 }
8739 }
8740 }
8741 deserializer.deserialize_identifier(GeneratedVisitor)
8742 }
8743 }
8744 struct GeneratedVisitor;
8745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8746 type Value = InjectSourceOffsetsResponse;
8747
8748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8749 formatter.write_str("struct meta.InjectSourceOffsetsResponse")
8750 }
8751
8752 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsResponse, V::Error>
8753 where
8754 V: serde::de::MapAccess<'de>,
8755 {
8756 let mut applied_split_ids__ = None;
8757 while let Some(k) = map_.next_key()? {
8758 match k {
8759 GeneratedField::AppliedSplitIds => {
8760 if applied_split_ids__.is_some() {
8761 return Err(serde::de::Error::duplicate_field("appliedSplitIds"));
8762 }
8763 applied_split_ids__ = Some(map_.next_value()?);
8764 }
8765 }
8766 }
8767 Ok(InjectSourceOffsetsResponse {
8768 applied_split_ids: applied_split_ids__.unwrap_or_default(),
8769 })
8770 }
8771 }
8772 deserializer.deserialize_struct("meta.InjectSourceOffsetsResponse", FIELDS, GeneratedVisitor)
8773 }
8774}
8775impl serde::Serialize for ListActorSplitsRequest {
8776 #[allow(deprecated)]
8777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8778 where
8779 S: serde::Serializer,
8780 {
8781 use serde::ser::SerializeStruct;
8782 let len = 0;
8783 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8784 struct_ser.end()
8785 }
8786}
8787impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8788 #[allow(deprecated)]
8789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8790 where
8791 D: serde::Deserializer<'de>,
8792 {
8793 const FIELDS: &[&str] = &[
8794 ];
8795
8796 #[allow(clippy::enum_variant_names)]
8797 enum GeneratedField {
8798 }
8799 impl<'de> serde::Deserialize<'de> for GeneratedField {
8800 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8801 where
8802 D: serde::Deserializer<'de>,
8803 {
8804 struct GeneratedVisitor;
8805
8806 impl serde::de::Visitor<'_> for GeneratedVisitor {
8807 type Value = GeneratedField;
8808
8809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8810 write!(formatter, "expected one of: {:?}", &FIELDS)
8811 }
8812
8813 #[allow(unused_variables)]
8814 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8815 where
8816 E: serde::de::Error,
8817 {
8818 Err(serde::de::Error::unknown_field(value, FIELDS))
8819 }
8820 }
8821 deserializer.deserialize_identifier(GeneratedVisitor)
8822 }
8823 }
8824 struct GeneratedVisitor;
8825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8826 type Value = ListActorSplitsRequest;
8827
8828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8829 formatter.write_str("struct meta.ListActorSplitsRequest")
8830 }
8831
8832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8833 where
8834 V: serde::de::MapAccess<'de>,
8835 {
8836 while map_.next_key::<GeneratedField>()?.is_some() {
8837 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8838 }
8839 Ok(ListActorSplitsRequest {
8840 })
8841 }
8842 }
8843 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
8844 }
8845}
8846impl serde::Serialize for ListActorSplitsResponse {
8847 #[allow(deprecated)]
8848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8849 where
8850 S: serde::Serializer,
8851 {
8852 use serde::ser::SerializeStruct;
8853 let mut len = 0;
8854 if !self.actor_splits.is_empty() {
8855 len += 1;
8856 }
8857 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
8858 if !self.actor_splits.is_empty() {
8859 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
8860 }
8861 struct_ser.end()
8862 }
8863}
8864impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
8865 #[allow(deprecated)]
8866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8867 where
8868 D: serde::Deserializer<'de>,
8869 {
8870 const FIELDS: &[&str] = &[
8871 "actor_splits",
8872 "actorSplits",
8873 ];
8874
8875 #[allow(clippy::enum_variant_names)]
8876 enum GeneratedField {
8877 ActorSplits,
8878 }
8879 impl<'de> serde::Deserialize<'de> for GeneratedField {
8880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8881 where
8882 D: serde::Deserializer<'de>,
8883 {
8884 struct GeneratedVisitor;
8885
8886 impl serde::de::Visitor<'_> for GeneratedVisitor {
8887 type Value = GeneratedField;
8888
8889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8890 write!(formatter, "expected one of: {:?}", &FIELDS)
8891 }
8892
8893 #[allow(unused_variables)]
8894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8895 where
8896 E: serde::de::Error,
8897 {
8898 match value {
8899 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
8900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8901 }
8902 }
8903 }
8904 deserializer.deserialize_identifier(GeneratedVisitor)
8905 }
8906 }
8907 struct GeneratedVisitor;
8908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8909 type Value = ListActorSplitsResponse;
8910
8911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8912 formatter.write_str("struct meta.ListActorSplitsResponse")
8913 }
8914
8915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
8916 where
8917 V: serde::de::MapAccess<'de>,
8918 {
8919 let mut actor_splits__ = None;
8920 while let Some(k) = map_.next_key()? {
8921 match k {
8922 GeneratedField::ActorSplits => {
8923 if actor_splits__.is_some() {
8924 return Err(serde::de::Error::duplicate_field("actorSplits"));
8925 }
8926 actor_splits__ = Some(map_.next_value()?);
8927 }
8928 }
8929 }
8930 Ok(ListActorSplitsResponse {
8931 actor_splits: actor_splits__.unwrap_or_default(),
8932 })
8933 }
8934 }
8935 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
8936 }
8937}
8938impl serde::Serialize for list_actor_splits_response::ActorSplit {
8939 #[allow(deprecated)]
8940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8941 where
8942 S: serde::Serializer,
8943 {
8944 use serde::ser::SerializeStruct;
8945 let mut len = 0;
8946 if self.actor_id != 0 {
8947 len += 1;
8948 }
8949 if self.fragment_id != 0 {
8950 len += 1;
8951 }
8952 if self.source_id != 0 {
8953 len += 1;
8954 }
8955 if !self.split_id.is_empty() {
8956 len += 1;
8957 }
8958 if self.fragment_type != 0 {
8959 len += 1;
8960 }
8961 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
8962 if self.actor_id != 0 {
8963 struct_ser.serialize_field("actorId", &self.actor_id)?;
8964 }
8965 if self.fragment_id != 0 {
8966 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8967 }
8968 if self.source_id != 0 {
8969 struct_ser.serialize_field("sourceId", &self.source_id)?;
8970 }
8971 if !self.split_id.is_empty() {
8972 struct_ser.serialize_field("splitId", &self.split_id)?;
8973 }
8974 if self.fragment_type != 0 {
8975 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
8976 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8977 struct_ser.serialize_field("fragmentType", &v)?;
8978 }
8979 struct_ser.end()
8980 }
8981}
8982impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8983 #[allow(deprecated)]
8984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8985 where
8986 D: serde::Deserializer<'de>,
8987 {
8988 const FIELDS: &[&str] = &[
8989 "actor_id",
8990 "actorId",
8991 "fragment_id",
8992 "fragmentId",
8993 "source_id",
8994 "sourceId",
8995 "split_id",
8996 "splitId",
8997 "fragment_type",
8998 "fragmentType",
8999 ];
9000
9001 #[allow(clippy::enum_variant_names)]
9002 enum GeneratedField {
9003 ActorId,
9004 FragmentId,
9005 SourceId,
9006 SplitId,
9007 FragmentType,
9008 }
9009 impl<'de> serde::Deserialize<'de> for GeneratedField {
9010 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9011 where
9012 D: serde::Deserializer<'de>,
9013 {
9014 struct GeneratedVisitor;
9015
9016 impl serde::de::Visitor<'_> for GeneratedVisitor {
9017 type Value = GeneratedField;
9018
9019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9020 write!(formatter, "expected one of: {:?}", &FIELDS)
9021 }
9022
9023 #[allow(unused_variables)]
9024 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9025 where
9026 E: serde::de::Error,
9027 {
9028 match value {
9029 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9030 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9031 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9032 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
9033 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
9034 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9035 }
9036 }
9037 }
9038 deserializer.deserialize_identifier(GeneratedVisitor)
9039 }
9040 }
9041 struct GeneratedVisitor;
9042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9043 type Value = list_actor_splits_response::ActorSplit;
9044
9045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9046 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
9047 }
9048
9049 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
9050 where
9051 V: serde::de::MapAccess<'de>,
9052 {
9053 let mut actor_id__ = None;
9054 let mut fragment_id__ = None;
9055 let mut source_id__ = None;
9056 let mut split_id__ = None;
9057 let mut fragment_type__ = None;
9058 while let Some(k) = map_.next_key()? {
9059 match k {
9060 GeneratedField::ActorId => {
9061 if actor_id__.is_some() {
9062 return Err(serde::de::Error::duplicate_field("actorId"));
9063 }
9064 actor_id__ =
9065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9066 ;
9067 }
9068 GeneratedField::FragmentId => {
9069 if fragment_id__.is_some() {
9070 return Err(serde::de::Error::duplicate_field("fragmentId"));
9071 }
9072 fragment_id__ =
9073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9074 ;
9075 }
9076 GeneratedField::SourceId => {
9077 if source_id__.is_some() {
9078 return Err(serde::de::Error::duplicate_field("sourceId"));
9079 }
9080 source_id__ =
9081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9082 ;
9083 }
9084 GeneratedField::SplitId => {
9085 if split_id__.is_some() {
9086 return Err(serde::de::Error::duplicate_field("splitId"));
9087 }
9088 split_id__ = Some(map_.next_value()?);
9089 }
9090 GeneratedField::FragmentType => {
9091 if fragment_type__.is_some() {
9092 return Err(serde::de::Error::duplicate_field("fragmentType"));
9093 }
9094 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
9095 }
9096 }
9097 }
9098 Ok(list_actor_splits_response::ActorSplit {
9099 actor_id: actor_id__.unwrap_or_default(),
9100 fragment_id: fragment_id__.unwrap_or_default(),
9101 source_id: source_id__.unwrap_or_default(),
9102 split_id: split_id__.unwrap_or_default(),
9103 fragment_type: fragment_type__.unwrap_or_default(),
9104 })
9105 }
9106 }
9107 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
9108 }
9109}
9110impl serde::Serialize for list_actor_splits_response::FragmentType {
9111 #[allow(deprecated)]
9112 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9113 where
9114 S: serde::Serializer,
9115 {
9116 let variant = match self {
9117 Self::Unspecified => "UNSPECIFIED",
9118 Self::NonSharedSource => "NON_SHARED_SOURCE",
9119 Self::SharedSource => "SHARED_SOURCE",
9120 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
9121 };
9122 serializer.serialize_str(variant)
9123 }
9124}
9125impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
9126 #[allow(deprecated)]
9127 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9128 where
9129 D: serde::Deserializer<'de>,
9130 {
9131 const FIELDS: &[&str] = &[
9132 "UNSPECIFIED",
9133 "NON_SHARED_SOURCE",
9134 "SHARED_SOURCE",
9135 "SHARED_SOURCE_BACKFILL",
9136 ];
9137
9138 struct GeneratedVisitor;
9139
9140 impl serde::de::Visitor<'_> for GeneratedVisitor {
9141 type Value = list_actor_splits_response::FragmentType;
9142
9143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9144 write!(formatter, "expected one of: {:?}", &FIELDS)
9145 }
9146
9147 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9148 where
9149 E: serde::de::Error,
9150 {
9151 i32::try_from(v)
9152 .ok()
9153 .and_then(|x| x.try_into().ok())
9154 .ok_or_else(|| {
9155 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9156 })
9157 }
9158
9159 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9160 where
9161 E: serde::de::Error,
9162 {
9163 i32::try_from(v)
9164 .ok()
9165 .and_then(|x| x.try_into().ok())
9166 .ok_or_else(|| {
9167 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9168 })
9169 }
9170
9171 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9172 where
9173 E: serde::de::Error,
9174 {
9175 match value {
9176 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
9177 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
9178 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
9179 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
9180 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9181 }
9182 }
9183 }
9184 deserializer.deserialize_any(GeneratedVisitor)
9185 }
9186}
9187impl serde::Serialize for ListActorStatesRequest {
9188 #[allow(deprecated)]
9189 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9190 where
9191 S: serde::Serializer,
9192 {
9193 use serde::ser::SerializeStruct;
9194 let len = 0;
9195 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
9196 struct_ser.end()
9197 }
9198}
9199impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
9200 #[allow(deprecated)]
9201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9202 where
9203 D: serde::Deserializer<'de>,
9204 {
9205 const FIELDS: &[&str] = &[
9206 ];
9207
9208 #[allow(clippy::enum_variant_names)]
9209 enum GeneratedField {
9210 }
9211 impl<'de> serde::Deserialize<'de> for GeneratedField {
9212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9213 where
9214 D: serde::Deserializer<'de>,
9215 {
9216 struct GeneratedVisitor;
9217
9218 impl serde::de::Visitor<'_> for GeneratedVisitor {
9219 type Value = GeneratedField;
9220
9221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9222 write!(formatter, "expected one of: {:?}", &FIELDS)
9223 }
9224
9225 #[allow(unused_variables)]
9226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9227 where
9228 E: serde::de::Error,
9229 {
9230 Err(serde::de::Error::unknown_field(value, FIELDS))
9231 }
9232 }
9233 deserializer.deserialize_identifier(GeneratedVisitor)
9234 }
9235 }
9236 struct GeneratedVisitor;
9237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9238 type Value = ListActorStatesRequest;
9239
9240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9241 formatter.write_str("struct meta.ListActorStatesRequest")
9242 }
9243
9244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
9245 where
9246 V: serde::de::MapAccess<'de>,
9247 {
9248 while map_.next_key::<GeneratedField>()?.is_some() {
9249 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9250 }
9251 Ok(ListActorStatesRequest {
9252 })
9253 }
9254 }
9255 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
9256 }
9257}
9258impl serde::Serialize for ListActorStatesResponse {
9259 #[allow(deprecated)]
9260 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9261 where
9262 S: serde::Serializer,
9263 {
9264 use serde::ser::SerializeStruct;
9265 let mut len = 0;
9266 if !self.states.is_empty() {
9267 len += 1;
9268 }
9269 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
9270 if !self.states.is_empty() {
9271 struct_ser.serialize_field("states", &self.states)?;
9272 }
9273 struct_ser.end()
9274 }
9275}
9276impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
9277 #[allow(deprecated)]
9278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9279 where
9280 D: serde::Deserializer<'de>,
9281 {
9282 const FIELDS: &[&str] = &[
9283 "states",
9284 ];
9285
9286 #[allow(clippy::enum_variant_names)]
9287 enum GeneratedField {
9288 States,
9289 }
9290 impl<'de> serde::Deserialize<'de> for GeneratedField {
9291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9292 where
9293 D: serde::Deserializer<'de>,
9294 {
9295 struct GeneratedVisitor;
9296
9297 impl serde::de::Visitor<'_> for GeneratedVisitor {
9298 type Value = GeneratedField;
9299
9300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9301 write!(formatter, "expected one of: {:?}", &FIELDS)
9302 }
9303
9304 #[allow(unused_variables)]
9305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9306 where
9307 E: serde::de::Error,
9308 {
9309 match value {
9310 "states" => Ok(GeneratedField::States),
9311 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9312 }
9313 }
9314 }
9315 deserializer.deserialize_identifier(GeneratedVisitor)
9316 }
9317 }
9318 struct GeneratedVisitor;
9319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9320 type Value = ListActorStatesResponse;
9321
9322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9323 formatter.write_str("struct meta.ListActorStatesResponse")
9324 }
9325
9326 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
9327 where
9328 V: serde::de::MapAccess<'de>,
9329 {
9330 let mut states__ = None;
9331 while let Some(k) = map_.next_key()? {
9332 match k {
9333 GeneratedField::States => {
9334 if states__.is_some() {
9335 return Err(serde::de::Error::duplicate_field("states"));
9336 }
9337 states__ = Some(map_.next_value()?);
9338 }
9339 }
9340 }
9341 Ok(ListActorStatesResponse {
9342 states: states__.unwrap_or_default(),
9343 })
9344 }
9345 }
9346 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
9347 }
9348}
9349impl serde::Serialize for list_actor_states_response::ActorState {
9350 #[allow(deprecated)]
9351 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9352 where
9353 S: serde::Serializer,
9354 {
9355 use serde::ser::SerializeStruct;
9356 let mut len = 0;
9357 if self.actor_id != 0 {
9358 len += 1;
9359 }
9360 if self.fragment_id != 0 {
9361 len += 1;
9362 }
9363 if self.worker_id != 0 {
9364 len += 1;
9365 }
9366 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
9367 if self.actor_id != 0 {
9368 struct_ser.serialize_field("actorId", &self.actor_id)?;
9369 }
9370 if self.fragment_id != 0 {
9371 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9372 }
9373 if self.worker_id != 0 {
9374 struct_ser.serialize_field("workerId", &self.worker_id)?;
9375 }
9376 struct_ser.end()
9377 }
9378}
9379impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
9380 #[allow(deprecated)]
9381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9382 where
9383 D: serde::Deserializer<'de>,
9384 {
9385 const FIELDS: &[&str] = &[
9386 "actor_id",
9387 "actorId",
9388 "fragment_id",
9389 "fragmentId",
9390 "worker_id",
9391 "workerId",
9392 ];
9393
9394 #[allow(clippy::enum_variant_names)]
9395 enum GeneratedField {
9396 ActorId,
9397 FragmentId,
9398 WorkerId,
9399 }
9400 impl<'de> serde::Deserialize<'de> for GeneratedField {
9401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9402 where
9403 D: serde::Deserializer<'de>,
9404 {
9405 struct GeneratedVisitor;
9406
9407 impl serde::de::Visitor<'_> for GeneratedVisitor {
9408 type Value = GeneratedField;
9409
9410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9411 write!(formatter, "expected one of: {:?}", &FIELDS)
9412 }
9413
9414 #[allow(unused_variables)]
9415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9416 where
9417 E: serde::de::Error,
9418 {
9419 match value {
9420 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9421 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9422 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
9423 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9424 }
9425 }
9426 }
9427 deserializer.deserialize_identifier(GeneratedVisitor)
9428 }
9429 }
9430 struct GeneratedVisitor;
9431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9432 type Value = list_actor_states_response::ActorState;
9433
9434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9435 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
9436 }
9437
9438 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
9439 where
9440 V: serde::de::MapAccess<'de>,
9441 {
9442 let mut actor_id__ = None;
9443 let mut fragment_id__ = None;
9444 let mut worker_id__ = None;
9445 while let Some(k) = map_.next_key()? {
9446 match k {
9447 GeneratedField::ActorId => {
9448 if actor_id__.is_some() {
9449 return Err(serde::de::Error::duplicate_field("actorId"));
9450 }
9451 actor_id__ =
9452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9453 ;
9454 }
9455 GeneratedField::FragmentId => {
9456 if fragment_id__.is_some() {
9457 return Err(serde::de::Error::duplicate_field("fragmentId"));
9458 }
9459 fragment_id__ =
9460 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9461 ;
9462 }
9463 GeneratedField::WorkerId => {
9464 if worker_id__.is_some() {
9465 return Err(serde::de::Error::duplicate_field("workerId"));
9466 }
9467 worker_id__ =
9468 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9469 ;
9470 }
9471 }
9472 }
9473 Ok(list_actor_states_response::ActorState {
9474 actor_id: actor_id__.unwrap_or_default(),
9475 fragment_id: fragment_id__.unwrap_or_default(),
9476 worker_id: worker_id__.unwrap_or_default(),
9477 })
9478 }
9479 }
9480 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
9481 }
9482}
9483impl serde::Serialize for ListAllNodesRequest {
9484 #[allow(deprecated)]
9485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9486 where
9487 S: serde::Serializer,
9488 {
9489 use serde::ser::SerializeStruct;
9490 let mut len = 0;
9491 if self.worker_type.is_some() {
9492 len += 1;
9493 }
9494 if self.include_starting_nodes {
9495 len += 1;
9496 }
9497 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9498 if let Some(v) = self.worker_type.as_ref() {
9499 let v = super::common::WorkerType::try_from(*v)
9500 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9501 struct_ser.serialize_field("workerType", &v)?;
9502 }
9503 if self.include_starting_nodes {
9504 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9505 }
9506 struct_ser.end()
9507 }
9508}
9509impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9510 #[allow(deprecated)]
9511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9512 where
9513 D: serde::Deserializer<'de>,
9514 {
9515 const FIELDS: &[&str] = &[
9516 "worker_type",
9517 "workerType",
9518 "include_starting_nodes",
9519 "includeStartingNodes",
9520 ];
9521
9522 #[allow(clippy::enum_variant_names)]
9523 enum GeneratedField {
9524 WorkerType,
9525 IncludeStartingNodes,
9526 }
9527 impl<'de> serde::Deserialize<'de> for GeneratedField {
9528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9529 where
9530 D: serde::Deserializer<'de>,
9531 {
9532 struct GeneratedVisitor;
9533
9534 impl serde::de::Visitor<'_> for GeneratedVisitor {
9535 type Value = GeneratedField;
9536
9537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9538 write!(formatter, "expected one of: {:?}", &FIELDS)
9539 }
9540
9541 #[allow(unused_variables)]
9542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9543 where
9544 E: serde::de::Error,
9545 {
9546 match value {
9547 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9548 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9550 }
9551 }
9552 }
9553 deserializer.deserialize_identifier(GeneratedVisitor)
9554 }
9555 }
9556 struct GeneratedVisitor;
9557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9558 type Value = ListAllNodesRequest;
9559
9560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9561 formatter.write_str("struct meta.ListAllNodesRequest")
9562 }
9563
9564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9565 where
9566 V: serde::de::MapAccess<'de>,
9567 {
9568 let mut worker_type__ = None;
9569 let mut include_starting_nodes__ = None;
9570 while let Some(k) = map_.next_key()? {
9571 match k {
9572 GeneratedField::WorkerType => {
9573 if worker_type__.is_some() {
9574 return Err(serde::de::Error::duplicate_field("workerType"));
9575 }
9576 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9577 }
9578 GeneratedField::IncludeStartingNodes => {
9579 if include_starting_nodes__.is_some() {
9580 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9581 }
9582 include_starting_nodes__ = Some(map_.next_value()?);
9583 }
9584 }
9585 }
9586 Ok(ListAllNodesRequest {
9587 worker_type: worker_type__,
9588 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9589 })
9590 }
9591 }
9592 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9593 }
9594}
9595impl serde::Serialize for ListAllNodesResponse {
9596 #[allow(deprecated)]
9597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9598 where
9599 S: serde::Serializer,
9600 {
9601 use serde::ser::SerializeStruct;
9602 let mut len = 0;
9603 if self.status.is_some() {
9604 len += 1;
9605 }
9606 if !self.nodes.is_empty() {
9607 len += 1;
9608 }
9609 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9610 if let Some(v) = self.status.as_ref() {
9611 struct_ser.serialize_field("status", v)?;
9612 }
9613 if !self.nodes.is_empty() {
9614 struct_ser.serialize_field("nodes", &self.nodes)?;
9615 }
9616 struct_ser.end()
9617 }
9618}
9619impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9620 #[allow(deprecated)]
9621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622 where
9623 D: serde::Deserializer<'de>,
9624 {
9625 const FIELDS: &[&str] = &[
9626 "status",
9627 "nodes",
9628 ];
9629
9630 #[allow(clippy::enum_variant_names)]
9631 enum GeneratedField {
9632 Status,
9633 Nodes,
9634 }
9635 impl<'de> serde::Deserialize<'de> for GeneratedField {
9636 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9637 where
9638 D: serde::Deserializer<'de>,
9639 {
9640 struct GeneratedVisitor;
9641
9642 impl serde::de::Visitor<'_> for GeneratedVisitor {
9643 type Value = GeneratedField;
9644
9645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9646 write!(formatter, "expected one of: {:?}", &FIELDS)
9647 }
9648
9649 #[allow(unused_variables)]
9650 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9651 where
9652 E: serde::de::Error,
9653 {
9654 match value {
9655 "status" => Ok(GeneratedField::Status),
9656 "nodes" => Ok(GeneratedField::Nodes),
9657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9658 }
9659 }
9660 }
9661 deserializer.deserialize_identifier(GeneratedVisitor)
9662 }
9663 }
9664 struct GeneratedVisitor;
9665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9666 type Value = ListAllNodesResponse;
9667
9668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9669 formatter.write_str("struct meta.ListAllNodesResponse")
9670 }
9671
9672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9673 where
9674 V: serde::de::MapAccess<'de>,
9675 {
9676 let mut status__ = None;
9677 let mut nodes__ = None;
9678 while let Some(k) = map_.next_key()? {
9679 match k {
9680 GeneratedField::Status => {
9681 if status__.is_some() {
9682 return Err(serde::de::Error::duplicate_field("status"));
9683 }
9684 status__ = map_.next_value()?;
9685 }
9686 GeneratedField::Nodes => {
9687 if nodes__.is_some() {
9688 return Err(serde::de::Error::duplicate_field("nodes"));
9689 }
9690 nodes__ = Some(map_.next_value()?);
9691 }
9692 }
9693 }
9694 Ok(ListAllNodesResponse {
9695 status: status__,
9696 nodes: nodes__.unwrap_or_default(),
9697 })
9698 }
9699 }
9700 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9701 }
9702}
9703impl serde::Serialize for ListCdcProgressRequest {
9704 #[allow(deprecated)]
9705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9706 where
9707 S: serde::Serializer,
9708 {
9709 use serde::ser::SerializeStruct;
9710 let len = 0;
9711 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9712 struct_ser.end()
9713 }
9714}
9715impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9716 #[allow(deprecated)]
9717 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9718 where
9719 D: serde::Deserializer<'de>,
9720 {
9721 const FIELDS: &[&str] = &[
9722 ];
9723
9724 #[allow(clippy::enum_variant_names)]
9725 enum GeneratedField {
9726 }
9727 impl<'de> serde::Deserialize<'de> for GeneratedField {
9728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9729 where
9730 D: serde::Deserializer<'de>,
9731 {
9732 struct GeneratedVisitor;
9733
9734 impl serde::de::Visitor<'_> for GeneratedVisitor {
9735 type Value = GeneratedField;
9736
9737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9738 write!(formatter, "expected one of: {:?}", &FIELDS)
9739 }
9740
9741 #[allow(unused_variables)]
9742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9743 where
9744 E: serde::de::Error,
9745 {
9746 Err(serde::de::Error::unknown_field(value, FIELDS))
9747 }
9748 }
9749 deserializer.deserialize_identifier(GeneratedVisitor)
9750 }
9751 }
9752 struct GeneratedVisitor;
9753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9754 type Value = ListCdcProgressRequest;
9755
9756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9757 formatter.write_str("struct meta.ListCdcProgressRequest")
9758 }
9759
9760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9761 where
9762 V: serde::de::MapAccess<'de>,
9763 {
9764 while map_.next_key::<GeneratedField>()?.is_some() {
9765 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9766 }
9767 Ok(ListCdcProgressRequest {
9768 })
9769 }
9770 }
9771 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9772 }
9773}
9774impl serde::Serialize for ListCdcProgressResponse {
9775 #[allow(deprecated)]
9776 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9777 where
9778 S: serde::Serializer,
9779 {
9780 use serde::ser::SerializeStruct;
9781 let mut len = 0;
9782 if !self.cdc_progress.is_empty() {
9783 len += 1;
9784 }
9785 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9786 if !self.cdc_progress.is_empty() {
9787 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9788 }
9789 struct_ser.end()
9790 }
9791}
9792impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9793 #[allow(deprecated)]
9794 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9795 where
9796 D: serde::Deserializer<'de>,
9797 {
9798 const FIELDS: &[&str] = &[
9799 "cdc_progress",
9800 "cdcProgress",
9801 ];
9802
9803 #[allow(clippy::enum_variant_names)]
9804 enum GeneratedField {
9805 CdcProgress,
9806 }
9807 impl<'de> serde::Deserialize<'de> for GeneratedField {
9808 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9809 where
9810 D: serde::Deserializer<'de>,
9811 {
9812 struct GeneratedVisitor;
9813
9814 impl serde::de::Visitor<'_> for GeneratedVisitor {
9815 type Value = GeneratedField;
9816
9817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9818 write!(formatter, "expected one of: {:?}", &FIELDS)
9819 }
9820
9821 #[allow(unused_variables)]
9822 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9823 where
9824 E: serde::de::Error,
9825 {
9826 match value {
9827 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9829 }
9830 }
9831 }
9832 deserializer.deserialize_identifier(GeneratedVisitor)
9833 }
9834 }
9835 struct GeneratedVisitor;
9836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9837 type Value = ListCdcProgressResponse;
9838
9839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9840 formatter.write_str("struct meta.ListCdcProgressResponse")
9841 }
9842
9843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
9844 where
9845 V: serde::de::MapAccess<'de>,
9846 {
9847 let mut cdc_progress__ = None;
9848 while let Some(k) = map_.next_key()? {
9849 match k {
9850 GeneratedField::CdcProgress => {
9851 if cdc_progress__.is_some() {
9852 return Err(serde::de::Error::duplicate_field("cdcProgress"));
9853 }
9854 cdc_progress__ = Some(
9855 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9856 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9857 );
9858 }
9859 }
9860 }
9861 Ok(ListCdcProgressResponse {
9862 cdc_progress: cdc_progress__.unwrap_or_default(),
9863 })
9864 }
9865 }
9866 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
9867 }
9868}
9869impl serde::Serialize for list_cdc_progress_response::CdcProgress {
9870 #[allow(deprecated)]
9871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9872 where
9873 S: serde::Serializer,
9874 {
9875 use serde::ser::SerializeStruct;
9876 let mut len = 0;
9877 if self.split_total_count != 0 {
9878 len += 1;
9879 }
9880 if self.split_backfilled_count != 0 {
9881 len += 1;
9882 }
9883 if self.split_completed_count != 0 {
9884 len += 1;
9885 }
9886 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
9887 if self.split_total_count != 0 {
9888 #[allow(clippy::needless_borrow)]
9889 #[allow(clippy::needless_borrows_for_generic_args)]
9890 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
9891 }
9892 if self.split_backfilled_count != 0 {
9893 #[allow(clippy::needless_borrow)]
9894 #[allow(clippy::needless_borrows_for_generic_args)]
9895 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
9896 }
9897 if self.split_completed_count != 0 {
9898 #[allow(clippy::needless_borrow)]
9899 #[allow(clippy::needless_borrows_for_generic_args)]
9900 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
9901 }
9902 struct_ser.end()
9903 }
9904}
9905impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
9906 #[allow(deprecated)]
9907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9908 where
9909 D: serde::Deserializer<'de>,
9910 {
9911 const FIELDS: &[&str] = &[
9912 "split_total_count",
9913 "splitTotalCount",
9914 "split_backfilled_count",
9915 "splitBackfilledCount",
9916 "split_completed_count",
9917 "splitCompletedCount",
9918 ];
9919
9920 #[allow(clippy::enum_variant_names)]
9921 enum GeneratedField {
9922 SplitTotalCount,
9923 SplitBackfilledCount,
9924 SplitCompletedCount,
9925 }
9926 impl<'de> serde::Deserialize<'de> for GeneratedField {
9927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9928 where
9929 D: serde::Deserializer<'de>,
9930 {
9931 struct GeneratedVisitor;
9932
9933 impl serde::de::Visitor<'_> for GeneratedVisitor {
9934 type Value = GeneratedField;
9935
9936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9937 write!(formatter, "expected one of: {:?}", &FIELDS)
9938 }
9939
9940 #[allow(unused_variables)]
9941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9942 where
9943 E: serde::de::Error,
9944 {
9945 match value {
9946 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
9947 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
9948 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
9949 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9950 }
9951 }
9952 }
9953 deserializer.deserialize_identifier(GeneratedVisitor)
9954 }
9955 }
9956 struct GeneratedVisitor;
9957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9958 type Value = list_cdc_progress_response::CdcProgress;
9959
9960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9961 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
9962 }
9963
9964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
9965 where
9966 V: serde::de::MapAccess<'de>,
9967 {
9968 let mut split_total_count__ = None;
9969 let mut split_backfilled_count__ = None;
9970 let mut split_completed_count__ = None;
9971 while let Some(k) = map_.next_key()? {
9972 match k {
9973 GeneratedField::SplitTotalCount => {
9974 if split_total_count__.is_some() {
9975 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9976 }
9977 split_total_count__ =
9978 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9979 ;
9980 }
9981 GeneratedField::SplitBackfilledCount => {
9982 if split_backfilled_count__.is_some() {
9983 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9984 }
9985 split_backfilled_count__ =
9986 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9987 ;
9988 }
9989 GeneratedField::SplitCompletedCount => {
9990 if split_completed_count__.is_some() {
9991 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9992 }
9993 split_completed_count__ =
9994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9995 ;
9996 }
9997 }
9998 }
9999 Ok(list_cdc_progress_response::CdcProgress {
10000 split_total_count: split_total_count__.unwrap_or_default(),
10001 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
10002 split_completed_count: split_completed_count__.unwrap_or_default(),
10003 })
10004 }
10005 }
10006 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
10007 }
10008}
10009impl serde::Serialize for ListCreatingFragmentDistributionRequest {
10010 #[allow(deprecated)]
10011 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10012 where
10013 S: serde::Serializer,
10014 {
10015 use serde::ser::SerializeStruct;
10016 let mut len = 0;
10017 if self.include_node.is_some() {
10018 len += 1;
10019 }
10020 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
10021 if let Some(v) = self.include_node.as_ref() {
10022 struct_ser.serialize_field("includeNode", v)?;
10023 }
10024 struct_ser.end()
10025 }
10026}
10027impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
10028 #[allow(deprecated)]
10029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10030 where
10031 D: serde::Deserializer<'de>,
10032 {
10033 const FIELDS: &[&str] = &[
10034 "include_node",
10035 "includeNode",
10036 ];
10037
10038 #[allow(clippy::enum_variant_names)]
10039 enum GeneratedField {
10040 IncludeNode,
10041 }
10042 impl<'de> serde::Deserialize<'de> for GeneratedField {
10043 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10044 where
10045 D: serde::Deserializer<'de>,
10046 {
10047 struct GeneratedVisitor;
10048
10049 impl serde::de::Visitor<'_> for GeneratedVisitor {
10050 type Value = GeneratedField;
10051
10052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10053 write!(formatter, "expected one of: {:?}", &FIELDS)
10054 }
10055
10056 #[allow(unused_variables)]
10057 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10058 where
10059 E: serde::de::Error,
10060 {
10061 match value {
10062 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10064 }
10065 }
10066 }
10067 deserializer.deserialize_identifier(GeneratedVisitor)
10068 }
10069 }
10070 struct GeneratedVisitor;
10071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10072 type Value = ListCreatingFragmentDistributionRequest;
10073
10074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10075 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
10076 }
10077
10078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
10079 where
10080 V: serde::de::MapAccess<'de>,
10081 {
10082 let mut include_node__ = None;
10083 while let Some(k) = map_.next_key()? {
10084 match k {
10085 GeneratedField::IncludeNode => {
10086 if include_node__.is_some() {
10087 return Err(serde::de::Error::duplicate_field("includeNode"));
10088 }
10089 include_node__ = map_.next_value()?;
10090 }
10091 }
10092 }
10093 Ok(ListCreatingFragmentDistributionRequest {
10094 include_node: include_node__,
10095 })
10096 }
10097 }
10098 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10099 }
10100}
10101impl serde::Serialize for ListCreatingFragmentDistributionResponse {
10102 #[allow(deprecated)]
10103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10104 where
10105 S: serde::Serializer,
10106 {
10107 use serde::ser::SerializeStruct;
10108 let mut len = 0;
10109 if !self.distributions.is_empty() {
10110 len += 1;
10111 }
10112 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
10113 if !self.distributions.is_empty() {
10114 struct_ser.serialize_field("distributions", &self.distributions)?;
10115 }
10116 struct_ser.end()
10117 }
10118}
10119impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
10120 #[allow(deprecated)]
10121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10122 where
10123 D: serde::Deserializer<'de>,
10124 {
10125 const FIELDS: &[&str] = &[
10126 "distributions",
10127 ];
10128
10129 #[allow(clippy::enum_variant_names)]
10130 enum GeneratedField {
10131 Distributions,
10132 }
10133 impl<'de> serde::Deserialize<'de> for GeneratedField {
10134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10135 where
10136 D: serde::Deserializer<'de>,
10137 {
10138 struct GeneratedVisitor;
10139
10140 impl serde::de::Visitor<'_> for GeneratedVisitor {
10141 type Value = GeneratedField;
10142
10143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10144 write!(formatter, "expected one of: {:?}", &FIELDS)
10145 }
10146
10147 #[allow(unused_variables)]
10148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10149 where
10150 E: serde::de::Error,
10151 {
10152 match value {
10153 "distributions" => Ok(GeneratedField::Distributions),
10154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10155 }
10156 }
10157 }
10158 deserializer.deserialize_identifier(GeneratedVisitor)
10159 }
10160 }
10161 struct GeneratedVisitor;
10162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10163 type Value = ListCreatingFragmentDistributionResponse;
10164
10165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10166 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
10167 }
10168
10169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
10170 where
10171 V: serde::de::MapAccess<'de>,
10172 {
10173 let mut distributions__ = None;
10174 while let Some(k) = map_.next_key()? {
10175 match k {
10176 GeneratedField::Distributions => {
10177 if distributions__.is_some() {
10178 return Err(serde::de::Error::duplicate_field("distributions"));
10179 }
10180 distributions__ = Some(map_.next_value()?);
10181 }
10182 }
10183 }
10184 Ok(ListCreatingFragmentDistributionResponse {
10185 distributions: distributions__.unwrap_or_default(),
10186 })
10187 }
10188 }
10189 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10190 }
10191}
10192impl serde::Serialize for ListEventLogRequest {
10193 #[allow(deprecated)]
10194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10195 where
10196 S: serde::Serializer,
10197 {
10198 use serde::ser::SerializeStruct;
10199 let len = 0;
10200 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
10201 struct_ser.end()
10202 }
10203}
10204impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
10205 #[allow(deprecated)]
10206 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10207 where
10208 D: serde::Deserializer<'de>,
10209 {
10210 const FIELDS: &[&str] = &[
10211 ];
10212
10213 #[allow(clippy::enum_variant_names)]
10214 enum GeneratedField {
10215 }
10216 impl<'de> serde::Deserialize<'de> for GeneratedField {
10217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10218 where
10219 D: serde::Deserializer<'de>,
10220 {
10221 struct GeneratedVisitor;
10222
10223 impl serde::de::Visitor<'_> for GeneratedVisitor {
10224 type Value = GeneratedField;
10225
10226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10227 write!(formatter, "expected one of: {:?}", &FIELDS)
10228 }
10229
10230 #[allow(unused_variables)]
10231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10232 where
10233 E: serde::de::Error,
10234 {
10235 Err(serde::de::Error::unknown_field(value, FIELDS))
10236 }
10237 }
10238 deserializer.deserialize_identifier(GeneratedVisitor)
10239 }
10240 }
10241 struct GeneratedVisitor;
10242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10243 type Value = ListEventLogRequest;
10244
10245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10246 formatter.write_str("struct meta.ListEventLogRequest")
10247 }
10248
10249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
10250 where
10251 V: serde::de::MapAccess<'de>,
10252 {
10253 while map_.next_key::<GeneratedField>()?.is_some() {
10254 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10255 }
10256 Ok(ListEventLogRequest {
10257 })
10258 }
10259 }
10260 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
10261 }
10262}
10263impl serde::Serialize for ListEventLogResponse {
10264 #[allow(deprecated)]
10265 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10266 where
10267 S: serde::Serializer,
10268 {
10269 use serde::ser::SerializeStruct;
10270 let mut len = 0;
10271 if !self.event_logs.is_empty() {
10272 len += 1;
10273 }
10274 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
10275 if !self.event_logs.is_empty() {
10276 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
10277 }
10278 struct_ser.end()
10279 }
10280}
10281impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
10282 #[allow(deprecated)]
10283 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10284 where
10285 D: serde::Deserializer<'de>,
10286 {
10287 const FIELDS: &[&str] = &[
10288 "event_logs",
10289 "eventLogs",
10290 ];
10291
10292 #[allow(clippy::enum_variant_names)]
10293 enum GeneratedField {
10294 EventLogs,
10295 }
10296 impl<'de> serde::Deserialize<'de> for GeneratedField {
10297 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10298 where
10299 D: serde::Deserializer<'de>,
10300 {
10301 struct GeneratedVisitor;
10302
10303 impl serde::de::Visitor<'_> for GeneratedVisitor {
10304 type Value = GeneratedField;
10305
10306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10307 write!(formatter, "expected one of: {:?}", &FIELDS)
10308 }
10309
10310 #[allow(unused_variables)]
10311 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10312 where
10313 E: serde::de::Error,
10314 {
10315 match value {
10316 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
10317 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10318 }
10319 }
10320 }
10321 deserializer.deserialize_identifier(GeneratedVisitor)
10322 }
10323 }
10324 struct GeneratedVisitor;
10325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10326 type Value = ListEventLogResponse;
10327
10328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10329 formatter.write_str("struct meta.ListEventLogResponse")
10330 }
10331
10332 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
10333 where
10334 V: serde::de::MapAccess<'de>,
10335 {
10336 let mut event_logs__ = None;
10337 while let Some(k) = map_.next_key()? {
10338 match k {
10339 GeneratedField::EventLogs => {
10340 if event_logs__.is_some() {
10341 return Err(serde::de::Error::duplicate_field("eventLogs"));
10342 }
10343 event_logs__ = Some(map_.next_value()?);
10344 }
10345 }
10346 }
10347 Ok(ListEventLogResponse {
10348 event_logs: event_logs__.unwrap_or_default(),
10349 })
10350 }
10351 }
10352 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
10353 }
10354}
10355impl serde::Serialize for ListFragmentDistributionRequest {
10356 #[allow(deprecated)]
10357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10358 where
10359 S: serde::Serializer,
10360 {
10361 use serde::ser::SerializeStruct;
10362 let mut len = 0;
10363 if self.include_node.is_some() {
10364 len += 1;
10365 }
10366 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
10367 if let Some(v) = self.include_node.as_ref() {
10368 struct_ser.serialize_field("includeNode", v)?;
10369 }
10370 struct_ser.end()
10371 }
10372}
10373impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
10374 #[allow(deprecated)]
10375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10376 where
10377 D: serde::Deserializer<'de>,
10378 {
10379 const FIELDS: &[&str] = &[
10380 "include_node",
10381 "includeNode",
10382 ];
10383
10384 #[allow(clippy::enum_variant_names)]
10385 enum GeneratedField {
10386 IncludeNode,
10387 }
10388 impl<'de> serde::Deserialize<'de> for GeneratedField {
10389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10390 where
10391 D: serde::Deserializer<'de>,
10392 {
10393 struct GeneratedVisitor;
10394
10395 impl serde::de::Visitor<'_> for GeneratedVisitor {
10396 type Value = GeneratedField;
10397
10398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10399 write!(formatter, "expected one of: {:?}", &FIELDS)
10400 }
10401
10402 #[allow(unused_variables)]
10403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10404 where
10405 E: serde::de::Error,
10406 {
10407 match value {
10408 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10409 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10410 }
10411 }
10412 }
10413 deserializer.deserialize_identifier(GeneratedVisitor)
10414 }
10415 }
10416 struct GeneratedVisitor;
10417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10418 type Value = ListFragmentDistributionRequest;
10419
10420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10421 formatter.write_str("struct meta.ListFragmentDistributionRequest")
10422 }
10423
10424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
10425 where
10426 V: serde::de::MapAccess<'de>,
10427 {
10428 let mut include_node__ = None;
10429 while let Some(k) = map_.next_key()? {
10430 match k {
10431 GeneratedField::IncludeNode => {
10432 if include_node__.is_some() {
10433 return Err(serde::de::Error::duplicate_field("includeNode"));
10434 }
10435 include_node__ = map_.next_value()?;
10436 }
10437 }
10438 }
10439 Ok(ListFragmentDistributionRequest {
10440 include_node: include_node__,
10441 })
10442 }
10443 }
10444 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10445 }
10446}
10447impl serde::Serialize for ListFragmentDistributionResponse {
10448 #[allow(deprecated)]
10449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10450 where
10451 S: serde::Serializer,
10452 {
10453 use serde::ser::SerializeStruct;
10454 let mut len = 0;
10455 if !self.distributions.is_empty() {
10456 len += 1;
10457 }
10458 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
10459 if !self.distributions.is_empty() {
10460 struct_ser.serialize_field("distributions", &self.distributions)?;
10461 }
10462 struct_ser.end()
10463 }
10464}
10465impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
10466 #[allow(deprecated)]
10467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10468 where
10469 D: serde::Deserializer<'de>,
10470 {
10471 const FIELDS: &[&str] = &[
10472 "distributions",
10473 ];
10474
10475 #[allow(clippy::enum_variant_names)]
10476 enum GeneratedField {
10477 Distributions,
10478 }
10479 impl<'de> serde::Deserialize<'de> for GeneratedField {
10480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10481 where
10482 D: serde::Deserializer<'de>,
10483 {
10484 struct GeneratedVisitor;
10485
10486 impl serde::de::Visitor<'_> for GeneratedVisitor {
10487 type Value = GeneratedField;
10488
10489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10490 write!(formatter, "expected one of: {:?}", &FIELDS)
10491 }
10492
10493 #[allow(unused_variables)]
10494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10495 where
10496 E: serde::de::Error,
10497 {
10498 match value {
10499 "distributions" => Ok(GeneratedField::Distributions),
10500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10501 }
10502 }
10503 }
10504 deserializer.deserialize_identifier(GeneratedVisitor)
10505 }
10506 }
10507 struct GeneratedVisitor;
10508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10509 type Value = ListFragmentDistributionResponse;
10510
10511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10512 formatter.write_str("struct meta.ListFragmentDistributionResponse")
10513 }
10514
10515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
10516 where
10517 V: serde::de::MapAccess<'de>,
10518 {
10519 let mut distributions__ = None;
10520 while let Some(k) = map_.next_key()? {
10521 match k {
10522 GeneratedField::Distributions => {
10523 if distributions__.is_some() {
10524 return Err(serde::de::Error::duplicate_field("distributions"));
10525 }
10526 distributions__ = Some(map_.next_value()?);
10527 }
10528 }
10529 }
10530 Ok(ListFragmentDistributionResponse {
10531 distributions: distributions__.unwrap_or_default(),
10532 })
10533 }
10534 }
10535 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10536 }
10537}
10538impl serde::Serialize for ListIcebergCompactionStatusRequest {
10539 #[allow(deprecated)]
10540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10541 where
10542 S: serde::Serializer,
10543 {
10544 use serde::ser::SerializeStruct;
10545 let len = 0;
10546 let struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusRequest", len)?;
10547 struct_ser.end()
10548 }
10549}
10550impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusRequest {
10551 #[allow(deprecated)]
10552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10553 where
10554 D: serde::Deserializer<'de>,
10555 {
10556 const FIELDS: &[&str] = &[
10557 ];
10558
10559 #[allow(clippy::enum_variant_names)]
10560 enum GeneratedField {
10561 }
10562 impl<'de> serde::Deserialize<'de> for GeneratedField {
10563 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10564 where
10565 D: serde::Deserializer<'de>,
10566 {
10567 struct GeneratedVisitor;
10568
10569 impl serde::de::Visitor<'_> for GeneratedVisitor {
10570 type Value = GeneratedField;
10571
10572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10573 write!(formatter, "expected one of: {:?}", &FIELDS)
10574 }
10575
10576 #[allow(unused_variables)]
10577 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10578 where
10579 E: serde::de::Error,
10580 {
10581 Err(serde::de::Error::unknown_field(value, FIELDS))
10582 }
10583 }
10584 deserializer.deserialize_identifier(GeneratedVisitor)
10585 }
10586 }
10587 struct GeneratedVisitor;
10588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10589 type Value = ListIcebergCompactionStatusRequest;
10590
10591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10592 formatter.write_str("struct meta.ListIcebergCompactionStatusRequest")
10593 }
10594
10595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusRequest, V::Error>
10596 where
10597 V: serde::de::MapAccess<'de>,
10598 {
10599 while map_.next_key::<GeneratedField>()?.is_some() {
10600 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10601 }
10602 Ok(ListIcebergCompactionStatusRequest {
10603 })
10604 }
10605 }
10606 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusRequest", FIELDS, GeneratedVisitor)
10607 }
10608}
10609impl serde::Serialize for ListIcebergCompactionStatusResponse {
10610 #[allow(deprecated)]
10611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10612 where
10613 S: serde::Serializer,
10614 {
10615 use serde::ser::SerializeStruct;
10616 let mut len = 0;
10617 if !self.statuses.is_empty() {
10618 len += 1;
10619 }
10620 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse", len)?;
10621 if !self.statuses.is_empty() {
10622 struct_ser.serialize_field("statuses", &self.statuses)?;
10623 }
10624 struct_ser.end()
10625 }
10626}
10627impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusResponse {
10628 #[allow(deprecated)]
10629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10630 where
10631 D: serde::Deserializer<'de>,
10632 {
10633 const FIELDS: &[&str] = &[
10634 "statuses",
10635 ];
10636
10637 #[allow(clippy::enum_variant_names)]
10638 enum GeneratedField {
10639 Statuses,
10640 }
10641 impl<'de> serde::Deserialize<'de> for GeneratedField {
10642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10643 where
10644 D: serde::Deserializer<'de>,
10645 {
10646 struct GeneratedVisitor;
10647
10648 impl serde::de::Visitor<'_> for GeneratedVisitor {
10649 type Value = GeneratedField;
10650
10651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10652 write!(formatter, "expected one of: {:?}", &FIELDS)
10653 }
10654
10655 #[allow(unused_variables)]
10656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10657 where
10658 E: serde::de::Error,
10659 {
10660 match value {
10661 "statuses" => Ok(GeneratedField::Statuses),
10662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10663 }
10664 }
10665 }
10666 deserializer.deserialize_identifier(GeneratedVisitor)
10667 }
10668 }
10669 struct GeneratedVisitor;
10670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10671 type Value = ListIcebergCompactionStatusResponse;
10672
10673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10674 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse")
10675 }
10676
10677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusResponse, V::Error>
10678 where
10679 V: serde::de::MapAccess<'de>,
10680 {
10681 let mut statuses__ = None;
10682 while let Some(k) = map_.next_key()? {
10683 match k {
10684 GeneratedField::Statuses => {
10685 if statuses__.is_some() {
10686 return Err(serde::de::Error::duplicate_field("statuses"));
10687 }
10688 statuses__ = Some(map_.next_value()?);
10689 }
10690 }
10691 }
10692 Ok(ListIcebergCompactionStatusResponse {
10693 statuses: statuses__.unwrap_or_default(),
10694 })
10695 }
10696 }
10697 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse", FIELDS, GeneratedVisitor)
10698 }
10699}
10700impl serde::Serialize for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10701 #[allow(deprecated)]
10702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10703 where
10704 S: serde::Serializer,
10705 {
10706 use serde::ser::SerializeStruct;
10707 let mut len = 0;
10708 if self.sink_id != 0 {
10709 len += 1;
10710 }
10711 if !self.task_type.is_empty() {
10712 len += 1;
10713 }
10714 if self.trigger_interval_sec != 0 {
10715 len += 1;
10716 }
10717 if self.trigger_snapshot_count != 0 {
10718 len += 1;
10719 }
10720 if !self.schedule_state.is_empty() {
10721 len += 1;
10722 }
10723 if self.next_compaction_after_sec.is_some() {
10724 len += 1;
10725 }
10726 if self.pending_snapshot_count.is_some() {
10727 len += 1;
10728 }
10729 if self.is_triggerable {
10730 len += 1;
10731 }
10732 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", len)?;
10733 if self.sink_id != 0 {
10734 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10735 }
10736 if !self.task_type.is_empty() {
10737 struct_ser.serialize_field("taskType", &self.task_type)?;
10738 }
10739 if self.trigger_interval_sec != 0 {
10740 #[allow(clippy::needless_borrow)]
10741 #[allow(clippy::needless_borrows_for_generic_args)]
10742 struct_ser.serialize_field("triggerIntervalSec", ToString::to_string(&self.trigger_interval_sec).as_str())?;
10743 }
10744 if self.trigger_snapshot_count != 0 {
10745 #[allow(clippy::needless_borrow)]
10746 #[allow(clippy::needless_borrows_for_generic_args)]
10747 struct_ser.serialize_field("triggerSnapshotCount", ToString::to_string(&self.trigger_snapshot_count).as_str())?;
10748 }
10749 if !self.schedule_state.is_empty() {
10750 struct_ser.serialize_field("scheduleState", &self.schedule_state)?;
10751 }
10752 if let Some(v) = self.next_compaction_after_sec.as_ref() {
10753 #[allow(clippy::needless_borrow)]
10754 #[allow(clippy::needless_borrows_for_generic_args)]
10755 struct_ser.serialize_field("nextCompactionAfterSec", ToString::to_string(&v).as_str())?;
10756 }
10757 if let Some(v) = self.pending_snapshot_count.as_ref() {
10758 #[allow(clippy::needless_borrow)]
10759 #[allow(clippy::needless_borrows_for_generic_args)]
10760 struct_ser.serialize_field("pendingSnapshotCount", ToString::to_string(&v).as_str())?;
10761 }
10762 if self.is_triggerable {
10763 struct_ser.serialize_field("isTriggerable", &self.is_triggerable)?;
10764 }
10765 struct_ser.end()
10766 }
10767}
10768impl<'de> serde::Deserialize<'de> for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10769 #[allow(deprecated)]
10770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10771 where
10772 D: serde::Deserializer<'de>,
10773 {
10774 const FIELDS: &[&str] = &[
10775 "sink_id",
10776 "sinkId",
10777 "task_type",
10778 "taskType",
10779 "trigger_interval_sec",
10780 "triggerIntervalSec",
10781 "trigger_snapshot_count",
10782 "triggerSnapshotCount",
10783 "schedule_state",
10784 "scheduleState",
10785 "next_compaction_after_sec",
10786 "nextCompactionAfterSec",
10787 "pending_snapshot_count",
10788 "pendingSnapshotCount",
10789 "is_triggerable",
10790 "isTriggerable",
10791 ];
10792
10793 #[allow(clippy::enum_variant_names)]
10794 enum GeneratedField {
10795 SinkId,
10796 TaskType,
10797 TriggerIntervalSec,
10798 TriggerSnapshotCount,
10799 ScheduleState,
10800 NextCompactionAfterSec,
10801 PendingSnapshotCount,
10802 IsTriggerable,
10803 }
10804 impl<'de> serde::Deserialize<'de> for GeneratedField {
10805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10806 where
10807 D: serde::Deserializer<'de>,
10808 {
10809 struct GeneratedVisitor;
10810
10811 impl serde::de::Visitor<'_> for GeneratedVisitor {
10812 type Value = GeneratedField;
10813
10814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10815 write!(formatter, "expected one of: {:?}", &FIELDS)
10816 }
10817
10818 #[allow(unused_variables)]
10819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10820 where
10821 E: serde::de::Error,
10822 {
10823 match value {
10824 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10825 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
10826 "triggerIntervalSec" | "trigger_interval_sec" => Ok(GeneratedField::TriggerIntervalSec),
10827 "triggerSnapshotCount" | "trigger_snapshot_count" => Ok(GeneratedField::TriggerSnapshotCount),
10828 "scheduleState" | "schedule_state" => Ok(GeneratedField::ScheduleState),
10829 "nextCompactionAfterSec" | "next_compaction_after_sec" => Ok(GeneratedField::NextCompactionAfterSec),
10830 "pendingSnapshotCount" | "pending_snapshot_count" => Ok(GeneratedField::PendingSnapshotCount),
10831 "isTriggerable" | "is_triggerable" => Ok(GeneratedField::IsTriggerable),
10832 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10833 }
10834 }
10835 }
10836 deserializer.deserialize_identifier(GeneratedVisitor)
10837 }
10838 }
10839 struct GeneratedVisitor;
10840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10841 type Value = list_iceberg_compaction_status_response::IcebergCompactionStatus;
10842
10843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10844 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus")
10845 }
10846
10847 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_compaction_status_response::IcebergCompactionStatus, V::Error>
10848 where
10849 V: serde::de::MapAccess<'de>,
10850 {
10851 let mut sink_id__ = None;
10852 let mut task_type__ = None;
10853 let mut trigger_interval_sec__ = None;
10854 let mut trigger_snapshot_count__ = None;
10855 let mut schedule_state__ = None;
10856 let mut next_compaction_after_sec__ = None;
10857 let mut pending_snapshot_count__ = None;
10858 let mut is_triggerable__ = None;
10859 while let Some(k) = map_.next_key()? {
10860 match k {
10861 GeneratedField::SinkId => {
10862 if sink_id__.is_some() {
10863 return Err(serde::de::Error::duplicate_field("sinkId"));
10864 }
10865 sink_id__ =
10866 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10867 ;
10868 }
10869 GeneratedField::TaskType => {
10870 if task_type__.is_some() {
10871 return Err(serde::de::Error::duplicate_field("taskType"));
10872 }
10873 task_type__ = Some(map_.next_value()?);
10874 }
10875 GeneratedField::TriggerIntervalSec => {
10876 if trigger_interval_sec__.is_some() {
10877 return Err(serde::de::Error::duplicate_field("triggerIntervalSec"));
10878 }
10879 trigger_interval_sec__ =
10880 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10881 ;
10882 }
10883 GeneratedField::TriggerSnapshotCount => {
10884 if trigger_snapshot_count__.is_some() {
10885 return Err(serde::de::Error::duplicate_field("triggerSnapshotCount"));
10886 }
10887 trigger_snapshot_count__ =
10888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10889 ;
10890 }
10891 GeneratedField::ScheduleState => {
10892 if schedule_state__.is_some() {
10893 return Err(serde::de::Error::duplicate_field("scheduleState"));
10894 }
10895 schedule_state__ = Some(map_.next_value()?);
10896 }
10897 GeneratedField::NextCompactionAfterSec => {
10898 if next_compaction_after_sec__.is_some() {
10899 return Err(serde::de::Error::duplicate_field("nextCompactionAfterSec"));
10900 }
10901 next_compaction_after_sec__ =
10902 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10903 ;
10904 }
10905 GeneratedField::PendingSnapshotCount => {
10906 if pending_snapshot_count__.is_some() {
10907 return Err(serde::de::Error::duplicate_field("pendingSnapshotCount"));
10908 }
10909 pending_snapshot_count__ =
10910 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10911 ;
10912 }
10913 GeneratedField::IsTriggerable => {
10914 if is_triggerable__.is_some() {
10915 return Err(serde::de::Error::duplicate_field("isTriggerable"));
10916 }
10917 is_triggerable__ = Some(map_.next_value()?);
10918 }
10919 }
10920 }
10921 Ok(list_iceberg_compaction_status_response::IcebergCompactionStatus {
10922 sink_id: sink_id__.unwrap_or_default(),
10923 task_type: task_type__.unwrap_or_default(),
10924 trigger_interval_sec: trigger_interval_sec__.unwrap_or_default(),
10925 trigger_snapshot_count: trigger_snapshot_count__.unwrap_or_default(),
10926 schedule_state: schedule_state__.unwrap_or_default(),
10927 next_compaction_after_sec: next_compaction_after_sec__,
10928 pending_snapshot_count: pending_snapshot_count__,
10929 is_triggerable: is_triggerable__.unwrap_or_default(),
10930 })
10931 }
10932 }
10933 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", FIELDS, GeneratedVisitor)
10934 }
10935}
10936impl serde::Serialize for ListIcebergTablesRequest {
10937 #[allow(deprecated)]
10938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10939 where
10940 S: serde::Serializer,
10941 {
10942 use serde::ser::SerializeStruct;
10943 let len = 0;
10944 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
10945 struct_ser.end()
10946 }
10947}
10948impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
10949 #[allow(deprecated)]
10950 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10951 where
10952 D: serde::Deserializer<'de>,
10953 {
10954 const FIELDS: &[&str] = &[
10955 ];
10956
10957 #[allow(clippy::enum_variant_names)]
10958 enum GeneratedField {
10959 }
10960 impl<'de> serde::Deserialize<'de> for GeneratedField {
10961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10962 where
10963 D: serde::Deserializer<'de>,
10964 {
10965 struct GeneratedVisitor;
10966
10967 impl serde::de::Visitor<'_> for GeneratedVisitor {
10968 type Value = GeneratedField;
10969
10970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10971 write!(formatter, "expected one of: {:?}", &FIELDS)
10972 }
10973
10974 #[allow(unused_variables)]
10975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10976 where
10977 E: serde::de::Error,
10978 {
10979 Err(serde::de::Error::unknown_field(value, FIELDS))
10980 }
10981 }
10982 deserializer.deserialize_identifier(GeneratedVisitor)
10983 }
10984 }
10985 struct GeneratedVisitor;
10986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10987 type Value = ListIcebergTablesRequest;
10988
10989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10990 formatter.write_str("struct meta.ListIcebergTablesRequest")
10991 }
10992
10993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
10994 where
10995 V: serde::de::MapAccess<'de>,
10996 {
10997 while map_.next_key::<GeneratedField>()?.is_some() {
10998 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10999 }
11000 Ok(ListIcebergTablesRequest {
11001 })
11002 }
11003 }
11004 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
11005 }
11006}
11007impl serde::Serialize for ListIcebergTablesResponse {
11008 #[allow(deprecated)]
11009 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11010 where
11011 S: serde::Serializer,
11012 {
11013 use serde::ser::SerializeStruct;
11014 let mut len = 0;
11015 if !self.iceberg_tables.is_empty() {
11016 len += 1;
11017 }
11018 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
11019 if !self.iceberg_tables.is_empty() {
11020 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
11021 }
11022 struct_ser.end()
11023 }
11024}
11025impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
11026 #[allow(deprecated)]
11027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11028 where
11029 D: serde::Deserializer<'de>,
11030 {
11031 const FIELDS: &[&str] = &[
11032 "iceberg_tables",
11033 "icebergTables",
11034 ];
11035
11036 #[allow(clippy::enum_variant_names)]
11037 enum GeneratedField {
11038 IcebergTables,
11039 }
11040 impl<'de> serde::Deserialize<'de> for GeneratedField {
11041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11042 where
11043 D: serde::Deserializer<'de>,
11044 {
11045 struct GeneratedVisitor;
11046
11047 impl serde::de::Visitor<'_> for GeneratedVisitor {
11048 type Value = GeneratedField;
11049
11050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11051 write!(formatter, "expected one of: {:?}", &FIELDS)
11052 }
11053
11054 #[allow(unused_variables)]
11055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11056 where
11057 E: serde::de::Error,
11058 {
11059 match value {
11060 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
11061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11062 }
11063 }
11064 }
11065 deserializer.deserialize_identifier(GeneratedVisitor)
11066 }
11067 }
11068 struct GeneratedVisitor;
11069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11070 type Value = ListIcebergTablesResponse;
11071
11072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11073 formatter.write_str("struct meta.ListIcebergTablesResponse")
11074 }
11075
11076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
11077 where
11078 V: serde::de::MapAccess<'de>,
11079 {
11080 let mut iceberg_tables__ = None;
11081 while let Some(k) = map_.next_key()? {
11082 match k {
11083 GeneratedField::IcebergTables => {
11084 if iceberg_tables__.is_some() {
11085 return Err(serde::de::Error::duplicate_field("icebergTables"));
11086 }
11087 iceberg_tables__ = Some(map_.next_value()?);
11088 }
11089 }
11090 }
11091 Ok(ListIcebergTablesResponse {
11092 iceberg_tables: iceberg_tables__.unwrap_or_default(),
11093 })
11094 }
11095 }
11096 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
11097 }
11098}
11099impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
11100 #[allow(deprecated)]
11101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11102 where
11103 S: serde::Serializer,
11104 {
11105 use serde::ser::SerializeStruct;
11106 let mut len = 0;
11107 if !self.catalog_name.is_empty() {
11108 len += 1;
11109 }
11110 if !self.table_namespace.is_empty() {
11111 len += 1;
11112 }
11113 if !self.table_name.is_empty() {
11114 len += 1;
11115 }
11116 if self.metadata_location.is_some() {
11117 len += 1;
11118 }
11119 if self.previous_metadata_location.is_some() {
11120 len += 1;
11121 }
11122 if self.iceberg_type.is_some() {
11123 len += 1;
11124 }
11125 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
11126 if !self.catalog_name.is_empty() {
11127 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
11128 }
11129 if !self.table_namespace.is_empty() {
11130 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
11131 }
11132 if !self.table_name.is_empty() {
11133 struct_ser.serialize_field("tableName", &self.table_name)?;
11134 }
11135 if let Some(v) = self.metadata_location.as_ref() {
11136 struct_ser.serialize_field("metadataLocation", v)?;
11137 }
11138 if let Some(v) = self.previous_metadata_location.as_ref() {
11139 struct_ser.serialize_field("previousMetadataLocation", v)?;
11140 }
11141 if let Some(v) = self.iceberg_type.as_ref() {
11142 struct_ser.serialize_field("icebergType", v)?;
11143 }
11144 struct_ser.end()
11145 }
11146}
11147impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
11148 #[allow(deprecated)]
11149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11150 where
11151 D: serde::Deserializer<'de>,
11152 {
11153 const FIELDS: &[&str] = &[
11154 "catalog_name",
11155 "catalogName",
11156 "table_namespace",
11157 "tableNamespace",
11158 "table_name",
11159 "tableName",
11160 "metadata_location",
11161 "metadataLocation",
11162 "previous_metadata_location",
11163 "previousMetadataLocation",
11164 "iceberg_type",
11165 "icebergType",
11166 ];
11167
11168 #[allow(clippy::enum_variant_names)]
11169 enum GeneratedField {
11170 CatalogName,
11171 TableNamespace,
11172 TableName,
11173 MetadataLocation,
11174 PreviousMetadataLocation,
11175 IcebergType,
11176 }
11177 impl<'de> serde::Deserialize<'de> for GeneratedField {
11178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11179 where
11180 D: serde::Deserializer<'de>,
11181 {
11182 struct GeneratedVisitor;
11183
11184 impl serde::de::Visitor<'_> for GeneratedVisitor {
11185 type Value = GeneratedField;
11186
11187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11188 write!(formatter, "expected one of: {:?}", &FIELDS)
11189 }
11190
11191 #[allow(unused_variables)]
11192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11193 where
11194 E: serde::de::Error,
11195 {
11196 match value {
11197 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
11198 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
11199 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11200 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
11201 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
11202 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
11203 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11204 }
11205 }
11206 }
11207 deserializer.deserialize_identifier(GeneratedVisitor)
11208 }
11209 }
11210 struct GeneratedVisitor;
11211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11212 type Value = list_iceberg_tables_response::IcebergTable;
11213
11214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11215 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
11216 }
11217
11218 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
11219 where
11220 V: serde::de::MapAccess<'de>,
11221 {
11222 let mut catalog_name__ = None;
11223 let mut table_namespace__ = None;
11224 let mut table_name__ = None;
11225 let mut metadata_location__ = None;
11226 let mut previous_metadata_location__ = None;
11227 let mut iceberg_type__ = None;
11228 while let Some(k) = map_.next_key()? {
11229 match k {
11230 GeneratedField::CatalogName => {
11231 if catalog_name__.is_some() {
11232 return Err(serde::de::Error::duplicate_field("catalogName"));
11233 }
11234 catalog_name__ = Some(map_.next_value()?);
11235 }
11236 GeneratedField::TableNamespace => {
11237 if table_namespace__.is_some() {
11238 return Err(serde::de::Error::duplicate_field("tableNamespace"));
11239 }
11240 table_namespace__ = Some(map_.next_value()?);
11241 }
11242 GeneratedField::TableName => {
11243 if table_name__.is_some() {
11244 return Err(serde::de::Error::duplicate_field("tableName"));
11245 }
11246 table_name__ = Some(map_.next_value()?);
11247 }
11248 GeneratedField::MetadataLocation => {
11249 if metadata_location__.is_some() {
11250 return Err(serde::de::Error::duplicate_field("metadataLocation"));
11251 }
11252 metadata_location__ = map_.next_value()?;
11253 }
11254 GeneratedField::PreviousMetadataLocation => {
11255 if previous_metadata_location__.is_some() {
11256 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
11257 }
11258 previous_metadata_location__ = map_.next_value()?;
11259 }
11260 GeneratedField::IcebergType => {
11261 if iceberg_type__.is_some() {
11262 return Err(serde::de::Error::duplicate_field("icebergType"));
11263 }
11264 iceberg_type__ = map_.next_value()?;
11265 }
11266 }
11267 }
11268 Ok(list_iceberg_tables_response::IcebergTable {
11269 catalog_name: catalog_name__.unwrap_or_default(),
11270 table_namespace: table_namespace__.unwrap_or_default(),
11271 table_name: table_name__.unwrap_or_default(),
11272 metadata_location: metadata_location__,
11273 previous_metadata_location: previous_metadata_location__,
11274 iceberg_type: iceberg_type__,
11275 })
11276 }
11277 }
11278 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
11279 }
11280}
11281impl serde::Serialize for ListRateLimitsRequest {
11282 #[allow(deprecated)]
11283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11284 where
11285 S: serde::Serializer,
11286 {
11287 use serde::ser::SerializeStruct;
11288 let len = 0;
11289 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
11290 struct_ser.end()
11291 }
11292}
11293impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
11294 #[allow(deprecated)]
11295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11296 where
11297 D: serde::Deserializer<'de>,
11298 {
11299 const FIELDS: &[&str] = &[
11300 ];
11301
11302 #[allow(clippy::enum_variant_names)]
11303 enum GeneratedField {
11304 }
11305 impl<'de> serde::Deserialize<'de> for GeneratedField {
11306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11307 where
11308 D: serde::Deserializer<'de>,
11309 {
11310 struct GeneratedVisitor;
11311
11312 impl serde::de::Visitor<'_> for GeneratedVisitor {
11313 type Value = GeneratedField;
11314
11315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11316 write!(formatter, "expected one of: {:?}", &FIELDS)
11317 }
11318
11319 #[allow(unused_variables)]
11320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11321 where
11322 E: serde::de::Error,
11323 {
11324 Err(serde::de::Error::unknown_field(value, FIELDS))
11325 }
11326 }
11327 deserializer.deserialize_identifier(GeneratedVisitor)
11328 }
11329 }
11330 struct GeneratedVisitor;
11331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11332 type Value = ListRateLimitsRequest;
11333
11334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11335 formatter.write_str("struct meta.ListRateLimitsRequest")
11336 }
11337
11338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
11339 where
11340 V: serde::de::MapAccess<'de>,
11341 {
11342 while map_.next_key::<GeneratedField>()?.is_some() {
11343 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11344 }
11345 Ok(ListRateLimitsRequest {
11346 })
11347 }
11348 }
11349 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
11350 }
11351}
11352impl serde::Serialize for ListRateLimitsResponse {
11353 #[allow(deprecated)]
11354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11355 where
11356 S: serde::Serializer,
11357 {
11358 use serde::ser::SerializeStruct;
11359 let mut len = 0;
11360 if !self.rate_limits.is_empty() {
11361 len += 1;
11362 }
11363 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
11364 if !self.rate_limits.is_empty() {
11365 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
11366 }
11367 struct_ser.end()
11368 }
11369}
11370impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
11371 #[allow(deprecated)]
11372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11373 where
11374 D: serde::Deserializer<'de>,
11375 {
11376 const FIELDS: &[&str] = &[
11377 "rate_limits",
11378 "rateLimits",
11379 ];
11380
11381 #[allow(clippy::enum_variant_names)]
11382 enum GeneratedField {
11383 RateLimits,
11384 }
11385 impl<'de> serde::Deserialize<'de> for GeneratedField {
11386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11387 where
11388 D: serde::Deserializer<'de>,
11389 {
11390 struct GeneratedVisitor;
11391
11392 impl serde::de::Visitor<'_> for GeneratedVisitor {
11393 type Value = GeneratedField;
11394
11395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11396 write!(formatter, "expected one of: {:?}", &FIELDS)
11397 }
11398
11399 #[allow(unused_variables)]
11400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11401 where
11402 E: serde::de::Error,
11403 {
11404 match value {
11405 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
11406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11407 }
11408 }
11409 }
11410 deserializer.deserialize_identifier(GeneratedVisitor)
11411 }
11412 }
11413 struct GeneratedVisitor;
11414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11415 type Value = ListRateLimitsResponse;
11416
11417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11418 formatter.write_str("struct meta.ListRateLimitsResponse")
11419 }
11420
11421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
11422 where
11423 V: serde::de::MapAccess<'de>,
11424 {
11425 let mut rate_limits__ = None;
11426 while let Some(k) = map_.next_key()? {
11427 match k {
11428 GeneratedField::RateLimits => {
11429 if rate_limits__.is_some() {
11430 return Err(serde::de::Error::duplicate_field("rateLimits"));
11431 }
11432 rate_limits__ = Some(map_.next_value()?);
11433 }
11434 }
11435 }
11436 Ok(ListRateLimitsResponse {
11437 rate_limits: rate_limits__.unwrap_or_default(),
11438 })
11439 }
11440 }
11441 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
11442 }
11443}
11444impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
11445 #[allow(deprecated)]
11446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11447 where
11448 S: serde::Serializer,
11449 {
11450 use serde::ser::SerializeStruct;
11451 let mut len = 0;
11452 if self.fragment_id != 0 {
11453 len += 1;
11454 }
11455 if self.job_id != 0 {
11456 len += 1;
11457 }
11458 if self.fragment_type_mask != 0 {
11459 len += 1;
11460 }
11461 if self.rate_limit != 0 {
11462 len += 1;
11463 }
11464 if !self.node_name.is_empty() {
11465 len += 1;
11466 }
11467 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
11468 if self.fragment_id != 0 {
11469 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11470 }
11471 if self.job_id != 0 {
11472 struct_ser.serialize_field("jobId", &self.job_id)?;
11473 }
11474 if self.fragment_type_mask != 0 {
11475 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11476 }
11477 if self.rate_limit != 0 {
11478 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
11479 }
11480 if !self.node_name.is_empty() {
11481 struct_ser.serialize_field("nodeName", &self.node_name)?;
11482 }
11483 struct_ser.end()
11484 }
11485}
11486impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
11487 #[allow(deprecated)]
11488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11489 where
11490 D: serde::Deserializer<'de>,
11491 {
11492 const FIELDS: &[&str] = &[
11493 "fragment_id",
11494 "fragmentId",
11495 "job_id",
11496 "jobId",
11497 "fragment_type_mask",
11498 "fragmentTypeMask",
11499 "rate_limit",
11500 "rateLimit",
11501 "node_name",
11502 "nodeName",
11503 ];
11504
11505 #[allow(clippy::enum_variant_names)]
11506 enum GeneratedField {
11507 FragmentId,
11508 JobId,
11509 FragmentTypeMask,
11510 RateLimit,
11511 NodeName,
11512 }
11513 impl<'de> serde::Deserialize<'de> for GeneratedField {
11514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11515 where
11516 D: serde::Deserializer<'de>,
11517 {
11518 struct GeneratedVisitor;
11519
11520 impl serde::de::Visitor<'_> for GeneratedVisitor {
11521 type Value = GeneratedField;
11522
11523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11524 write!(formatter, "expected one of: {:?}", &FIELDS)
11525 }
11526
11527 #[allow(unused_variables)]
11528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11529 where
11530 E: serde::de::Error,
11531 {
11532 match value {
11533 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11534 "jobId" | "job_id" => Ok(GeneratedField::JobId),
11535 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11536 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11537 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
11538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11539 }
11540 }
11541 }
11542 deserializer.deserialize_identifier(GeneratedVisitor)
11543 }
11544 }
11545 struct GeneratedVisitor;
11546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11547 type Value = list_rate_limits_response::RateLimitInfo;
11548
11549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11550 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
11551 }
11552
11553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
11554 where
11555 V: serde::de::MapAccess<'de>,
11556 {
11557 let mut fragment_id__ = None;
11558 let mut job_id__ = None;
11559 let mut fragment_type_mask__ = None;
11560 let mut rate_limit__ = None;
11561 let mut node_name__ = None;
11562 while let Some(k) = map_.next_key()? {
11563 match k {
11564 GeneratedField::FragmentId => {
11565 if fragment_id__.is_some() {
11566 return Err(serde::de::Error::duplicate_field("fragmentId"));
11567 }
11568 fragment_id__ =
11569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11570 ;
11571 }
11572 GeneratedField::JobId => {
11573 if job_id__.is_some() {
11574 return Err(serde::de::Error::duplicate_field("jobId"));
11575 }
11576 job_id__ =
11577 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11578 ;
11579 }
11580 GeneratedField::FragmentTypeMask => {
11581 if fragment_type_mask__.is_some() {
11582 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11583 }
11584 fragment_type_mask__ =
11585 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11586 ;
11587 }
11588 GeneratedField::RateLimit => {
11589 if rate_limit__.is_some() {
11590 return Err(serde::de::Error::duplicate_field("rateLimit"));
11591 }
11592 rate_limit__ =
11593 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11594 ;
11595 }
11596 GeneratedField::NodeName => {
11597 if node_name__.is_some() {
11598 return Err(serde::de::Error::duplicate_field("nodeName"));
11599 }
11600 node_name__ = Some(map_.next_value()?);
11601 }
11602 }
11603 }
11604 Ok(list_rate_limits_response::RateLimitInfo {
11605 fragment_id: fragment_id__.unwrap_or_default(),
11606 job_id: job_id__.unwrap_or_default(),
11607 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11608 rate_limit: rate_limit__.unwrap_or_default(),
11609 node_name: node_name__.unwrap_or_default(),
11610 })
11611 }
11612 }
11613 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
11614 }
11615}
11616impl serde::Serialize for ListRefreshTableStatesRequest {
11617 #[allow(deprecated)]
11618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11619 where
11620 S: serde::Serializer,
11621 {
11622 use serde::ser::SerializeStruct;
11623 let len = 0;
11624 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
11625 struct_ser.end()
11626 }
11627}
11628impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11629 #[allow(deprecated)]
11630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11631 where
11632 D: serde::Deserializer<'de>,
11633 {
11634 const FIELDS: &[&str] = &[
11635 ];
11636
11637 #[allow(clippy::enum_variant_names)]
11638 enum GeneratedField {
11639 }
11640 impl<'de> serde::Deserialize<'de> for GeneratedField {
11641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11642 where
11643 D: serde::Deserializer<'de>,
11644 {
11645 struct GeneratedVisitor;
11646
11647 impl serde::de::Visitor<'_> for GeneratedVisitor {
11648 type Value = GeneratedField;
11649
11650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11651 write!(formatter, "expected one of: {:?}", &FIELDS)
11652 }
11653
11654 #[allow(unused_variables)]
11655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11656 where
11657 E: serde::de::Error,
11658 {
11659 Err(serde::de::Error::unknown_field(value, FIELDS))
11660 }
11661 }
11662 deserializer.deserialize_identifier(GeneratedVisitor)
11663 }
11664 }
11665 struct GeneratedVisitor;
11666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11667 type Value = ListRefreshTableStatesRequest;
11668
11669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11670 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11671 }
11672
11673 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11674 where
11675 V: serde::de::MapAccess<'de>,
11676 {
11677 while map_.next_key::<GeneratedField>()?.is_some() {
11678 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11679 }
11680 Ok(ListRefreshTableStatesRequest {
11681 })
11682 }
11683 }
11684 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11685 }
11686}
11687impl serde::Serialize for ListRefreshTableStatesResponse {
11688 #[allow(deprecated)]
11689 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11690 where
11691 S: serde::Serializer,
11692 {
11693 use serde::ser::SerializeStruct;
11694 let mut len = 0;
11695 if !self.states.is_empty() {
11696 len += 1;
11697 }
11698 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11699 if !self.states.is_empty() {
11700 struct_ser.serialize_field("states", &self.states)?;
11701 }
11702 struct_ser.end()
11703 }
11704}
11705impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11706 #[allow(deprecated)]
11707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11708 where
11709 D: serde::Deserializer<'de>,
11710 {
11711 const FIELDS: &[&str] = &[
11712 "states",
11713 ];
11714
11715 #[allow(clippy::enum_variant_names)]
11716 enum GeneratedField {
11717 States,
11718 }
11719 impl<'de> serde::Deserialize<'de> for GeneratedField {
11720 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11721 where
11722 D: serde::Deserializer<'de>,
11723 {
11724 struct GeneratedVisitor;
11725
11726 impl serde::de::Visitor<'_> for GeneratedVisitor {
11727 type Value = GeneratedField;
11728
11729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11730 write!(formatter, "expected one of: {:?}", &FIELDS)
11731 }
11732
11733 #[allow(unused_variables)]
11734 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11735 where
11736 E: serde::de::Error,
11737 {
11738 match value {
11739 "states" => Ok(GeneratedField::States),
11740 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11741 }
11742 }
11743 }
11744 deserializer.deserialize_identifier(GeneratedVisitor)
11745 }
11746 }
11747 struct GeneratedVisitor;
11748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11749 type Value = ListRefreshTableStatesResponse;
11750
11751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11752 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11753 }
11754
11755 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11756 where
11757 V: serde::de::MapAccess<'de>,
11758 {
11759 let mut states__ = None;
11760 while let Some(k) = map_.next_key()? {
11761 match k {
11762 GeneratedField::States => {
11763 if states__.is_some() {
11764 return Err(serde::de::Error::duplicate_field("states"));
11765 }
11766 states__ = Some(map_.next_value()?);
11767 }
11768 }
11769 }
11770 Ok(ListRefreshTableStatesResponse {
11771 states: states__.unwrap_or_default(),
11772 })
11773 }
11774 }
11775 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11776 }
11777}
11778impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11779 #[allow(deprecated)]
11780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11781 where
11782 S: serde::Serializer,
11783 {
11784 use serde::ser::SerializeStruct;
11785 let mut len = 0;
11786 if self.table_id != 0 {
11787 len += 1;
11788 }
11789 if !self.current_status.is_empty() {
11790 len += 1;
11791 }
11792 if self.last_trigger_time.is_some() {
11793 len += 1;
11794 }
11795 if self.trigger_interval_secs.is_some() {
11796 len += 1;
11797 }
11798 if self.last_success_time.is_some() {
11799 len += 1;
11800 }
11801 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11802 if self.table_id != 0 {
11803 struct_ser.serialize_field("tableId", &self.table_id)?;
11804 }
11805 if !self.current_status.is_empty() {
11806 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11807 }
11808 if let Some(v) = self.last_trigger_time.as_ref() {
11809 struct_ser.serialize_field("lastTriggerTime", v)?;
11810 }
11811 if let Some(v) = self.trigger_interval_secs.as_ref() {
11812 #[allow(clippy::needless_borrow)]
11813 #[allow(clippy::needless_borrows_for_generic_args)]
11814 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11815 }
11816 if let Some(v) = self.last_success_time.as_ref() {
11817 struct_ser.serialize_field("lastSuccessTime", v)?;
11818 }
11819 struct_ser.end()
11820 }
11821}
11822impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11823 #[allow(deprecated)]
11824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11825 where
11826 D: serde::Deserializer<'de>,
11827 {
11828 const FIELDS: &[&str] = &[
11829 "table_id",
11830 "tableId",
11831 "current_status",
11832 "currentStatus",
11833 "last_trigger_time",
11834 "lastTriggerTime",
11835 "trigger_interval_secs",
11836 "triggerIntervalSecs",
11837 "last_success_time",
11838 "lastSuccessTime",
11839 ];
11840
11841 #[allow(clippy::enum_variant_names)]
11842 enum GeneratedField {
11843 TableId,
11844 CurrentStatus,
11845 LastTriggerTime,
11846 TriggerIntervalSecs,
11847 LastSuccessTime,
11848 }
11849 impl<'de> serde::Deserialize<'de> for GeneratedField {
11850 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11851 where
11852 D: serde::Deserializer<'de>,
11853 {
11854 struct GeneratedVisitor;
11855
11856 impl serde::de::Visitor<'_> for GeneratedVisitor {
11857 type Value = GeneratedField;
11858
11859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11860 write!(formatter, "expected one of: {:?}", &FIELDS)
11861 }
11862
11863 #[allow(unused_variables)]
11864 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11865 where
11866 E: serde::de::Error,
11867 {
11868 match value {
11869 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11870 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11871 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11872 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11873 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11874 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11875 }
11876 }
11877 }
11878 deserializer.deserialize_identifier(GeneratedVisitor)
11879 }
11880 }
11881 struct GeneratedVisitor;
11882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11883 type Value = list_refresh_table_states_response::RefreshTableState;
11884
11885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11886 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11887 }
11888
11889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11890 where
11891 V: serde::de::MapAccess<'de>,
11892 {
11893 let mut table_id__ = None;
11894 let mut current_status__ = None;
11895 let mut last_trigger_time__ = None;
11896 let mut trigger_interval_secs__ = None;
11897 let mut last_success_time__ = None;
11898 while let Some(k) = map_.next_key()? {
11899 match k {
11900 GeneratedField::TableId => {
11901 if table_id__.is_some() {
11902 return Err(serde::de::Error::duplicate_field("tableId"));
11903 }
11904 table_id__ =
11905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11906 ;
11907 }
11908 GeneratedField::CurrentStatus => {
11909 if current_status__.is_some() {
11910 return Err(serde::de::Error::duplicate_field("currentStatus"));
11911 }
11912 current_status__ = Some(map_.next_value()?);
11913 }
11914 GeneratedField::LastTriggerTime => {
11915 if last_trigger_time__.is_some() {
11916 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11917 }
11918 last_trigger_time__ = map_.next_value()?;
11919 }
11920 GeneratedField::TriggerIntervalSecs => {
11921 if trigger_interval_secs__.is_some() {
11922 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11923 }
11924 trigger_interval_secs__ =
11925 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11926 ;
11927 }
11928 GeneratedField::LastSuccessTime => {
11929 if last_success_time__.is_some() {
11930 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11931 }
11932 last_success_time__ = map_.next_value()?;
11933 }
11934 }
11935 }
11936 Ok(list_refresh_table_states_response::RefreshTableState {
11937 table_id: table_id__.unwrap_or_default(),
11938 current_status: current_status__.unwrap_or_default(),
11939 last_trigger_time: last_trigger_time__,
11940 trigger_interval_secs: trigger_interval_secs__,
11941 last_success_time: last_success_time__,
11942 })
11943 }
11944 }
11945 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11946 }
11947}
11948impl serde::Serialize for ListSinkLogStoreTablesRequest {
11949 #[allow(deprecated)]
11950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11951 where
11952 S: serde::Serializer,
11953 {
11954 use serde::ser::SerializeStruct;
11955 let len = 0;
11956 let struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesRequest", len)?;
11957 struct_ser.end()
11958 }
11959}
11960impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesRequest {
11961 #[allow(deprecated)]
11962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11963 where
11964 D: serde::Deserializer<'de>,
11965 {
11966 const FIELDS: &[&str] = &[
11967 ];
11968
11969 #[allow(clippy::enum_variant_names)]
11970 enum GeneratedField {
11971 }
11972 impl<'de> serde::Deserialize<'de> for GeneratedField {
11973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11974 where
11975 D: serde::Deserializer<'de>,
11976 {
11977 struct GeneratedVisitor;
11978
11979 impl serde::de::Visitor<'_> for GeneratedVisitor {
11980 type Value = GeneratedField;
11981
11982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11983 write!(formatter, "expected one of: {:?}", &FIELDS)
11984 }
11985
11986 #[allow(unused_variables)]
11987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11988 where
11989 E: serde::de::Error,
11990 {
11991 Err(serde::de::Error::unknown_field(value, FIELDS))
11992 }
11993 }
11994 deserializer.deserialize_identifier(GeneratedVisitor)
11995 }
11996 }
11997 struct GeneratedVisitor;
11998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11999 type Value = ListSinkLogStoreTablesRequest;
12000
12001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12002 formatter.write_str("struct meta.ListSinkLogStoreTablesRequest")
12003 }
12004
12005 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesRequest, V::Error>
12006 where
12007 V: serde::de::MapAccess<'de>,
12008 {
12009 while map_.next_key::<GeneratedField>()?.is_some() {
12010 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12011 }
12012 Ok(ListSinkLogStoreTablesRequest {
12013 })
12014 }
12015 }
12016 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesRequest", FIELDS, GeneratedVisitor)
12017 }
12018}
12019impl serde::Serialize for ListSinkLogStoreTablesResponse {
12020 #[allow(deprecated)]
12021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12022 where
12023 S: serde::Serializer,
12024 {
12025 use serde::ser::SerializeStruct;
12026 let mut len = 0;
12027 if !self.tables.is_empty() {
12028 len += 1;
12029 }
12030 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse", len)?;
12031 if !self.tables.is_empty() {
12032 struct_ser.serialize_field("tables", &self.tables)?;
12033 }
12034 struct_ser.end()
12035 }
12036}
12037impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesResponse {
12038 #[allow(deprecated)]
12039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12040 where
12041 D: serde::Deserializer<'de>,
12042 {
12043 const FIELDS: &[&str] = &[
12044 "tables",
12045 ];
12046
12047 #[allow(clippy::enum_variant_names)]
12048 enum GeneratedField {
12049 Tables,
12050 }
12051 impl<'de> serde::Deserialize<'de> for GeneratedField {
12052 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12053 where
12054 D: serde::Deserializer<'de>,
12055 {
12056 struct GeneratedVisitor;
12057
12058 impl serde::de::Visitor<'_> for GeneratedVisitor {
12059 type Value = GeneratedField;
12060
12061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12062 write!(formatter, "expected one of: {:?}", &FIELDS)
12063 }
12064
12065 #[allow(unused_variables)]
12066 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12067 where
12068 E: serde::de::Error,
12069 {
12070 match value {
12071 "tables" => Ok(GeneratedField::Tables),
12072 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12073 }
12074 }
12075 }
12076 deserializer.deserialize_identifier(GeneratedVisitor)
12077 }
12078 }
12079 struct GeneratedVisitor;
12080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12081 type Value = ListSinkLogStoreTablesResponse;
12082
12083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12084 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse")
12085 }
12086
12087 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesResponse, V::Error>
12088 where
12089 V: serde::de::MapAccess<'de>,
12090 {
12091 let mut tables__ = None;
12092 while let Some(k) = map_.next_key()? {
12093 match k {
12094 GeneratedField::Tables => {
12095 if tables__.is_some() {
12096 return Err(serde::de::Error::duplicate_field("tables"));
12097 }
12098 tables__ = Some(map_.next_value()?);
12099 }
12100 }
12101 }
12102 Ok(ListSinkLogStoreTablesResponse {
12103 tables: tables__.unwrap_or_default(),
12104 })
12105 }
12106 }
12107 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse", FIELDS, GeneratedVisitor)
12108 }
12109}
12110impl serde::Serialize for list_sink_log_store_tables_response::SinkLogStoreTable {
12111 #[allow(deprecated)]
12112 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12113 where
12114 S: serde::Serializer,
12115 {
12116 use serde::ser::SerializeStruct;
12117 let mut len = 0;
12118 if self.sink_id != 0 {
12119 len += 1;
12120 }
12121 if self.internal_table_id != 0 {
12122 len += 1;
12123 }
12124 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", len)?;
12125 if self.sink_id != 0 {
12126 struct_ser.serialize_field("sinkId", &self.sink_id)?;
12127 }
12128 if self.internal_table_id != 0 {
12129 struct_ser.serialize_field("internalTableId", &self.internal_table_id)?;
12130 }
12131 struct_ser.end()
12132 }
12133}
12134impl<'de> serde::Deserialize<'de> for list_sink_log_store_tables_response::SinkLogStoreTable {
12135 #[allow(deprecated)]
12136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12137 where
12138 D: serde::Deserializer<'de>,
12139 {
12140 const FIELDS: &[&str] = &[
12141 "sink_id",
12142 "sinkId",
12143 "internal_table_id",
12144 "internalTableId",
12145 ];
12146
12147 #[allow(clippy::enum_variant_names)]
12148 enum GeneratedField {
12149 SinkId,
12150 InternalTableId,
12151 }
12152 impl<'de> serde::Deserialize<'de> for GeneratedField {
12153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12154 where
12155 D: serde::Deserializer<'de>,
12156 {
12157 struct GeneratedVisitor;
12158
12159 impl serde::de::Visitor<'_> for GeneratedVisitor {
12160 type Value = GeneratedField;
12161
12162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12163 write!(formatter, "expected one of: {:?}", &FIELDS)
12164 }
12165
12166 #[allow(unused_variables)]
12167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12168 where
12169 E: serde::de::Error,
12170 {
12171 match value {
12172 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
12173 "internalTableId" | "internal_table_id" => Ok(GeneratedField::InternalTableId),
12174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12175 }
12176 }
12177 }
12178 deserializer.deserialize_identifier(GeneratedVisitor)
12179 }
12180 }
12181 struct GeneratedVisitor;
12182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12183 type Value = list_sink_log_store_tables_response::SinkLogStoreTable;
12184
12185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12186 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable")
12187 }
12188
12189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_sink_log_store_tables_response::SinkLogStoreTable, V::Error>
12190 where
12191 V: serde::de::MapAccess<'de>,
12192 {
12193 let mut sink_id__ = None;
12194 let mut internal_table_id__ = None;
12195 while let Some(k) = map_.next_key()? {
12196 match k {
12197 GeneratedField::SinkId => {
12198 if sink_id__.is_some() {
12199 return Err(serde::de::Error::duplicate_field("sinkId"));
12200 }
12201 sink_id__ =
12202 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12203 ;
12204 }
12205 GeneratedField::InternalTableId => {
12206 if internal_table_id__.is_some() {
12207 return Err(serde::de::Error::duplicate_field("internalTableId"));
12208 }
12209 internal_table_id__ =
12210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12211 ;
12212 }
12213 }
12214 }
12215 Ok(list_sink_log_store_tables_response::SinkLogStoreTable {
12216 sink_id: sink_id__.unwrap_or_default(),
12217 internal_table_id: internal_table_id__.unwrap_or_default(),
12218 })
12219 }
12220 }
12221 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", FIELDS, GeneratedVisitor)
12222 }
12223}
12224impl serde::Serialize for ListStreamingJobStatesRequest {
12225 #[allow(deprecated)]
12226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12227 where
12228 S: serde::Serializer,
12229 {
12230 use serde::ser::SerializeStruct;
12231 let len = 0;
12232 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
12233 struct_ser.end()
12234 }
12235}
12236impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
12237 #[allow(deprecated)]
12238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12239 where
12240 D: serde::Deserializer<'de>,
12241 {
12242 const FIELDS: &[&str] = &[
12243 ];
12244
12245 #[allow(clippy::enum_variant_names)]
12246 enum GeneratedField {
12247 }
12248 impl<'de> serde::Deserialize<'de> for GeneratedField {
12249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12250 where
12251 D: serde::Deserializer<'de>,
12252 {
12253 struct GeneratedVisitor;
12254
12255 impl serde::de::Visitor<'_> for GeneratedVisitor {
12256 type Value = GeneratedField;
12257
12258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12259 write!(formatter, "expected one of: {:?}", &FIELDS)
12260 }
12261
12262 #[allow(unused_variables)]
12263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12264 where
12265 E: serde::de::Error,
12266 {
12267 Err(serde::de::Error::unknown_field(value, FIELDS))
12268 }
12269 }
12270 deserializer.deserialize_identifier(GeneratedVisitor)
12271 }
12272 }
12273 struct GeneratedVisitor;
12274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12275 type Value = ListStreamingJobStatesRequest;
12276
12277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12278 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
12279 }
12280
12281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
12282 where
12283 V: serde::de::MapAccess<'de>,
12284 {
12285 while map_.next_key::<GeneratedField>()?.is_some() {
12286 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12287 }
12288 Ok(ListStreamingJobStatesRequest {
12289 })
12290 }
12291 }
12292 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
12293 }
12294}
12295impl serde::Serialize for ListStreamingJobStatesResponse {
12296 #[allow(deprecated)]
12297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12298 where
12299 S: serde::Serializer,
12300 {
12301 use serde::ser::SerializeStruct;
12302 let mut len = 0;
12303 if !self.states.is_empty() {
12304 len += 1;
12305 }
12306 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
12307 if !self.states.is_empty() {
12308 struct_ser.serialize_field("states", &self.states)?;
12309 }
12310 struct_ser.end()
12311 }
12312}
12313impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
12314 #[allow(deprecated)]
12315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12316 where
12317 D: serde::Deserializer<'de>,
12318 {
12319 const FIELDS: &[&str] = &[
12320 "states",
12321 ];
12322
12323 #[allow(clippy::enum_variant_names)]
12324 enum GeneratedField {
12325 States,
12326 }
12327 impl<'de> serde::Deserialize<'de> for GeneratedField {
12328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12329 where
12330 D: serde::Deserializer<'de>,
12331 {
12332 struct GeneratedVisitor;
12333
12334 impl serde::de::Visitor<'_> for GeneratedVisitor {
12335 type Value = GeneratedField;
12336
12337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12338 write!(formatter, "expected one of: {:?}", &FIELDS)
12339 }
12340
12341 #[allow(unused_variables)]
12342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12343 where
12344 E: serde::de::Error,
12345 {
12346 match value {
12347 "states" => Ok(GeneratedField::States),
12348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12349 }
12350 }
12351 }
12352 deserializer.deserialize_identifier(GeneratedVisitor)
12353 }
12354 }
12355 struct GeneratedVisitor;
12356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12357 type Value = ListStreamingJobStatesResponse;
12358
12359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12360 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
12361 }
12362
12363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
12364 where
12365 V: serde::de::MapAccess<'de>,
12366 {
12367 let mut states__ = None;
12368 while let Some(k) = map_.next_key()? {
12369 match k {
12370 GeneratedField::States => {
12371 if states__.is_some() {
12372 return Err(serde::de::Error::duplicate_field("states"));
12373 }
12374 states__ = Some(map_.next_value()?);
12375 }
12376 }
12377 }
12378 Ok(ListStreamingJobStatesResponse {
12379 states: states__.unwrap_or_default(),
12380 })
12381 }
12382 }
12383 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
12384 }
12385}
12386impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
12387 #[allow(deprecated)]
12388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12389 where
12390 S: serde::Serializer,
12391 {
12392 use serde::ser::SerializeStruct;
12393 let mut len = 0;
12394 if self.table_id != 0 {
12395 len += 1;
12396 }
12397 if self.state != 0 {
12398 len += 1;
12399 }
12400 if self.parallelism.is_some() {
12401 len += 1;
12402 }
12403 if self.max_parallelism != 0 {
12404 len += 1;
12405 }
12406 if !self.name.is_empty() {
12407 len += 1;
12408 }
12409 if !self.resource_group.is_empty() {
12410 len += 1;
12411 }
12412 if !self.config_override.is_empty() {
12413 len += 1;
12414 }
12415 if self.database_id != 0 {
12416 len += 1;
12417 }
12418 if self.schema_id != 0 {
12419 len += 1;
12420 }
12421 if self.adaptive_parallelism_strategy.is_some() {
12422 len += 1;
12423 }
12424 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12425 if self.table_id != 0 {
12426 struct_ser.serialize_field("tableId", &self.table_id)?;
12427 }
12428 if self.state != 0 {
12429 let v = table_fragments::State::try_from(self.state)
12430 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12431 struct_ser.serialize_field("state", &v)?;
12432 }
12433 if let Some(v) = self.parallelism.as_ref() {
12434 struct_ser.serialize_field("parallelism", v)?;
12435 }
12436 if self.max_parallelism != 0 {
12437 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12438 }
12439 if !self.name.is_empty() {
12440 struct_ser.serialize_field("name", &self.name)?;
12441 }
12442 if !self.resource_group.is_empty() {
12443 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12444 }
12445 if !self.config_override.is_empty() {
12446 struct_ser.serialize_field("configOverride", &self.config_override)?;
12447 }
12448 if self.database_id != 0 {
12449 struct_ser.serialize_field("databaseId", &self.database_id)?;
12450 }
12451 if self.schema_id != 0 {
12452 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12453 }
12454 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
12455 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
12456 }
12457 struct_ser.end()
12458 }
12459}
12460impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12461 #[allow(deprecated)]
12462 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12463 where
12464 D: serde::Deserializer<'de>,
12465 {
12466 const FIELDS: &[&str] = &[
12467 "table_id",
12468 "tableId",
12469 "state",
12470 "parallelism",
12471 "max_parallelism",
12472 "maxParallelism",
12473 "name",
12474 "resource_group",
12475 "resourceGroup",
12476 "config_override",
12477 "configOverride",
12478 "database_id",
12479 "databaseId",
12480 "schema_id",
12481 "schemaId",
12482 "adaptive_parallelism_strategy",
12483 "adaptiveParallelismStrategy",
12484 ];
12485
12486 #[allow(clippy::enum_variant_names)]
12487 enum GeneratedField {
12488 TableId,
12489 State,
12490 Parallelism,
12491 MaxParallelism,
12492 Name,
12493 ResourceGroup,
12494 ConfigOverride,
12495 DatabaseId,
12496 SchemaId,
12497 AdaptiveParallelismStrategy,
12498 }
12499 impl<'de> serde::Deserialize<'de> for GeneratedField {
12500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12501 where
12502 D: serde::Deserializer<'de>,
12503 {
12504 struct GeneratedVisitor;
12505
12506 impl serde::de::Visitor<'_> for GeneratedVisitor {
12507 type Value = GeneratedField;
12508
12509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12510 write!(formatter, "expected one of: {:?}", &FIELDS)
12511 }
12512
12513 #[allow(unused_variables)]
12514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12515 where
12516 E: serde::de::Error,
12517 {
12518 match value {
12519 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12520 "state" => Ok(GeneratedField::State),
12521 "parallelism" => Ok(GeneratedField::Parallelism),
12522 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12523 "name" => Ok(GeneratedField::Name),
12524 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12525 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12526 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12527 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12528 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12530 }
12531 }
12532 }
12533 deserializer.deserialize_identifier(GeneratedVisitor)
12534 }
12535 }
12536 struct GeneratedVisitor;
12537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12538 type Value = list_streaming_job_states_response::StreamingJobState;
12539
12540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12541 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12542 }
12543
12544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12545 where
12546 V: serde::de::MapAccess<'de>,
12547 {
12548 let mut table_id__ = None;
12549 let mut state__ = None;
12550 let mut parallelism__ = None;
12551 let mut max_parallelism__ = None;
12552 let mut name__ = None;
12553 let mut resource_group__ = None;
12554 let mut config_override__ = None;
12555 let mut database_id__ = None;
12556 let mut schema_id__ = None;
12557 let mut adaptive_parallelism_strategy__ = None;
12558 while let Some(k) = map_.next_key()? {
12559 match k {
12560 GeneratedField::TableId => {
12561 if table_id__.is_some() {
12562 return Err(serde::de::Error::duplicate_field("tableId"));
12563 }
12564 table_id__ =
12565 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12566 ;
12567 }
12568 GeneratedField::State => {
12569 if state__.is_some() {
12570 return Err(serde::de::Error::duplicate_field("state"));
12571 }
12572 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12573 }
12574 GeneratedField::Parallelism => {
12575 if parallelism__.is_some() {
12576 return Err(serde::de::Error::duplicate_field("parallelism"));
12577 }
12578 parallelism__ = map_.next_value()?;
12579 }
12580 GeneratedField::MaxParallelism => {
12581 if max_parallelism__.is_some() {
12582 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12583 }
12584 max_parallelism__ =
12585 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12586 ;
12587 }
12588 GeneratedField::Name => {
12589 if name__.is_some() {
12590 return Err(serde::de::Error::duplicate_field("name"));
12591 }
12592 name__ = Some(map_.next_value()?);
12593 }
12594 GeneratedField::ResourceGroup => {
12595 if resource_group__.is_some() {
12596 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12597 }
12598 resource_group__ = Some(map_.next_value()?);
12599 }
12600 GeneratedField::ConfigOverride => {
12601 if config_override__.is_some() {
12602 return Err(serde::de::Error::duplicate_field("configOverride"));
12603 }
12604 config_override__ = Some(map_.next_value()?);
12605 }
12606 GeneratedField::DatabaseId => {
12607 if database_id__.is_some() {
12608 return Err(serde::de::Error::duplicate_field("databaseId"));
12609 }
12610 database_id__ =
12611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12612 ;
12613 }
12614 GeneratedField::SchemaId => {
12615 if schema_id__.is_some() {
12616 return Err(serde::de::Error::duplicate_field("schemaId"));
12617 }
12618 schema_id__ =
12619 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12620 ;
12621 }
12622 GeneratedField::AdaptiveParallelismStrategy => {
12623 if adaptive_parallelism_strategy__.is_some() {
12624 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12625 }
12626 adaptive_parallelism_strategy__ = map_.next_value()?;
12627 }
12628 }
12629 }
12630 Ok(list_streaming_job_states_response::StreamingJobState {
12631 table_id: table_id__.unwrap_or_default(),
12632 state: state__.unwrap_or_default(),
12633 parallelism: parallelism__,
12634 max_parallelism: max_parallelism__.unwrap_or_default(),
12635 name: name__.unwrap_or_default(),
12636 resource_group: resource_group__.unwrap_or_default(),
12637 config_override: config_override__.unwrap_or_default(),
12638 database_id: database_id__.unwrap_or_default(),
12639 schema_id: schema_id__.unwrap_or_default(),
12640 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
12641 })
12642 }
12643 }
12644 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12645 }
12646}
12647impl serde::Serialize for ListTableFragmentsRequest {
12648 #[allow(deprecated)]
12649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12650 where
12651 S: serde::Serializer,
12652 {
12653 use serde::ser::SerializeStruct;
12654 let mut len = 0;
12655 if !self.table_ids.is_empty() {
12656 len += 1;
12657 }
12658 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12659 if !self.table_ids.is_empty() {
12660 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12661 }
12662 struct_ser.end()
12663 }
12664}
12665impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12666 #[allow(deprecated)]
12667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12668 where
12669 D: serde::Deserializer<'de>,
12670 {
12671 const FIELDS: &[&str] = &[
12672 "table_ids",
12673 "tableIds",
12674 ];
12675
12676 #[allow(clippy::enum_variant_names)]
12677 enum GeneratedField {
12678 TableIds,
12679 }
12680 impl<'de> serde::Deserialize<'de> for GeneratedField {
12681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12682 where
12683 D: serde::Deserializer<'de>,
12684 {
12685 struct GeneratedVisitor;
12686
12687 impl serde::de::Visitor<'_> for GeneratedVisitor {
12688 type Value = GeneratedField;
12689
12690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12691 write!(formatter, "expected one of: {:?}", &FIELDS)
12692 }
12693
12694 #[allow(unused_variables)]
12695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12696 where
12697 E: serde::de::Error,
12698 {
12699 match value {
12700 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12702 }
12703 }
12704 }
12705 deserializer.deserialize_identifier(GeneratedVisitor)
12706 }
12707 }
12708 struct GeneratedVisitor;
12709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12710 type Value = ListTableFragmentsRequest;
12711
12712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12713 formatter.write_str("struct meta.ListTableFragmentsRequest")
12714 }
12715
12716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12717 where
12718 V: serde::de::MapAccess<'de>,
12719 {
12720 let mut table_ids__ = None;
12721 while let Some(k) = map_.next_key()? {
12722 match k {
12723 GeneratedField::TableIds => {
12724 if table_ids__.is_some() {
12725 return Err(serde::de::Error::duplicate_field("tableIds"));
12726 }
12727 table_ids__ =
12728 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12729 .into_iter().map(|x| x.0).collect())
12730 ;
12731 }
12732 }
12733 }
12734 Ok(ListTableFragmentsRequest {
12735 table_ids: table_ids__.unwrap_or_default(),
12736 })
12737 }
12738 }
12739 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12740 }
12741}
12742impl serde::Serialize for ListTableFragmentsResponse {
12743 #[allow(deprecated)]
12744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12745 where
12746 S: serde::Serializer,
12747 {
12748 use serde::ser::SerializeStruct;
12749 let mut len = 0;
12750 if !self.table_fragments.is_empty() {
12751 len += 1;
12752 }
12753 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12754 if !self.table_fragments.is_empty() {
12755 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12756 }
12757 struct_ser.end()
12758 }
12759}
12760impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12761 #[allow(deprecated)]
12762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12763 where
12764 D: serde::Deserializer<'de>,
12765 {
12766 const FIELDS: &[&str] = &[
12767 "table_fragments",
12768 "tableFragments",
12769 ];
12770
12771 #[allow(clippy::enum_variant_names)]
12772 enum GeneratedField {
12773 TableFragments,
12774 }
12775 impl<'de> serde::Deserialize<'de> for GeneratedField {
12776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12777 where
12778 D: serde::Deserializer<'de>,
12779 {
12780 struct GeneratedVisitor;
12781
12782 impl serde::de::Visitor<'_> for GeneratedVisitor {
12783 type Value = GeneratedField;
12784
12785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12786 write!(formatter, "expected one of: {:?}", &FIELDS)
12787 }
12788
12789 #[allow(unused_variables)]
12790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12791 where
12792 E: serde::de::Error,
12793 {
12794 match value {
12795 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
12796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12797 }
12798 }
12799 }
12800 deserializer.deserialize_identifier(GeneratedVisitor)
12801 }
12802 }
12803 struct GeneratedVisitor;
12804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12805 type Value = ListTableFragmentsResponse;
12806
12807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12808 formatter.write_str("struct meta.ListTableFragmentsResponse")
12809 }
12810
12811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12812 where
12813 V: serde::de::MapAccess<'de>,
12814 {
12815 let mut table_fragments__ = None;
12816 while let Some(k) = map_.next_key()? {
12817 match k {
12818 GeneratedField::TableFragments => {
12819 if table_fragments__.is_some() {
12820 return Err(serde::de::Error::duplicate_field("tableFragments"));
12821 }
12822 table_fragments__ = Some(
12823 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12824 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12825 );
12826 }
12827 }
12828 }
12829 Ok(ListTableFragmentsResponse {
12830 table_fragments: table_fragments__.unwrap_or_default(),
12831 })
12832 }
12833 }
12834 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
12835 }
12836}
12837impl serde::Serialize for list_table_fragments_response::ActorInfo {
12838 #[allow(deprecated)]
12839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12840 where
12841 S: serde::Serializer,
12842 {
12843 use serde::ser::SerializeStruct;
12844 let mut len = 0;
12845 if self.id != 0 {
12846 len += 1;
12847 }
12848 if self.node.is_some() {
12849 len += 1;
12850 }
12851 if !self.dispatcher.is_empty() {
12852 len += 1;
12853 }
12854 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
12855 if self.id != 0 {
12856 struct_ser.serialize_field("id", &self.id)?;
12857 }
12858 if let Some(v) = self.node.as_ref() {
12859 struct_ser.serialize_field("node", v)?;
12860 }
12861 if !self.dispatcher.is_empty() {
12862 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12863 }
12864 struct_ser.end()
12865 }
12866}
12867impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
12868 #[allow(deprecated)]
12869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12870 where
12871 D: serde::Deserializer<'de>,
12872 {
12873 const FIELDS: &[&str] = &[
12874 "id",
12875 "node",
12876 "dispatcher",
12877 ];
12878
12879 #[allow(clippy::enum_variant_names)]
12880 enum GeneratedField {
12881 Id,
12882 Node,
12883 Dispatcher,
12884 }
12885 impl<'de> serde::Deserialize<'de> for GeneratedField {
12886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12887 where
12888 D: serde::Deserializer<'de>,
12889 {
12890 struct GeneratedVisitor;
12891
12892 impl serde::de::Visitor<'_> for GeneratedVisitor {
12893 type Value = GeneratedField;
12894
12895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12896 write!(formatter, "expected one of: {:?}", &FIELDS)
12897 }
12898
12899 #[allow(unused_variables)]
12900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12901 where
12902 E: serde::de::Error,
12903 {
12904 match value {
12905 "id" => Ok(GeneratedField::Id),
12906 "node" => Ok(GeneratedField::Node),
12907 "dispatcher" => Ok(GeneratedField::Dispatcher),
12908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12909 }
12910 }
12911 }
12912 deserializer.deserialize_identifier(GeneratedVisitor)
12913 }
12914 }
12915 struct GeneratedVisitor;
12916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12917 type Value = list_table_fragments_response::ActorInfo;
12918
12919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12920 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
12921 }
12922
12923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12924 where
12925 V: serde::de::MapAccess<'de>,
12926 {
12927 let mut id__ = None;
12928 let mut node__ = None;
12929 let mut dispatcher__ = None;
12930 while let Some(k) = map_.next_key()? {
12931 match k {
12932 GeneratedField::Id => {
12933 if id__.is_some() {
12934 return Err(serde::de::Error::duplicate_field("id"));
12935 }
12936 id__ =
12937 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12938 ;
12939 }
12940 GeneratedField::Node => {
12941 if node__.is_some() {
12942 return Err(serde::de::Error::duplicate_field("node"));
12943 }
12944 node__ = map_.next_value()?;
12945 }
12946 GeneratedField::Dispatcher => {
12947 if dispatcher__.is_some() {
12948 return Err(serde::de::Error::duplicate_field("dispatcher"));
12949 }
12950 dispatcher__ = Some(map_.next_value()?);
12951 }
12952 }
12953 }
12954 Ok(list_table_fragments_response::ActorInfo {
12955 id: id__.unwrap_or_default(),
12956 node: node__,
12957 dispatcher: dispatcher__.unwrap_or_default(),
12958 })
12959 }
12960 }
12961 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12962 }
12963}
12964impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12965 #[allow(deprecated)]
12966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12967 where
12968 S: serde::Serializer,
12969 {
12970 use serde::ser::SerializeStruct;
12971 let mut len = 0;
12972 if self.id != 0 {
12973 len += 1;
12974 }
12975 if !self.actors.is_empty() {
12976 len += 1;
12977 }
12978 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12979 if self.id != 0 {
12980 struct_ser.serialize_field("id", &self.id)?;
12981 }
12982 if !self.actors.is_empty() {
12983 struct_ser.serialize_field("actors", &self.actors)?;
12984 }
12985 struct_ser.end()
12986 }
12987}
12988impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12989 #[allow(deprecated)]
12990 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12991 where
12992 D: serde::Deserializer<'de>,
12993 {
12994 const FIELDS: &[&str] = &[
12995 "id",
12996 "actors",
12997 ];
12998
12999 #[allow(clippy::enum_variant_names)]
13000 enum GeneratedField {
13001 Id,
13002 Actors,
13003 }
13004 impl<'de> serde::Deserialize<'de> for GeneratedField {
13005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13006 where
13007 D: serde::Deserializer<'de>,
13008 {
13009 struct GeneratedVisitor;
13010
13011 impl serde::de::Visitor<'_> for GeneratedVisitor {
13012 type Value = GeneratedField;
13013
13014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13015 write!(formatter, "expected one of: {:?}", &FIELDS)
13016 }
13017
13018 #[allow(unused_variables)]
13019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13020 where
13021 E: serde::de::Error,
13022 {
13023 match value {
13024 "id" => Ok(GeneratedField::Id),
13025 "actors" => Ok(GeneratedField::Actors),
13026 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13027 }
13028 }
13029 }
13030 deserializer.deserialize_identifier(GeneratedVisitor)
13031 }
13032 }
13033 struct GeneratedVisitor;
13034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13035 type Value = list_table_fragments_response::FragmentInfo;
13036
13037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13038 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
13039 }
13040
13041 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
13042 where
13043 V: serde::de::MapAccess<'de>,
13044 {
13045 let mut id__ = None;
13046 let mut actors__ = None;
13047 while let Some(k) = map_.next_key()? {
13048 match k {
13049 GeneratedField::Id => {
13050 if id__.is_some() {
13051 return Err(serde::de::Error::duplicate_field("id"));
13052 }
13053 id__ =
13054 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13055 ;
13056 }
13057 GeneratedField::Actors => {
13058 if actors__.is_some() {
13059 return Err(serde::de::Error::duplicate_field("actors"));
13060 }
13061 actors__ = Some(map_.next_value()?);
13062 }
13063 }
13064 }
13065 Ok(list_table_fragments_response::FragmentInfo {
13066 id: id__.unwrap_or_default(),
13067 actors: actors__.unwrap_or_default(),
13068 })
13069 }
13070 }
13071 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
13072 }
13073}
13074impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
13075 #[allow(deprecated)]
13076 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13077 where
13078 S: serde::Serializer,
13079 {
13080 use serde::ser::SerializeStruct;
13081 let mut len = 0;
13082 if !self.fragments.is_empty() {
13083 len += 1;
13084 }
13085 if self.ctx.is_some() {
13086 len += 1;
13087 }
13088 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
13089 if !self.fragments.is_empty() {
13090 struct_ser.serialize_field("fragments", &self.fragments)?;
13091 }
13092 if let Some(v) = self.ctx.as_ref() {
13093 struct_ser.serialize_field("ctx", v)?;
13094 }
13095 struct_ser.end()
13096 }
13097}
13098impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
13099 #[allow(deprecated)]
13100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13101 where
13102 D: serde::Deserializer<'de>,
13103 {
13104 const FIELDS: &[&str] = &[
13105 "fragments",
13106 "ctx",
13107 ];
13108
13109 #[allow(clippy::enum_variant_names)]
13110 enum GeneratedField {
13111 Fragments,
13112 Ctx,
13113 }
13114 impl<'de> serde::Deserialize<'de> for GeneratedField {
13115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13116 where
13117 D: serde::Deserializer<'de>,
13118 {
13119 struct GeneratedVisitor;
13120
13121 impl serde::de::Visitor<'_> for GeneratedVisitor {
13122 type Value = GeneratedField;
13123
13124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13125 write!(formatter, "expected one of: {:?}", &FIELDS)
13126 }
13127
13128 #[allow(unused_variables)]
13129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13130 where
13131 E: serde::de::Error,
13132 {
13133 match value {
13134 "fragments" => Ok(GeneratedField::Fragments),
13135 "ctx" => Ok(GeneratedField::Ctx),
13136 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13137 }
13138 }
13139 }
13140 deserializer.deserialize_identifier(GeneratedVisitor)
13141 }
13142 }
13143 struct GeneratedVisitor;
13144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13145 type Value = list_table_fragments_response::TableFragmentInfo;
13146
13147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13148 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
13149 }
13150
13151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
13152 where
13153 V: serde::de::MapAccess<'de>,
13154 {
13155 let mut fragments__ = None;
13156 let mut ctx__ = None;
13157 while let Some(k) = map_.next_key()? {
13158 match k {
13159 GeneratedField::Fragments => {
13160 if fragments__.is_some() {
13161 return Err(serde::de::Error::duplicate_field("fragments"));
13162 }
13163 fragments__ = Some(map_.next_value()?);
13164 }
13165 GeneratedField::Ctx => {
13166 if ctx__.is_some() {
13167 return Err(serde::de::Error::duplicate_field("ctx"));
13168 }
13169 ctx__ = map_.next_value()?;
13170 }
13171 }
13172 }
13173 Ok(list_table_fragments_response::TableFragmentInfo {
13174 fragments: fragments__.unwrap_or_default(),
13175 ctx: ctx__,
13176 })
13177 }
13178 }
13179 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
13180 }
13181}
13182impl serde::Serialize for ListUnmigratedTablesRequest {
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 len = 0;
13190 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
13191 struct_ser.end()
13192 }
13193}
13194impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
13195 #[allow(deprecated)]
13196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13197 where
13198 D: serde::Deserializer<'de>,
13199 {
13200 const FIELDS: &[&str] = &[
13201 ];
13202
13203 #[allow(clippy::enum_variant_names)]
13204 enum GeneratedField {
13205 }
13206 impl<'de> serde::Deserialize<'de> for GeneratedField {
13207 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13208 where
13209 D: serde::Deserializer<'de>,
13210 {
13211 struct GeneratedVisitor;
13212
13213 impl serde::de::Visitor<'_> for GeneratedVisitor {
13214 type Value = GeneratedField;
13215
13216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13217 write!(formatter, "expected one of: {:?}", &FIELDS)
13218 }
13219
13220 #[allow(unused_variables)]
13221 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13222 where
13223 E: serde::de::Error,
13224 {
13225 Err(serde::de::Error::unknown_field(value, FIELDS))
13226 }
13227 }
13228 deserializer.deserialize_identifier(GeneratedVisitor)
13229 }
13230 }
13231 struct GeneratedVisitor;
13232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13233 type Value = ListUnmigratedTablesRequest;
13234
13235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13236 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
13237 }
13238
13239 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
13240 where
13241 V: serde::de::MapAccess<'de>,
13242 {
13243 while map_.next_key::<GeneratedField>()?.is_some() {
13244 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13245 }
13246 Ok(ListUnmigratedTablesRequest {
13247 })
13248 }
13249 }
13250 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
13251 }
13252}
13253impl serde::Serialize for ListUnmigratedTablesResponse {
13254 #[allow(deprecated)]
13255 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13256 where
13257 S: serde::Serializer,
13258 {
13259 use serde::ser::SerializeStruct;
13260 let mut len = 0;
13261 if !self.tables.is_empty() {
13262 len += 1;
13263 }
13264 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
13265 if !self.tables.is_empty() {
13266 struct_ser.serialize_field("tables", &self.tables)?;
13267 }
13268 struct_ser.end()
13269 }
13270}
13271impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
13272 #[allow(deprecated)]
13273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13274 where
13275 D: serde::Deserializer<'de>,
13276 {
13277 const FIELDS: &[&str] = &[
13278 "tables",
13279 ];
13280
13281 #[allow(clippy::enum_variant_names)]
13282 enum GeneratedField {
13283 Tables,
13284 }
13285 impl<'de> serde::Deserialize<'de> for GeneratedField {
13286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13287 where
13288 D: serde::Deserializer<'de>,
13289 {
13290 struct GeneratedVisitor;
13291
13292 impl serde::de::Visitor<'_> for GeneratedVisitor {
13293 type Value = GeneratedField;
13294
13295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13296 write!(formatter, "expected one of: {:?}", &FIELDS)
13297 }
13298
13299 #[allow(unused_variables)]
13300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13301 where
13302 E: serde::de::Error,
13303 {
13304 match value {
13305 "tables" => Ok(GeneratedField::Tables),
13306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13307 }
13308 }
13309 }
13310 deserializer.deserialize_identifier(GeneratedVisitor)
13311 }
13312 }
13313 struct GeneratedVisitor;
13314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13315 type Value = ListUnmigratedTablesResponse;
13316
13317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13318 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
13319 }
13320
13321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
13322 where
13323 V: serde::de::MapAccess<'de>,
13324 {
13325 let mut tables__ = None;
13326 while let Some(k) = map_.next_key()? {
13327 match k {
13328 GeneratedField::Tables => {
13329 if tables__.is_some() {
13330 return Err(serde::de::Error::duplicate_field("tables"));
13331 }
13332 tables__ = Some(map_.next_value()?);
13333 }
13334 }
13335 }
13336 Ok(ListUnmigratedTablesResponse {
13337 tables: tables__.unwrap_or_default(),
13338 })
13339 }
13340 }
13341 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
13342 }
13343}
13344impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
13345 #[allow(deprecated)]
13346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13347 where
13348 S: serde::Serializer,
13349 {
13350 use serde::ser::SerializeStruct;
13351 let mut len = 0;
13352 if self.table_id != 0 {
13353 len += 1;
13354 }
13355 if !self.table_name.is_empty() {
13356 len += 1;
13357 }
13358 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
13359 if self.table_id != 0 {
13360 struct_ser.serialize_field("tableId", &self.table_id)?;
13361 }
13362 if !self.table_name.is_empty() {
13363 struct_ser.serialize_field("tableName", &self.table_name)?;
13364 }
13365 struct_ser.end()
13366 }
13367}
13368impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
13369 #[allow(deprecated)]
13370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13371 where
13372 D: serde::Deserializer<'de>,
13373 {
13374 const FIELDS: &[&str] = &[
13375 "table_id",
13376 "tableId",
13377 "table_name",
13378 "tableName",
13379 ];
13380
13381 #[allow(clippy::enum_variant_names)]
13382 enum GeneratedField {
13383 TableId,
13384 TableName,
13385 }
13386 impl<'de> serde::Deserialize<'de> for GeneratedField {
13387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13388 where
13389 D: serde::Deserializer<'de>,
13390 {
13391 struct GeneratedVisitor;
13392
13393 impl serde::de::Visitor<'_> for GeneratedVisitor {
13394 type Value = GeneratedField;
13395
13396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13397 write!(formatter, "expected one of: {:?}", &FIELDS)
13398 }
13399
13400 #[allow(unused_variables)]
13401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13402 where
13403 E: serde::de::Error,
13404 {
13405 match value {
13406 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13407 "tableName" | "table_name" => Ok(GeneratedField::TableName),
13408 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13409 }
13410 }
13411 }
13412 deserializer.deserialize_identifier(GeneratedVisitor)
13413 }
13414 }
13415 struct GeneratedVisitor;
13416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13417 type Value = list_unmigrated_tables_response::UnmigratedTable;
13418
13419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13420 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
13421 }
13422
13423 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
13424 where
13425 V: serde::de::MapAccess<'de>,
13426 {
13427 let mut table_id__ = None;
13428 let mut table_name__ = None;
13429 while let Some(k) = map_.next_key()? {
13430 match k {
13431 GeneratedField::TableId => {
13432 if table_id__.is_some() {
13433 return Err(serde::de::Error::duplicate_field("tableId"));
13434 }
13435 table_id__ =
13436 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13437 ;
13438 }
13439 GeneratedField::TableName => {
13440 if table_name__.is_some() {
13441 return Err(serde::de::Error::duplicate_field("tableName"));
13442 }
13443 table_name__ = Some(map_.next_value()?);
13444 }
13445 }
13446 }
13447 Ok(list_unmigrated_tables_response::UnmigratedTable {
13448 table_id: table_id__.unwrap_or_default(),
13449 table_name: table_name__.unwrap_or_default(),
13450 })
13451 }
13452 }
13453 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13454 }
13455}
13456impl serde::Serialize for MembersRequest {
13457 #[allow(deprecated)]
13458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13459 where
13460 S: serde::Serializer,
13461 {
13462 use serde::ser::SerializeStruct;
13463 let len = 0;
13464 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13465 struct_ser.end()
13466 }
13467}
13468impl<'de> serde::Deserialize<'de> for MembersRequest {
13469 #[allow(deprecated)]
13470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13471 where
13472 D: serde::Deserializer<'de>,
13473 {
13474 const FIELDS: &[&str] = &[
13475 ];
13476
13477 #[allow(clippy::enum_variant_names)]
13478 enum GeneratedField {
13479 }
13480 impl<'de> serde::Deserialize<'de> for GeneratedField {
13481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13482 where
13483 D: serde::Deserializer<'de>,
13484 {
13485 struct GeneratedVisitor;
13486
13487 impl serde::de::Visitor<'_> for GeneratedVisitor {
13488 type Value = GeneratedField;
13489
13490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13491 write!(formatter, "expected one of: {:?}", &FIELDS)
13492 }
13493
13494 #[allow(unused_variables)]
13495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13496 where
13497 E: serde::de::Error,
13498 {
13499 Err(serde::de::Error::unknown_field(value, FIELDS))
13500 }
13501 }
13502 deserializer.deserialize_identifier(GeneratedVisitor)
13503 }
13504 }
13505 struct GeneratedVisitor;
13506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13507 type Value = MembersRequest;
13508
13509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13510 formatter.write_str("struct meta.MembersRequest")
13511 }
13512
13513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13514 where
13515 V: serde::de::MapAccess<'de>,
13516 {
13517 while map_.next_key::<GeneratedField>()?.is_some() {
13518 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13519 }
13520 Ok(MembersRequest {
13521 })
13522 }
13523 }
13524 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13525 }
13526}
13527impl serde::Serialize for MembersResponse {
13528 #[allow(deprecated)]
13529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13530 where
13531 S: serde::Serializer,
13532 {
13533 use serde::ser::SerializeStruct;
13534 let mut len = 0;
13535 if !self.members.is_empty() {
13536 len += 1;
13537 }
13538 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13539 if !self.members.is_empty() {
13540 struct_ser.serialize_field("members", &self.members)?;
13541 }
13542 struct_ser.end()
13543 }
13544}
13545impl<'de> serde::Deserialize<'de> for MembersResponse {
13546 #[allow(deprecated)]
13547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13548 where
13549 D: serde::Deserializer<'de>,
13550 {
13551 const FIELDS: &[&str] = &[
13552 "members",
13553 ];
13554
13555 #[allow(clippy::enum_variant_names)]
13556 enum GeneratedField {
13557 Members,
13558 }
13559 impl<'de> serde::Deserialize<'de> for GeneratedField {
13560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13561 where
13562 D: serde::Deserializer<'de>,
13563 {
13564 struct GeneratedVisitor;
13565
13566 impl serde::de::Visitor<'_> for GeneratedVisitor {
13567 type Value = GeneratedField;
13568
13569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13570 write!(formatter, "expected one of: {:?}", &FIELDS)
13571 }
13572
13573 #[allow(unused_variables)]
13574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13575 where
13576 E: serde::de::Error,
13577 {
13578 match value {
13579 "members" => Ok(GeneratedField::Members),
13580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13581 }
13582 }
13583 }
13584 deserializer.deserialize_identifier(GeneratedVisitor)
13585 }
13586 }
13587 struct GeneratedVisitor;
13588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13589 type Value = MembersResponse;
13590
13591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13592 formatter.write_str("struct meta.MembersResponse")
13593 }
13594
13595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13596 where
13597 V: serde::de::MapAccess<'de>,
13598 {
13599 let mut members__ = None;
13600 while let Some(k) = map_.next_key()? {
13601 match k {
13602 GeneratedField::Members => {
13603 if members__.is_some() {
13604 return Err(serde::de::Error::duplicate_field("members"));
13605 }
13606 members__ = Some(map_.next_value()?);
13607 }
13608 }
13609 }
13610 Ok(MembersResponse {
13611 members: members__.unwrap_or_default(),
13612 })
13613 }
13614 }
13615 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13616 }
13617}
13618impl serde::Serialize for MetaMember {
13619 #[allow(deprecated)]
13620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13621 where
13622 S: serde::Serializer,
13623 {
13624 use serde::ser::SerializeStruct;
13625 let mut len = 0;
13626 if self.address.is_some() {
13627 len += 1;
13628 }
13629 if self.is_leader {
13630 len += 1;
13631 }
13632 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13633 if let Some(v) = self.address.as_ref() {
13634 struct_ser.serialize_field("address", v)?;
13635 }
13636 if self.is_leader {
13637 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13638 }
13639 struct_ser.end()
13640 }
13641}
13642impl<'de> serde::Deserialize<'de> for MetaMember {
13643 #[allow(deprecated)]
13644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13645 where
13646 D: serde::Deserializer<'de>,
13647 {
13648 const FIELDS: &[&str] = &[
13649 "address",
13650 "is_leader",
13651 "isLeader",
13652 ];
13653
13654 #[allow(clippy::enum_variant_names)]
13655 enum GeneratedField {
13656 Address,
13657 IsLeader,
13658 }
13659 impl<'de> serde::Deserialize<'de> for GeneratedField {
13660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13661 where
13662 D: serde::Deserializer<'de>,
13663 {
13664 struct GeneratedVisitor;
13665
13666 impl serde::de::Visitor<'_> for GeneratedVisitor {
13667 type Value = GeneratedField;
13668
13669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13670 write!(formatter, "expected one of: {:?}", &FIELDS)
13671 }
13672
13673 #[allow(unused_variables)]
13674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13675 where
13676 E: serde::de::Error,
13677 {
13678 match value {
13679 "address" => Ok(GeneratedField::Address),
13680 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13682 }
13683 }
13684 }
13685 deserializer.deserialize_identifier(GeneratedVisitor)
13686 }
13687 }
13688 struct GeneratedVisitor;
13689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13690 type Value = MetaMember;
13691
13692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13693 formatter.write_str("struct meta.MetaMember")
13694 }
13695
13696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13697 where
13698 V: serde::de::MapAccess<'de>,
13699 {
13700 let mut address__ = None;
13701 let mut is_leader__ = None;
13702 while let Some(k) = map_.next_key()? {
13703 match k {
13704 GeneratedField::Address => {
13705 if address__.is_some() {
13706 return Err(serde::de::Error::duplicate_field("address"));
13707 }
13708 address__ = map_.next_value()?;
13709 }
13710 GeneratedField::IsLeader => {
13711 if is_leader__.is_some() {
13712 return Err(serde::de::Error::duplicate_field("isLeader"));
13713 }
13714 is_leader__ = Some(map_.next_value()?);
13715 }
13716 }
13717 }
13718 Ok(MetaMember {
13719 address: address__,
13720 is_leader: is_leader__.unwrap_or_default(),
13721 })
13722 }
13723 }
13724 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13725 }
13726}
13727impl serde::Serialize for MetaSnapshot {
13728 #[allow(deprecated)]
13729 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13730 where
13731 S: serde::Serializer,
13732 {
13733 use serde::ser::SerializeStruct;
13734 let mut len = 0;
13735 if !self.databases.is_empty() {
13736 len += 1;
13737 }
13738 if !self.schemas.is_empty() {
13739 len += 1;
13740 }
13741 if !self.sources.is_empty() {
13742 len += 1;
13743 }
13744 if !self.sinks.is_empty() {
13745 len += 1;
13746 }
13747 if !self.tables.is_empty() {
13748 len += 1;
13749 }
13750 if !self.indexes.is_empty() {
13751 len += 1;
13752 }
13753 if !self.views.is_empty() {
13754 len += 1;
13755 }
13756 if !self.functions.is_empty() {
13757 len += 1;
13758 }
13759 if !self.connections.is_empty() {
13760 len += 1;
13761 }
13762 if !self.subscriptions.is_empty() {
13763 len += 1;
13764 }
13765 if !self.users.is_empty() {
13766 len += 1;
13767 }
13768 if self.session_params.is_some() {
13769 len += 1;
13770 }
13771 if !self.secrets.is_empty() {
13772 len += 1;
13773 }
13774 if self.cluster_resource.is_some() {
13775 len += 1;
13776 }
13777 if !self.nodes.is_empty() {
13778 len += 1;
13779 }
13780 if self.hummock_version.is_some() {
13781 len += 1;
13782 }
13783 if self.meta_backup_manifest_id.is_some() {
13784 len += 1;
13785 }
13786 if self.hummock_write_limits.is_some() {
13787 len += 1;
13788 }
13789 if !self.streaming_worker_slot_mappings.is_empty() {
13790 len += 1;
13791 }
13792 if !self.serving_worker_slot_mappings.is_empty() {
13793 len += 1;
13794 }
13795 if !self.object_dependencies.is_empty() {
13796 len += 1;
13797 }
13798 if self.version.is_some() {
13799 len += 1;
13800 }
13801 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13802 if !self.databases.is_empty() {
13803 struct_ser.serialize_field("databases", &self.databases)?;
13804 }
13805 if !self.schemas.is_empty() {
13806 struct_ser.serialize_field("schemas", &self.schemas)?;
13807 }
13808 if !self.sources.is_empty() {
13809 struct_ser.serialize_field("sources", &self.sources)?;
13810 }
13811 if !self.sinks.is_empty() {
13812 struct_ser.serialize_field("sinks", &self.sinks)?;
13813 }
13814 if !self.tables.is_empty() {
13815 struct_ser.serialize_field("tables", &self.tables)?;
13816 }
13817 if !self.indexes.is_empty() {
13818 struct_ser.serialize_field("indexes", &self.indexes)?;
13819 }
13820 if !self.views.is_empty() {
13821 struct_ser.serialize_field("views", &self.views)?;
13822 }
13823 if !self.functions.is_empty() {
13824 struct_ser.serialize_field("functions", &self.functions)?;
13825 }
13826 if !self.connections.is_empty() {
13827 struct_ser.serialize_field("connections", &self.connections)?;
13828 }
13829 if !self.subscriptions.is_empty() {
13830 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13831 }
13832 if !self.users.is_empty() {
13833 struct_ser.serialize_field("users", &self.users)?;
13834 }
13835 if let Some(v) = self.session_params.as_ref() {
13836 struct_ser.serialize_field("sessionParams", v)?;
13837 }
13838 if !self.secrets.is_empty() {
13839 struct_ser.serialize_field("secrets", &self.secrets)?;
13840 }
13841 if let Some(v) = self.cluster_resource.as_ref() {
13842 struct_ser.serialize_field("clusterResource", v)?;
13843 }
13844 if !self.nodes.is_empty() {
13845 struct_ser.serialize_field("nodes", &self.nodes)?;
13846 }
13847 if let Some(v) = self.hummock_version.as_ref() {
13848 struct_ser.serialize_field("hummockVersion", v)?;
13849 }
13850 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
13851 struct_ser.serialize_field("metaBackupManifestId", v)?;
13852 }
13853 if let Some(v) = self.hummock_write_limits.as_ref() {
13854 struct_ser.serialize_field("hummockWriteLimits", v)?;
13855 }
13856 if !self.streaming_worker_slot_mappings.is_empty() {
13857 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
13858 }
13859 if !self.serving_worker_slot_mappings.is_empty() {
13860 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
13861 }
13862 if !self.object_dependencies.is_empty() {
13863 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
13864 }
13865 if let Some(v) = self.version.as_ref() {
13866 struct_ser.serialize_field("version", v)?;
13867 }
13868 struct_ser.end()
13869 }
13870}
13871impl<'de> serde::Deserialize<'de> for MetaSnapshot {
13872 #[allow(deprecated)]
13873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13874 where
13875 D: serde::Deserializer<'de>,
13876 {
13877 const FIELDS: &[&str] = &[
13878 "databases",
13879 "schemas",
13880 "sources",
13881 "sinks",
13882 "tables",
13883 "indexes",
13884 "views",
13885 "functions",
13886 "connections",
13887 "subscriptions",
13888 "users",
13889 "session_params",
13890 "sessionParams",
13891 "secrets",
13892 "cluster_resource",
13893 "clusterResource",
13894 "nodes",
13895 "hummock_version",
13896 "hummockVersion",
13897 "meta_backup_manifest_id",
13898 "metaBackupManifestId",
13899 "hummock_write_limits",
13900 "hummockWriteLimits",
13901 "streaming_worker_slot_mappings",
13902 "streamingWorkerSlotMappings",
13903 "serving_worker_slot_mappings",
13904 "servingWorkerSlotMappings",
13905 "object_dependencies",
13906 "objectDependencies",
13907 "version",
13908 ];
13909
13910 #[allow(clippy::enum_variant_names)]
13911 enum GeneratedField {
13912 Databases,
13913 Schemas,
13914 Sources,
13915 Sinks,
13916 Tables,
13917 Indexes,
13918 Views,
13919 Functions,
13920 Connections,
13921 Subscriptions,
13922 Users,
13923 SessionParams,
13924 Secrets,
13925 ClusterResource,
13926 Nodes,
13927 HummockVersion,
13928 MetaBackupManifestId,
13929 HummockWriteLimits,
13930 StreamingWorkerSlotMappings,
13931 ServingWorkerSlotMappings,
13932 ObjectDependencies,
13933 Version,
13934 }
13935 impl<'de> serde::Deserialize<'de> for GeneratedField {
13936 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13937 where
13938 D: serde::Deserializer<'de>,
13939 {
13940 struct GeneratedVisitor;
13941
13942 impl serde::de::Visitor<'_> for GeneratedVisitor {
13943 type Value = GeneratedField;
13944
13945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13946 write!(formatter, "expected one of: {:?}", &FIELDS)
13947 }
13948
13949 #[allow(unused_variables)]
13950 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13951 where
13952 E: serde::de::Error,
13953 {
13954 match value {
13955 "databases" => Ok(GeneratedField::Databases),
13956 "schemas" => Ok(GeneratedField::Schemas),
13957 "sources" => Ok(GeneratedField::Sources),
13958 "sinks" => Ok(GeneratedField::Sinks),
13959 "tables" => Ok(GeneratedField::Tables),
13960 "indexes" => Ok(GeneratedField::Indexes),
13961 "views" => Ok(GeneratedField::Views),
13962 "functions" => Ok(GeneratedField::Functions),
13963 "connections" => Ok(GeneratedField::Connections),
13964 "subscriptions" => Ok(GeneratedField::Subscriptions),
13965 "users" => Ok(GeneratedField::Users),
13966 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13967 "secrets" => Ok(GeneratedField::Secrets),
13968 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13969 "nodes" => Ok(GeneratedField::Nodes),
13970 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13971 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13972 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13973 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13974 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13975 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
13976 "version" => Ok(GeneratedField::Version),
13977 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13978 }
13979 }
13980 }
13981 deserializer.deserialize_identifier(GeneratedVisitor)
13982 }
13983 }
13984 struct GeneratedVisitor;
13985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13986 type Value = MetaSnapshot;
13987
13988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13989 formatter.write_str("struct meta.MetaSnapshot")
13990 }
13991
13992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13993 where
13994 V: serde::de::MapAccess<'de>,
13995 {
13996 let mut databases__ = None;
13997 let mut schemas__ = None;
13998 let mut sources__ = None;
13999 let mut sinks__ = None;
14000 let mut tables__ = None;
14001 let mut indexes__ = None;
14002 let mut views__ = None;
14003 let mut functions__ = None;
14004 let mut connections__ = None;
14005 let mut subscriptions__ = None;
14006 let mut users__ = None;
14007 let mut session_params__ = None;
14008 let mut secrets__ = None;
14009 let mut cluster_resource__ = None;
14010 let mut nodes__ = None;
14011 let mut hummock_version__ = None;
14012 let mut meta_backup_manifest_id__ = None;
14013 let mut hummock_write_limits__ = None;
14014 let mut streaming_worker_slot_mappings__ = None;
14015 let mut serving_worker_slot_mappings__ = None;
14016 let mut object_dependencies__ = None;
14017 let mut version__ = None;
14018 while let Some(k) = map_.next_key()? {
14019 match k {
14020 GeneratedField::Databases => {
14021 if databases__.is_some() {
14022 return Err(serde::de::Error::duplicate_field("databases"));
14023 }
14024 databases__ = Some(map_.next_value()?);
14025 }
14026 GeneratedField::Schemas => {
14027 if schemas__.is_some() {
14028 return Err(serde::de::Error::duplicate_field("schemas"));
14029 }
14030 schemas__ = Some(map_.next_value()?);
14031 }
14032 GeneratedField::Sources => {
14033 if sources__.is_some() {
14034 return Err(serde::de::Error::duplicate_field("sources"));
14035 }
14036 sources__ = Some(map_.next_value()?);
14037 }
14038 GeneratedField::Sinks => {
14039 if sinks__.is_some() {
14040 return Err(serde::de::Error::duplicate_field("sinks"));
14041 }
14042 sinks__ = Some(map_.next_value()?);
14043 }
14044 GeneratedField::Tables => {
14045 if tables__.is_some() {
14046 return Err(serde::de::Error::duplicate_field("tables"));
14047 }
14048 tables__ = Some(map_.next_value()?);
14049 }
14050 GeneratedField::Indexes => {
14051 if indexes__.is_some() {
14052 return Err(serde::de::Error::duplicate_field("indexes"));
14053 }
14054 indexes__ = Some(map_.next_value()?);
14055 }
14056 GeneratedField::Views => {
14057 if views__.is_some() {
14058 return Err(serde::de::Error::duplicate_field("views"));
14059 }
14060 views__ = Some(map_.next_value()?);
14061 }
14062 GeneratedField::Functions => {
14063 if functions__.is_some() {
14064 return Err(serde::de::Error::duplicate_field("functions"));
14065 }
14066 functions__ = Some(map_.next_value()?);
14067 }
14068 GeneratedField::Connections => {
14069 if connections__.is_some() {
14070 return Err(serde::de::Error::duplicate_field("connections"));
14071 }
14072 connections__ = Some(map_.next_value()?);
14073 }
14074 GeneratedField::Subscriptions => {
14075 if subscriptions__.is_some() {
14076 return Err(serde::de::Error::duplicate_field("subscriptions"));
14077 }
14078 subscriptions__ = Some(map_.next_value()?);
14079 }
14080 GeneratedField::Users => {
14081 if users__.is_some() {
14082 return Err(serde::de::Error::duplicate_field("users"));
14083 }
14084 users__ = Some(map_.next_value()?);
14085 }
14086 GeneratedField::SessionParams => {
14087 if session_params__.is_some() {
14088 return Err(serde::de::Error::duplicate_field("sessionParams"));
14089 }
14090 session_params__ = map_.next_value()?;
14091 }
14092 GeneratedField::Secrets => {
14093 if secrets__.is_some() {
14094 return Err(serde::de::Error::duplicate_field("secrets"));
14095 }
14096 secrets__ = Some(map_.next_value()?);
14097 }
14098 GeneratedField::ClusterResource => {
14099 if cluster_resource__.is_some() {
14100 return Err(serde::de::Error::duplicate_field("clusterResource"));
14101 }
14102 cluster_resource__ = map_.next_value()?;
14103 }
14104 GeneratedField::Nodes => {
14105 if nodes__.is_some() {
14106 return Err(serde::de::Error::duplicate_field("nodes"));
14107 }
14108 nodes__ = Some(map_.next_value()?);
14109 }
14110 GeneratedField::HummockVersion => {
14111 if hummock_version__.is_some() {
14112 return Err(serde::de::Error::duplicate_field("hummockVersion"));
14113 }
14114 hummock_version__ = map_.next_value()?;
14115 }
14116 GeneratedField::MetaBackupManifestId => {
14117 if meta_backup_manifest_id__.is_some() {
14118 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14119 }
14120 meta_backup_manifest_id__ = map_.next_value()?;
14121 }
14122 GeneratedField::HummockWriteLimits => {
14123 if hummock_write_limits__.is_some() {
14124 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14125 }
14126 hummock_write_limits__ = map_.next_value()?;
14127 }
14128 GeneratedField::StreamingWorkerSlotMappings => {
14129 if streaming_worker_slot_mappings__.is_some() {
14130 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
14131 }
14132 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
14133 }
14134 GeneratedField::ServingWorkerSlotMappings => {
14135 if serving_worker_slot_mappings__.is_some() {
14136 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14137 }
14138 serving_worker_slot_mappings__ = Some(map_.next_value()?);
14139 }
14140 GeneratedField::ObjectDependencies => {
14141 if object_dependencies__.is_some() {
14142 return Err(serde::de::Error::duplicate_field("objectDependencies"));
14143 }
14144 object_dependencies__ = Some(map_.next_value()?);
14145 }
14146 GeneratedField::Version => {
14147 if version__.is_some() {
14148 return Err(serde::de::Error::duplicate_field("version"));
14149 }
14150 version__ = map_.next_value()?;
14151 }
14152 }
14153 }
14154 Ok(MetaSnapshot {
14155 databases: databases__.unwrap_or_default(),
14156 schemas: schemas__.unwrap_or_default(),
14157 sources: sources__.unwrap_or_default(),
14158 sinks: sinks__.unwrap_or_default(),
14159 tables: tables__.unwrap_or_default(),
14160 indexes: indexes__.unwrap_or_default(),
14161 views: views__.unwrap_or_default(),
14162 functions: functions__.unwrap_or_default(),
14163 connections: connections__.unwrap_or_default(),
14164 subscriptions: subscriptions__.unwrap_or_default(),
14165 users: users__.unwrap_or_default(),
14166 session_params: session_params__,
14167 secrets: secrets__.unwrap_or_default(),
14168 cluster_resource: cluster_resource__,
14169 nodes: nodes__.unwrap_or_default(),
14170 hummock_version: hummock_version__,
14171 meta_backup_manifest_id: meta_backup_manifest_id__,
14172 hummock_write_limits: hummock_write_limits__,
14173 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
14174 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
14175 object_dependencies: object_dependencies__.unwrap_or_default(),
14176 version: version__,
14177 })
14178 }
14179 }
14180 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
14181 }
14182}
14183impl serde::Serialize for meta_snapshot::SnapshotVersion {
14184 #[allow(deprecated)]
14185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14186 where
14187 S: serde::Serializer,
14188 {
14189 use serde::ser::SerializeStruct;
14190 let mut len = 0;
14191 if self.catalog_version != 0 {
14192 len += 1;
14193 }
14194 if self.worker_node_version != 0 {
14195 len += 1;
14196 }
14197 if self.streaming_worker_slot_mapping_version != 0 {
14198 len += 1;
14199 }
14200 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
14201 if self.catalog_version != 0 {
14202 #[allow(clippy::needless_borrow)]
14203 #[allow(clippy::needless_borrows_for_generic_args)]
14204 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
14205 }
14206 if self.worker_node_version != 0 {
14207 #[allow(clippy::needless_borrow)]
14208 #[allow(clippy::needless_borrows_for_generic_args)]
14209 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
14210 }
14211 if self.streaming_worker_slot_mapping_version != 0 {
14212 #[allow(clippy::needless_borrow)]
14213 #[allow(clippy::needless_borrows_for_generic_args)]
14214 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
14215 }
14216 struct_ser.end()
14217 }
14218}
14219impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
14220 #[allow(deprecated)]
14221 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14222 where
14223 D: serde::Deserializer<'de>,
14224 {
14225 const FIELDS: &[&str] = &[
14226 "catalog_version",
14227 "catalogVersion",
14228 "worker_node_version",
14229 "workerNodeVersion",
14230 "streaming_worker_slot_mapping_version",
14231 "streamingWorkerSlotMappingVersion",
14232 ];
14233
14234 #[allow(clippy::enum_variant_names)]
14235 enum GeneratedField {
14236 CatalogVersion,
14237 WorkerNodeVersion,
14238 StreamingWorkerSlotMappingVersion,
14239 }
14240 impl<'de> serde::Deserialize<'de> for GeneratedField {
14241 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14242 where
14243 D: serde::Deserializer<'de>,
14244 {
14245 struct GeneratedVisitor;
14246
14247 impl serde::de::Visitor<'_> for GeneratedVisitor {
14248 type Value = GeneratedField;
14249
14250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14251 write!(formatter, "expected one of: {:?}", &FIELDS)
14252 }
14253
14254 #[allow(unused_variables)]
14255 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14256 where
14257 E: serde::de::Error,
14258 {
14259 match value {
14260 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
14261 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
14262 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
14263 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14264 }
14265 }
14266 }
14267 deserializer.deserialize_identifier(GeneratedVisitor)
14268 }
14269 }
14270 struct GeneratedVisitor;
14271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14272 type Value = meta_snapshot::SnapshotVersion;
14273
14274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14275 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
14276 }
14277
14278 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
14279 where
14280 V: serde::de::MapAccess<'de>,
14281 {
14282 let mut catalog_version__ = None;
14283 let mut worker_node_version__ = None;
14284 let mut streaming_worker_slot_mapping_version__ = None;
14285 while let Some(k) = map_.next_key()? {
14286 match k {
14287 GeneratedField::CatalogVersion => {
14288 if catalog_version__.is_some() {
14289 return Err(serde::de::Error::duplicate_field("catalogVersion"));
14290 }
14291 catalog_version__ =
14292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14293 ;
14294 }
14295 GeneratedField::WorkerNodeVersion => {
14296 if worker_node_version__.is_some() {
14297 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
14298 }
14299 worker_node_version__ =
14300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14301 ;
14302 }
14303 GeneratedField::StreamingWorkerSlotMappingVersion => {
14304 if streaming_worker_slot_mapping_version__.is_some() {
14305 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
14306 }
14307 streaming_worker_slot_mapping_version__ =
14308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14309 ;
14310 }
14311 }
14312 }
14313 Ok(meta_snapshot::SnapshotVersion {
14314 catalog_version: catalog_version__.unwrap_or_default(),
14315 worker_node_version: worker_node_version__.unwrap_or_default(),
14316 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
14317 })
14318 }
14319 }
14320 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
14321 }
14322}
14323impl serde::Serialize for MigrationPlan {
14324 #[allow(deprecated)]
14325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14326 where
14327 S: serde::Serializer,
14328 {
14329 use serde::ser::SerializeStruct;
14330 let mut len = 0;
14331 if !self.worker_slot_migration_plan.is_empty() {
14332 len += 1;
14333 }
14334 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
14335 if !self.worker_slot_migration_plan.is_empty() {
14336 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
14337 .map(|(k, v)| (k, v.to_string())).collect();
14338 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
14339 }
14340 struct_ser.end()
14341 }
14342}
14343impl<'de> serde::Deserialize<'de> for MigrationPlan {
14344 #[allow(deprecated)]
14345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14346 where
14347 D: serde::Deserializer<'de>,
14348 {
14349 const FIELDS: &[&str] = &[
14350 "worker_slot_migration_plan",
14351 "workerSlotMigrationPlan",
14352 ];
14353
14354 #[allow(clippy::enum_variant_names)]
14355 enum GeneratedField {
14356 WorkerSlotMigrationPlan,
14357 }
14358 impl<'de> serde::Deserialize<'de> for GeneratedField {
14359 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14360 where
14361 D: serde::Deserializer<'de>,
14362 {
14363 struct GeneratedVisitor;
14364
14365 impl serde::de::Visitor<'_> for GeneratedVisitor {
14366 type Value = GeneratedField;
14367
14368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14369 write!(formatter, "expected one of: {:?}", &FIELDS)
14370 }
14371
14372 #[allow(unused_variables)]
14373 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14374 where
14375 E: serde::de::Error,
14376 {
14377 match value {
14378 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
14379 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14380 }
14381 }
14382 }
14383 deserializer.deserialize_identifier(GeneratedVisitor)
14384 }
14385 }
14386 struct GeneratedVisitor;
14387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14388 type Value = MigrationPlan;
14389
14390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14391 formatter.write_str("struct meta.MigrationPlan")
14392 }
14393
14394 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
14395 where
14396 V: serde::de::MapAccess<'de>,
14397 {
14398 let mut worker_slot_migration_plan__ = None;
14399 while let Some(k) = map_.next_key()? {
14400 match k {
14401 GeneratedField::WorkerSlotMigrationPlan => {
14402 if worker_slot_migration_plan__.is_some() {
14403 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
14404 }
14405 worker_slot_migration_plan__ = Some(
14406 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14407 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
14408 );
14409 }
14410 }
14411 }
14412 Ok(MigrationPlan {
14413 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
14414 })
14415 }
14416 }
14417 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
14418 }
14419}
14420impl serde::Serialize for Object {
14421 #[allow(deprecated)]
14422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14423 where
14424 S: serde::Serializer,
14425 {
14426 use serde::ser::SerializeStruct;
14427 let mut len = 0;
14428 if self.object_info.is_some() {
14429 len += 1;
14430 }
14431 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
14432 if let Some(v) = self.object_info.as_ref() {
14433 match v {
14434 object::ObjectInfo::Database(v) => {
14435 struct_ser.serialize_field("database", v)?;
14436 }
14437 object::ObjectInfo::Schema(v) => {
14438 struct_ser.serialize_field("schema", v)?;
14439 }
14440 object::ObjectInfo::Table(v) => {
14441 struct_ser.serialize_field("table", v)?;
14442 }
14443 object::ObjectInfo::Index(v) => {
14444 struct_ser.serialize_field("index", v)?;
14445 }
14446 object::ObjectInfo::Source(v) => {
14447 struct_ser.serialize_field("source", v)?;
14448 }
14449 object::ObjectInfo::Sink(v) => {
14450 struct_ser.serialize_field("sink", v)?;
14451 }
14452 object::ObjectInfo::View(v) => {
14453 struct_ser.serialize_field("view", v)?;
14454 }
14455 object::ObjectInfo::Function(v) => {
14456 struct_ser.serialize_field("function", v)?;
14457 }
14458 object::ObjectInfo::Connection(v) => {
14459 struct_ser.serialize_field("connection", v)?;
14460 }
14461 object::ObjectInfo::Subscription(v) => {
14462 struct_ser.serialize_field("subscription", v)?;
14463 }
14464 object::ObjectInfo::Secret(v) => {
14465 struct_ser.serialize_field("secret", v)?;
14466 }
14467 }
14468 }
14469 struct_ser.end()
14470 }
14471}
14472impl<'de> serde::Deserialize<'de> for Object {
14473 #[allow(deprecated)]
14474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14475 where
14476 D: serde::Deserializer<'de>,
14477 {
14478 const FIELDS: &[&str] = &[
14479 "database",
14480 "schema",
14481 "table",
14482 "index",
14483 "source",
14484 "sink",
14485 "view",
14486 "function",
14487 "connection",
14488 "subscription",
14489 "secret",
14490 ];
14491
14492 #[allow(clippy::enum_variant_names)]
14493 enum GeneratedField {
14494 Database,
14495 Schema,
14496 Table,
14497 Index,
14498 Source,
14499 Sink,
14500 View,
14501 Function,
14502 Connection,
14503 Subscription,
14504 Secret,
14505 }
14506 impl<'de> serde::Deserialize<'de> for GeneratedField {
14507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14508 where
14509 D: serde::Deserializer<'de>,
14510 {
14511 struct GeneratedVisitor;
14512
14513 impl serde::de::Visitor<'_> for GeneratedVisitor {
14514 type Value = GeneratedField;
14515
14516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14517 write!(formatter, "expected one of: {:?}", &FIELDS)
14518 }
14519
14520 #[allow(unused_variables)]
14521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14522 where
14523 E: serde::de::Error,
14524 {
14525 match value {
14526 "database" => Ok(GeneratedField::Database),
14527 "schema" => Ok(GeneratedField::Schema),
14528 "table" => Ok(GeneratedField::Table),
14529 "index" => Ok(GeneratedField::Index),
14530 "source" => Ok(GeneratedField::Source),
14531 "sink" => Ok(GeneratedField::Sink),
14532 "view" => Ok(GeneratedField::View),
14533 "function" => Ok(GeneratedField::Function),
14534 "connection" => Ok(GeneratedField::Connection),
14535 "subscription" => Ok(GeneratedField::Subscription),
14536 "secret" => Ok(GeneratedField::Secret),
14537 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14538 }
14539 }
14540 }
14541 deserializer.deserialize_identifier(GeneratedVisitor)
14542 }
14543 }
14544 struct GeneratedVisitor;
14545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14546 type Value = Object;
14547
14548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14549 formatter.write_str("struct meta.Object")
14550 }
14551
14552 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14553 where
14554 V: serde::de::MapAccess<'de>,
14555 {
14556 let mut object_info__ = None;
14557 while let Some(k) = map_.next_key()? {
14558 match k {
14559 GeneratedField::Database => {
14560 if object_info__.is_some() {
14561 return Err(serde::de::Error::duplicate_field("database"));
14562 }
14563 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14564;
14565 }
14566 GeneratedField::Schema => {
14567 if object_info__.is_some() {
14568 return Err(serde::de::Error::duplicate_field("schema"));
14569 }
14570 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14571;
14572 }
14573 GeneratedField::Table => {
14574 if object_info__.is_some() {
14575 return Err(serde::de::Error::duplicate_field("table"));
14576 }
14577 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14578;
14579 }
14580 GeneratedField::Index => {
14581 if object_info__.is_some() {
14582 return Err(serde::de::Error::duplicate_field("index"));
14583 }
14584 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14585;
14586 }
14587 GeneratedField::Source => {
14588 if object_info__.is_some() {
14589 return Err(serde::de::Error::duplicate_field("source"));
14590 }
14591 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14592;
14593 }
14594 GeneratedField::Sink => {
14595 if object_info__.is_some() {
14596 return Err(serde::de::Error::duplicate_field("sink"));
14597 }
14598 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14599;
14600 }
14601 GeneratedField::View => {
14602 if object_info__.is_some() {
14603 return Err(serde::de::Error::duplicate_field("view"));
14604 }
14605 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14606;
14607 }
14608 GeneratedField::Function => {
14609 if object_info__.is_some() {
14610 return Err(serde::de::Error::duplicate_field("function"));
14611 }
14612 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14613;
14614 }
14615 GeneratedField::Connection => {
14616 if object_info__.is_some() {
14617 return Err(serde::de::Error::duplicate_field("connection"));
14618 }
14619 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14620;
14621 }
14622 GeneratedField::Subscription => {
14623 if object_info__.is_some() {
14624 return Err(serde::de::Error::duplicate_field("subscription"));
14625 }
14626 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14627;
14628 }
14629 GeneratedField::Secret => {
14630 if object_info__.is_some() {
14631 return Err(serde::de::Error::duplicate_field("secret"));
14632 }
14633 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14634;
14635 }
14636 }
14637 }
14638 Ok(Object {
14639 object_info: object_info__,
14640 })
14641 }
14642 }
14643 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14644 }
14645}
14646impl serde::Serialize for ObjectDependency {
14647 #[allow(deprecated)]
14648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14649 where
14650 S: serde::Serializer,
14651 {
14652 use serde::ser::SerializeStruct;
14653 let mut len = 0;
14654 if self.object_id != 0 {
14655 len += 1;
14656 }
14657 if self.referenced_object_id != 0 {
14658 len += 1;
14659 }
14660 if self.referenced_object_type != 0 {
14661 len += 1;
14662 }
14663 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14664 if self.object_id != 0 {
14665 struct_ser.serialize_field("objectId", &self.object_id)?;
14666 }
14667 if self.referenced_object_id != 0 {
14668 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14669 }
14670 if self.referenced_object_type != 0 {
14671 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14672 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14673 struct_ser.serialize_field("referencedObjectType", &v)?;
14674 }
14675 struct_ser.end()
14676 }
14677}
14678impl<'de> serde::Deserialize<'de> for ObjectDependency {
14679 #[allow(deprecated)]
14680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14681 where
14682 D: serde::Deserializer<'de>,
14683 {
14684 const FIELDS: &[&str] = &[
14685 "object_id",
14686 "objectId",
14687 "referenced_object_id",
14688 "referencedObjectId",
14689 "referenced_object_type",
14690 "referencedObjectType",
14691 ];
14692
14693 #[allow(clippy::enum_variant_names)]
14694 enum GeneratedField {
14695 ObjectId,
14696 ReferencedObjectId,
14697 ReferencedObjectType,
14698 }
14699 impl<'de> serde::Deserialize<'de> for GeneratedField {
14700 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14701 where
14702 D: serde::Deserializer<'de>,
14703 {
14704 struct GeneratedVisitor;
14705
14706 impl serde::de::Visitor<'_> for GeneratedVisitor {
14707 type Value = GeneratedField;
14708
14709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14710 write!(formatter, "expected one of: {:?}", &FIELDS)
14711 }
14712
14713 #[allow(unused_variables)]
14714 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14715 where
14716 E: serde::de::Error,
14717 {
14718 match value {
14719 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14720 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14721 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14722 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14723 }
14724 }
14725 }
14726 deserializer.deserialize_identifier(GeneratedVisitor)
14727 }
14728 }
14729 struct GeneratedVisitor;
14730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14731 type Value = ObjectDependency;
14732
14733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14734 formatter.write_str("struct meta.ObjectDependency")
14735 }
14736
14737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14738 where
14739 V: serde::de::MapAccess<'de>,
14740 {
14741 let mut object_id__ = None;
14742 let mut referenced_object_id__ = None;
14743 let mut referenced_object_type__ = None;
14744 while let Some(k) = map_.next_key()? {
14745 match k {
14746 GeneratedField::ObjectId => {
14747 if object_id__.is_some() {
14748 return Err(serde::de::Error::duplicate_field("objectId"));
14749 }
14750 object_id__ =
14751 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14752 ;
14753 }
14754 GeneratedField::ReferencedObjectId => {
14755 if referenced_object_id__.is_some() {
14756 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14757 }
14758 referenced_object_id__ =
14759 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14760 ;
14761 }
14762 GeneratedField::ReferencedObjectType => {
14763 if referenced_object_type__.is_some() {
14764 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14765 }
14766 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14767 }
14768 }
14769 }
14770 Ok(ObjectDependency {
14771 object_id: object_id__.unwrap_or_default(),
14772 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14773 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14774 })
14775 }
14776 }
14777 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14778 }
14779}
14780impl serde::Serialize for ObjectGroup {
14781 #[allow(deprecated)]
14782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14783 where
14784 S: serde::Serializer,
14785 {
14786 use serde::ser::SerializeStruct;
14787 let mut len = 0;
14788 if !self.objects.is_empty() {
14789 len += 1;
14790 }
14791 if !self.dependencies.is_empty() {
14792 len += 1;
14793 }
14794 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14795 if !self.objects.is_empty() {
14796 struct_ser.serialize_field("objects", &self.objects)?;
14797 }
14798 if !self.dependencies.is_empty() {
14799 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14800 }
14801 struct_ser.end()
14802 }
14803}
14804impl<'de> serde::Deserialize<'de> for ObjectGroup {
14805 #[allow(deprecated)]
14806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14807 where
14808 D: serde::Deserializer<'de>,
14809 {
14810 const FIELDS: &[&str] = &[
14811 "objects",
14812 "dependencies",
14813 ];
14814
14815 #[allow(clippy::enum_variant_names)]
14816 enum GeneratedField {
14817 Objects,
14818 Dependencies,
14819 }
14820 impl<'de> serde::Deserialize<'de> for GeneratedField {
14821 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14822 where
14823 D: serde::Deserializer<'de>,
14824 {
14825 struct GeneratedVisitor;
14826
14827 impl serde::de::Visitor<'_> for GeneratedVisitor {
14828 type Value = GeneratedField;
14829
14830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14831 write!(formatter, "expected one of: {:?}", &FIELDS)
14832 }
14833
14834 #[allow(unused_variables)]
14835 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14836 where
14837 E: serde::de::Error,
14838 {
14839 match value {
14840 "objects" => Ok(GeneratedField::Objects),
14841 "dependencies" => Ok(GeneratedField::Dependencies),
14842 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14843 }
14844 }
14845 }
14846 deserializer.deserialize_identifier(GeneratedVisitor)
14847 }
14848 }
14849 struct GeneratedVisitor;
14850 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14851 type Value = ObjectGroup;
14852
14853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14854 formatter.write_str("struct meta.ObjectGroup")
14855 }
14856
14857 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
14858 where
14859 V: serde::de::MapAccess<'de>,
14860 {
14861 let mut objects__ = None;
14862 let mut dependencies__ = None;
14863 while let Some(k) = map_.next_key()? {
14864 match k {
14865 GeneratedField::Objects => {
14866 if objects__.is_some() {
14867 return Err(serde::de::Error::duplicate_field("objects"));
14868 }
14869 objects__ = Some(map_.next_value()?);
14870 }
14871 GeneratedField::Dependencies => {
14872 if dependencies__.is_some() {
14873 return Err(serde::de::Error::duplicate_field("dependencies"));
14874 }
14875 dependencies__ = Some(map_.next_value()?);
14876 }
14877 }
14878 }
14879 Ok(ObjectGroup {
14880 objects: objects__.unwrap_or_default(),
14881 dependencies: dependencies__.unwrap_or_default(),
14882 })
14883 }
14884 }
14885 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
14886 }
14887}
14888impl serde::Serialize for PauseRequest {
14889 #[allow(deprecated)]
14890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14891 where
14892 S: serde::Serializer,
14893 {
14894 use serde::ser::SerializeStruct;
14895 let len = 0;
14896 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
14897 struct_ser.end()
14898 }
14899}
14900impl<'de> serde::Deserialize<'de> for PauseRequest {
14901 #[allow(deprecated)]
14902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14903 where
14904 D: serde::Deserializer<'de>,
14905 {
14906 const FIELDS: &[&str] = &[
14907 ];
14908
14909 #[allow(clippy::enum_variant_names)]
14910 enum GeneratedField {
14911 }
14912 impl<'de> serde::Deserialize<'de> for GeneratedField {
14913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14914 where
14915 D: serde::Deserializer<'de>,
14916 {
14917 struct GeneratedVisitor;
14918
14919 impl serde::de::Visitor<'_> for GeneratedVisitor {
14920 type Value = GeneratedField;
14921
14922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14923 write!(formatter, "expected one of: {:?}", &FIELDS)
14924 }
14925
14926 #[allow(unused_variables)]
14927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14928 where
14929 E: serde::de::Error,
14930 {
14931 Err(serde::de::Error::unknown_field(value, FIELDS))
14932 }
14933 }
14934 deserializer.deserialize_identifier(GeneratedVisitor)
14935 }
14936 }
14937 struct GeneratedVisitor;
14938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14939 type Value = PauseRequest;
14940
14941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14942 formatter.write_str("struct meta.PauseRequest")
14943 }
14944
14945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
14946 where
14947 V: serde::de::MapAccess<'de>,
14948 {
14949 while map_.next_key::<GeneratedField>()?.is_some() {
14950 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14951 }
14952 Ok(PauseRequest {
14953 })
14954 }
14955 }
14956 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
14957 }
14958}
14959impl serde::Serialize for PauseResponse {
14960 #[allow(deprecated)]
14961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14962 where
14963 S: serde::Serializer,
14964 {
14965 use serde::ser::SerializeStruct;
14966 let len = 0;
14967 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
14968 struct_ser.end()
14969 }
14970}
14971impl<'de> serde::Deserialize<'de> for PauseResponse {
14972 #[allow(deprecated)]
14973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14974 where
14975 D: serde::Deserializer<'de>,
14976 {
14977 const FIELDS: &[&str] = &[
14978 ];
14979
14980 #[allow(clippy::enum_variant_names)]
14981 enum GeneratedField {
14982 }
14983 impl<'de> serde::Deserialize<'de> for GeneratedField {
14984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14985 where
14986 D: serde::Deserializer<'de>,
14987 {
14988 struct GeneratedVisitor;
14989
14990 impl serde::de::Visitor<'_> for GeneratedVisitor {
14991 type Value = GeneratedField;
14992
14993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14994 write!(formatter, "expected one of: {:?}", &FIELDS)
14995 }
14996
14997 #[allow(unused_variables)]
14998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14999 where
15000 E: serde::de::Error,
15001 {
15002 Err(serde::de::Error::unknown_field(value, FIELDS))
15003 }
15004 }
15005 deserializer.deserialize_identifier(GeneratedVisitor)
15006 }
15007 }
15008 struct GeneratedVisitor;
15009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15010 type Value = PauseResponse;
15011
15012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15013 formatter.write_str("struct meta.PauseResponse")
15014 }
15015
15016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
15017 where
15018 V: serde::de::MapAccess<'de>,
15019 {
15020 while map_.next_key::<GeneratedField>()?.is_some() {
15021 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15022 }
15023 Ok(PauseResponse {
15024 })
15025 }
15026 }
15027 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
15028 }
15029}
15030impl serde::Serialize for PropertyUpdateOptions {
15031 #[allow(deprecated)]
15032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15033 where
15034 S: serde::Serializer,
15035 {
15036 use serde::ser::SerializeStruct;
15037 let mut len = 0;
15038 if self.reset_splits {
15039 len += 1;
15040 }
15041 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
15042 if self.reset_splits {
15043 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
15044 }
15045 struct_ser.end()
15046 }
15047}
15048impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
15049 #[allow(deprecated)]
15050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15051 where
15052 D: serde::Deserializer<'de>,
15053 {
15054 const FIELDS: &[&str] = &[
15055 "reset_splits",
15056 "resetSplits",
15057 ];
15058
15059 #[allow(clippy::enum_variant_names)]
15060 enum GeneratedField {
15061 ResetSplits,
15062 }
15063 impl<'de> serde::Deserialize<'de> for GeneratedField {
15064 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15065 where
15066 D: serde::Deserializer<'de>,
15067 {
15068 struct GeneratedVisitor;
15069
15070 impl serde::de::Visitor<'_> for GeneratedVisitor {
15071 type Value = GeneratedField;
15072
15073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15074 write!(formatter, "expected one of: {:?}", &FIELDS)
15075 }
15076
15077 #[allow(unused_variables)]
15078 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15079 where
15080 E: serde::de::Error,
15081 {
15082 match value {
15083 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
15084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15085 }
15086 }
15087 }
15088 deserializer.deserialize_identifier(GeneratedVisitor)
15089 }
15090 }
15091 struct GeneratedVisitor;
15092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15093 type Value = PropertyUpdateOptions;
15094
15095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15096 formatter.write_str("struct meta.PropertyUpdateOptions")
15097 }
15098
15099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
15100 where
15101 V: serde::de::MapAccess<'de>,
15102 {
15103 let mut reset_splits__ = None;
15104 while let Some(k) = map_.next_key()? {
15105 match k {
15106 GeneratedField::ResetSplits => {
15107 if reset_splits__.is_some() {
15108 return Err(serde::de::Error::duplicate_field("resetSplits"));
15109 }
15110 reset_splits__ = Some(map_.next_value()?);
15111 }
15112 }
15113 }
15114 Ok(PropertyUpdateOptions {
15115 reset_splits: reset_splits__.unwrap_or_default(),
15116 })
15117 }
15118 }
15119 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
15120 }
15121}
15122impl serde::Serialize for RecoverRequest {
15123 #[allow(deprecated)]
15124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15125 where
15126 S: serde::Serializer,
15127 {
15128 use serde::ser::SerializeStruct;
15129 let len = 0;
15130 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
15131 struct_ser.end()
15132 }
15133}
15134impl<'de> serde::Deserialize<'de> for RecoverRequest {
15135 #[allow(deprecated)]
15136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15137 where
15138 D: serde::Deserializer<'de>,
15139 {
15140 const FIELDS: &[&str] = &[
15141 ];
15142
15143 #[allow(clippy::enum_variant_names)]
15144 enum GeneratedField {
15145 }
15146 impl<'de> serde::Deserialize<'de> for GeneratedField {
15147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15148 where
15149 D: serde::Deserializer<'de>,
15150 {
15151 struct GeneratedVisitor;
15152
15153 impl serde::de::Visitor<'_> for GeneratedVisitor {
15154 type Value = GeneratedField;
15155
15156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15157 write!(formatter, "expected one of: {:?}", &FIELDS)
15158 }
15159
15160 #[allow(unused_variables)]
15161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15162 where
15163 E: serde::de::Error,
15164 {
15165 Err(serde::de::Error::unknown_field(value, FIELDS))
15166 }
15167 }
15168 deserializer.deserialize_identifier(GeneratedVisitor)
15169 }
15170 }
15171 struct GeneratedVisitor;
15172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15173 type Value = RecoverRequest;
15174
15175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15176 formatter.write_str("struct meta.RecoverRequest")
15177 }
15178
15179 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
15180 where
15181 V: serde::de::MapAccess<'de>,
15182 {
15183 while map_.next_key::<GeneratedField>()?.is_some() {
15184 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15185 }
15186 Ok(RecoverRequest {
15187 })
15188 }
15189 }
15190 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
15191 }
15192}
15193impl serde::Serialize for RecoverResponse {
15194 #[allow(deprecated)]
15195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15196 where
15197 S: serde::Serializer,
15198 {
15199 use serde::ser::SerializeStruct;
15200 let len = 0;
15201 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
15202 struct_ser.end()
15203 }
15204}
15205impl<'de> serde::Deserialize<'de> for RecoverResponse {
15206 #[allow(deprecated)]
15207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15208 where
15209 D: serde::Deserializer<'de>,
15210 {
15211 const FIELDS: &[&str] = &[
15212 ];
15213
15214 #[allow(clippy::enum_variant_names)]
15215 enum GeneratedField {
15216 }
15217 impl<'de> serde::Deserialize<'de> for GeneratedField {
15218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15219 where
15220 D: serde::Deserializer<'de>,
15221 {
15222 struct GeneratedVisitor;
15223
15224 impl serde::de::Visitor<'_> for GeneratedVisitor {
15225 type Value = GeneratedField;
15226
15227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15228 write!(formatter, "expected one of: {:?}", &FIELDS)
15229 }
15230
15231 #[allow(unused_variables)]
15232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15233 where
15234 E: serde::de::Error,
15235 {
15236 Err(serde::de::Error::unknown_field(value, FIELDS))
15237 }
15238 }
15239 deserializer.deserialize_identifier(GeneratedVisitor)
15240 }
15241 }
15242 struct GeneratedVisitor;
15243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15244 type Value = RecoverResponse;
15245
15246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15247 formatter.write_str("struct meta.RecoverResponse")
15248 }
15249
15250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
15251 where
15252 V: serde::de::MapAccess<'de>,
15253 {
15254 while map_.next_key::<GeneratedField>()?.is_some() {
15255 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15256 }
15257 Ok(RecoverResponse {
15258 })
15259 }
15260 }
15261 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
15262 }
15263}
15264impl serde::Serialize for Recovery {
15265 #[allow(deprecated)]
15266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15267 where
15268 S: serde::Serializer,
15269 {
15270 use serde::ser::SerializeStruct;
15271 let len = 0;
15272 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
15273 struct_ser.end()
15274 }
15275}
15276impl<'de> serde::Deserialize<'de> for Recovery {
15277 #[allow(deprecated)]
15278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15279 where
15280 D: serde::Deserializer<'de>,
15281 {
15282 const FIELDS: &[&str] = &[
15283 ];
15284
15285 #[allow(clippy::enum_variant_names)]
15286 enum GeneratedField {
15287 }
15288 impl<'de> serde::Deserialize<'de> for GeneratedField {
15289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15290 where
15291 D: serde::Deserializer<'de>,
15292 {
15293 struct GeneratedVisitor;
15294
15295 impl serde::de::Visitor<'_> for GeneratedVisitor {
15296 type Value = GeneratedField;
15297
15298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15299 write!(formatter, "expected one of: {:?}", &FIELDS)
15300 }
15301
15302 #[allow(unused_variables)]
15303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15304 where
15305 E: serde::de::Error,
15306 {
15307 Err(serde::de::Error::unknown_field(value, FIELDS))
15308 }
15309 }
15310 deserializer.deserialize_identifier(GeneratedVisitor)
15311 }
15312 }
15313 struct GeneratedVisitor;
15314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15315 type Value = Recovery;
15316
15317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15318 formatter.write_str("struct meta.Recovery")
15319 }
15320
15321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
15322 where
15323 V: serde::de::MapAccess<'de>,
15324 {
15325 while map_.next_key::<GeneratedField>()?.is_some() {
15326 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15327 }
15328 Ok(Recovery {
15329 })
15330 }
15331 }
15332 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
15333 }
15334}
15335impl serde::Serialize for RecoveryStatus {
15336 #[allow(deprecated)]
15337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15338 where
15339 S: serde::Serializer,
15340 {
15341 let variant = match self {
15342 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
15343 Self::StatusStarting => "STATUS_STARTING",
15344 Self::StatusRecovering => "STATUS_RECOVERING",
15345 Self::StatusRunning => "STATUS_RUNNING",
15346 };
15347 serializer.serialize_str(variant)
15348 }
15349}
15350impl<'de> serde::Deserialize<'de> for RecoveryStatus {
15351 #[allow(deprecated)]
15352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15353 where
15354 D: serde::Deserializer<'de>,
15355 {
15356 const FIELDS: &[&str] = &[
15357 "STATUS_UNSPECIFIED",
15358 "STATUS_STARTING",
15359 "STATUS_RECOVERING",
15360 "STATUS_RUNNING",
15361 ];
15362
15363 struct GeneratedVisitor;
15364
15365 impl serde::de::Visitor<'_> for GeneratedVisitor {
15366 type Value = RecoveryStatus;
15367
15368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15369 write!(formatter, "expected one of: {:?}", &FIELDS)
15370 }
15371
15372 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15373 where
15374 E: serde::de::Error,
15375 {
15376 i32::try_from(v)
15377 .ok()
15378 .and_then(|x| x.try_into().ok())
15379 .ok_or_else(|| {
15380 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15381 })
15382 }
15383
15384 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15385 where
15386 E: serde::de::Error,
15387 {
15388 i32::try_from(v)
15389 .ok()
15390 .and_then(|x| x.try_into().ok())
15391 .ok_or_else(|| {
15392 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15393 })
15394 }
15395
15396 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15397 where
15398 E: serde::de::Error,
15399 {
15400 match value {
15401 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
15402 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
15403 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
15404 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
15405 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15406 }
15407 }
15408 }
15409 deserializer.deserialize_any(GeneratedVisitor)
15410 }
15411}
15412impl serde::Serialize for RefreshRequest {
15413 #[allow(deprecated)]
15414 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15415 where
15416 S: serde::Serializer,
15417 {
15418 use serde::ser::SerializeStruct;
15419 let mut len = 0;
15420 if self.table_id != 0 {
15421 len += 1;
15422 }
15423 if self.associated_source_id != 0 {
15424 len += 1;
15425 }
15426 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
15427 if self.table_id != 0 {
15428 struct_ser.serialize_field("tableId", &self.table_id)?;
15429 }
15430 if self.associated_source_id != 0 {
15431 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
15432 }
15433 struct_ser.end()
15434 }
15435}
15436impl<'de> serde::Deserialize<'de> for RefreshRequest {
15437 #[allow(deprecated)]
15438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15439 where
15440 D: serde::Deserializer<'de>,
15441 {
15442 const FIELDS: &[&str] = &[
15443 "table_id",
15444 "tableId",
15445 "associated_source_id",
15446 "associatedSourceId",
15447 ];
15448
15449 #[allow(clippy::enum_variant_names)]
15450 enum GeneratedField {
15451 TableId,
15452 AssociatedSourceId,
15453 }
15454 impl<'de> serde::Deserialize<'de> for GeneratedField {
15455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15456 where
15457 D: serde::Deserializer<'de>,
15458 {
15459 struct GeneratedVisitor;
15460
15461 impl serde::de::Visitor<'_> for GeneratedVisitor {
15462 type Value = GeneratedField;
15463
15464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15465 write!(formatter, "expected one of: {:?}", &FIELDS)
15466 }
15467
15468 #[allow(unused_variables)]
15469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15470 where
15471 E: serde::de::Error,
15472 {
15473 match value {
15474 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15475 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15476 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15477 }
15478 }
15479 }
15480 deserializer.deserialize_identifier(GeneratedVisitor)
15481 }
15482 }
15483 struct GeneratedVisitor;
15484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15485 type Value = RefreshRequest;
15486
15487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15488 formatter.write_str("struct meta.RefreshRequest")
15489 }
15490
15491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15492 where
15493 V: serde::de::MapAccess<'de>,
15494 {
15495 let mut table_id__ = None;
15496 let mut associated_source_id__ = None;
15497 while let Some(k) = map_.next_key()? {
15498 match k {
15499 GeneratedField::TableId => {
15500 if table_id__.is_some() {
15501 return Err(serde::de::Error::duplicate_field("tableId"));
15502 }
15503 table_id__ =
15504 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15505 ;
15506 }
15507 GeneratedField::AssociatedSourceId => {
15508 if associated_source_id__.is_some() {
15509 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15510 }
15511 associated_source_id__ =
15512 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15513 ;
15514 }
15515 }
15516 }
15517 Ok(RefreshRequest {
15518 table_id: table_id__.unwrap_or_default(),
15519 associated_source_id: associated_source_id__.unwrap_or_default(),
15520 })
15521 }
15522 }
15523 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15524 }
15525}
15526impl serde::Serialize for RefreshResponse {
15527 #[allow(deprecated)]
15528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15529 where
15530 S: serde::Serializer,
15531 {
15532 use serde::ser::SerializeStruct;
15533 let mut len = 0;
15534 if self.status.is_some() {
15535 len += 1;
15536 }
15537 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15538 if let Some(v) = self.status.as_ref() {
15539 struct_ser.serialize_field("status", v)?;
15540 }
15541 struct_ser.end()
15542 }
15543}
15544impl<'de> serde::Deserialize<'de> for RefreshResponse {
15545 #[allow(deprecated)]
15546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15547 where
15548 D: serde::Deserializer<'de>,
15549 {
15550 const FIELDS: &[&str] = &[
15551 "status",
15552 ];
15553
15554 #[allow(clippy::enum_variant_names)]
15555 enum GeneratedField {
15556 Status,
15557 }
15558 impl<'de> serde::Deserialize<'de> for GeneratedField {
15559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15560 where
15561 D: serde::Deserializer<'de>,
15562 {
15563 struct GeneratedVisitor;
15564
15565 impl serde::de::Visitor<'_> for GeneratedVisitor {
15566 type Value = GeneratedField;
15567
15568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15569 write!(formatter, "expected one of: {:?}", &FIELDS)
15570 }
15571
15572 #[allow(unused_variables)]
15573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15574 where
15575 E: serde::de::Error,
15576 {
15577 match value {
15578 "status" => Ok(GeneratedField::Status),
15579 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15580 }
15581 }
15582 }
15583 deserializer.deserialize_identifier(GeneratedVisitor)
15584 }
15585 }
15586 struct GeneratedVisitor;
15587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15588 type Value = RefreshResponse;
15589
15590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15591 formatter.write_str("struct meta.RefreshResponse")
15592 }
15593
15594 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15595 where
15596 V: serde::de::MapAccess<'de>,
15597 {
15598 let mut status__ = None;
15599 while let Some(k) = map_.next_key()? {
15600 match k {
15601 GeneratedField::Status => {
15602 if status__.is_some() {
15603 return Err(serde::de::Error::duplicate_field("status"));
15604 }
15605 status__ = map_.next_value()?;
15606 }
15607 }
15608 }
15609 Ok(RefreshResponse {
15610 status: status__,
15611 })
15612 }
15613 }
15614 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15615 }
15616}
15617impl serde::Serialize for RelationIdInfos {
15618 #[allow(deprecated)]
15619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15620 where
15621 S: serde::Serializer,
15622 {
15623 use serde::ser::SerializeStruct;
15624 let mut len = 0;
15625 if !self.map.is_empty() {
15626 len += 1;
15627 }
15628 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15629 if !self.map.is_empty() {
15630 struct_ser.serialize_field("map", &self.map)?;
15631 }
15632 struct_ser.end()
15633 }
15634}
15635impl<'de> serde::Deserialize<'de> for RelationIdInfos {
15636 #[allow(deprecated)]
15637 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15638 where
15639 D: serde::Deserializer<'de>,
15640 {
15641 const FIELDS: &[&str] = &[
15642 "map",
15643 ];
15644
15645 #[allow(clippy::enum_variant_names)]
15646 enum GeneratedField {
15647 Map,
15648 }
15649 impl<'de> serde::Deserialize<'de> for GeneratedField {
15650 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15651 where
15652 D: serde::Deserializer<'de>,
15653 {
15654 struct GeneratedVisitor;
15655
15656 impl serde::de::Visitor<'_> for GeneratedVisitor {
15657 type Value = GeneratedField;
15658
15659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15660 write!(formatter, "expected one of: {:?}", &FIELDS)
15661 }
15662
15663 #[allow(unused_variables)]
15664 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15665 where
15666 E: serde::de::Error,
15667 {
15668 match value {
15669 "map" => Ok(GeneratedField::Map),
15670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15671 }
15672 }
15673 }
15674 deserializer.deserialize_identifier(GeneratedVisitor)
15675 }
15676 }
15677 struct GeneratedVisitor;
15678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15679 type Value = RelationIdInfos;
15680
15681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15682 formatter.write_str("struct meta.RelationIdInfos")
15683 }
15684
15685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15686 where
15687 V: serde::de::MapAccess<'de>,
15688 {
15689 let mut map__ = None;
15690 while let Some(k) = map_.next_key()? {
15691 match k {
15692 GeneratedField::Map => {
15693 if map__.is_some() {
15694 return Err(serde::de::Error::duplicate_field("map"));
15695 }
15696 map__ = Some(
15697 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15698 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15699 );
15700 }
15701 }
15702 }
15703 Ok(RelationIdInfos {
15704 map: map__.unwrap_or_default(),
15705 })
15706 }
15707 }
15708 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15709 }
15710}
15711impl serde::Serialize for RescheduleRequest {
15712 #[allow(deprecated)]
15713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15714 where
15715 S: serde::Serializer,
15716 {
15717 use serde::ser::SerializeStruct;
15718 let mut len = 0;
15719 if self.revision != 0 {
15720 len += 1;
15721 }
15722 if self.resolve_no_shuffle_upstream {
15723 len += 1;
15724 }
15725 if !self.worker_reschedules.is_empty() {
15726 len += 1;
15727 }
15728 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15729 if self.revision != 0 {
15730 #[allow(clippy::needless_borrow)]
15731 #[allow(clippy::needless_borrows_for_generic_args)]
15732 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15733 }
15734 if self.resolve_no_shuffle_upstream {
15735 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15736 }
15737 if !self.worker_reschedules.is_empty() {
15738 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15739 }
15740 struct_ser.end()
15741 }
15742}
15743impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15744 #[allow(deprecated)]
15745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15746 where
15747 D: serde::Deserializer<'de>,
15748 {
15749 const FIELDS: &[&str] = &[
15750 "revision",
15751 "resolve_no_shuffle_upstream",
15752 "resolveNoShuffleUpstream",
15753 "worker_reschedules",
15754 "workerReschedules",
15755 ];
15756
15757 #[allow(clippy::enum_variant_names)]
15758 enum GeneratedField {
15759 Revision,
15760 ResolveNoShuffleUpstream,
15761 WorkerReschedules,
15762 }
15763 impl<'de> serde::Deserialize<'de> for GeneratedField {
15764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15765 where
15766 D: serde::Deserializer<'de>,
15767 {
15768 struct GeneratedVisitor;
15769
15770 impl serde::de::Visitor<'_> for GeneratedVisitor {
15771 type Value = GeneratedField;
15772
15773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15774 write!(formatter, "expected one of: {:?}", &FIELDS)
15775 }
15776
15777 #[allow(unused_variables)]
15778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15779 where
15780 E: serde::de::Error,
15781 {
15782 match value {
15783 "revision" => Ok(GeneratedField::Revision),
15784 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15785 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15786 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15787 }
15788 }
15789 }
15790 deserializer.deserialize_identifier(GeneratedVisitor)
15791 }
15792 }
15793 struct GeneratedVisitor;
15794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15795 type Value = RescheduleRequest;
15796
15797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15798 formatter.write_str("struct meta.RescheduleRequest")
15799 }
15800
15801 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15802 where
15803 V: serde::de::MapAccess<'de>,
15804 {
15805 let mut revision__ = None;
15806 let mut resolve_no_shuffle_upstream__ = None;
15807 let mut worker_reschedules__ = None;
15808 while let Some(k) = map_.next_key()? {
15809 match k {
15810 GeneratedField::Revision => {
15811 if revision__.is_some() {
15812 return Err(serde::de::Error::duplicate_field("revision"));
15813 }
15814 revision__ =
15815 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15816 ;
15817 }
15818 GeneratedField::ResolveNoShuffleUpstream => {
15819 if resolve_no_shuffle_upstream__.is_some() {
15820 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
15821 }
15822 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
15823 }
15824 GeneratedField::WorkerReschedules => {
15825 if worker_reschedules__.is_some() {
15826 return Err(serde::de::Error::duplicate_field("workerReschedules"));
15827 }
15828 worker_reschedules__ = Some(
15829 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15830 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15831 );
15832 }
15833 }
15834 }
15835 Ok(RescheduleRequest {
15836 revision: revision__.unwrap_or_default(),
15837 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
15838 worker_reschedules: worker_reschedules__.unwrap_or_default(),
15839 })
15840 }
15841 }
15842 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
15843 }
15844}
15845impl serde::Serialize for RescheduleResponse {
15846 #[allow(deprecated)]
15847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15848 where
15849 S: serde::Serializer,
15850 {
15851 use serde::ser::SerializeStruct;
15852 let mut len = 0;
15853 if self.success {
15854 len += 1;
15855 }
15856 if self.revision != 0 {
15857 len += 1;
15858 }
15859 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
15860 if self.success {
15861 struct_ser.serialize_field("success", &self.success)?;
15862 }
15863 if self.revision != 0 {
15864 #[allow(clippy::needless_borrow)]
15865 #[allow(clippy::needless_borrows_for_generic_args)]
15866 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15867 }
15868 struct_ser.end()
15869 }
15870}
15871impl<'de> serde::Deserialize<'de> for RescheduleResponse {
15872 #[allow(deprecated)]
15873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15874 where
15875 D: serde::Deserializer<'de>,
15876 {
15877 const FIELDS: &[&str] = &[
15878 "success",
15879 "revision",
15880 ];
15881
15882 #[allow(clippy::enum_variant_names)]
15883 enum GeneratedField {
15884 Success,
15885 Revision,
15886 }
15887 impl<'de> serde::Deserialize<'de> for GeneratedField {
15888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15889 where
15890 D: serde::Deserializer<'de>,
15891 {
15892 struct GeneratedVisitor;
15893
15894 impl serde::de::Visitor<'_> for GeneratedVisitor {
15895 type Value = GeneratedField;
15896
15897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15898 write!(formatter, "expected one of: {:?}", &FIELDS)
15899 }
15900
15901 #[allow(unused_variables)]
15902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15903 where
15904 E: serde::de::Error,
15905 {
15906 match value {
15907 "success" => Ok(GeneratedField::Success),
15908 "revision" => Ok(GeneratedField::Revision),
15909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15910 }
15911 }
15912 }
15913 deserializer.deserialize_identifier(GeneratedVisitor)
15914 }
15915 }
15916 struct GeneratedVisitor;
15917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15918 type Value = RescheduleResponse;
15919
15920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15921 formatter.write_str("struct meta.RescheduleResponse")
15922 }
15923
15924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
15925 where
15926 V: serde::de::MapAccess<'de>,
15927 {
15928 let mut success__ = None;
15929 let mut revision__ = None;
15930 while let Some(k) = map_.next_key()? {
15931 match k {
15932 GeneratedField::Success => {
15933 if success__.is_some() {
15934 return Err(serde::de::Error::duplicate_field("success"));
15935 }
15936 success__ = Some(map_.next_value()?);
15937 }
15938 GeneratedField::Revision => {
15939 if revision__.is_some() {
15940 return Err(serde::de::Error::duplicate_field("revision"));
15941 }
15942 revision__ =
15943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15944 ;
15945 }
15946 }
15947 }
15948 Ok(RescheduleResponse {
15949 success: success__.unwrap_or_default(),
15950 revision: revision__.unwrap_or_default(),
15951 })
15952 }
15953 }
15954 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
15955 }
15956}
15957impl serde::Serialize for ResetSourceSplitsRequest {
15958 #[allow(deprecated)]
15959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15960 where
15961 S: serde::Serializer,
15962 {
15963 use serde::ser::SerializeStruct;
15964 let mut len = 0;
15965 if self.source_id != 0 {
15966 len += 1;
15967 }
15968 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
15969 if self.source_id != 0 {
15970 struct_ser.serialize_field("sourceId", &self.source_id)?;
15971 }
15972 struct_ser.end()
15973 }
15974}
15975impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
15976 #[allow(deprecated)]
15977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15978 where
15979 D: serde::Deserializer<'de>,
15980 {
15981 const FIELDS: &[&str] = &[
15982 "source_id",
15983 "sourceId",
15984 ];
15985
15986 #[allow(clippy::enum_variant_names)]
15987 enum GeneratedField {
15988 SourceId,
15989 }
15990 impl<'de> serde::Deserialize<'de> for GeneratedField {
15991 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15992 where
15993 D: serde::Deserializer<'de>,
15994 {
15995 struct GeneratedVisitor;
15996
15997 impl serde::de::Visitor<'_> for GeneratedVisitor {
15998 type Value = GeneratedField;
15999
16000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16001 write!(formatter, "expected one of: {:?}", &FIELDS)
16002 }
16003
16004 #[allow(unused_variables)]
16005 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16006 where
16007 E: serde::de::Error,
16008 {
16009 match value {
16010 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16012 }
16013 }
16014 }
16015 deserializer.deserialize_identifier(GeneratedVisitor)
16016 }
16017 }
16018 struct GeneratedVisitor;
16019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16020 type Value = ResetSourceSplitsRequest;
16021
16022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16023 formatter.write_str("struct meta.ResetSourceSplitsRequest")
16024 }
16025
16026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
16027 where
16028 V: serde::de::MapAccess<'de>,
16029 {
16030 let mut source_id__ = None;
16031 while let Some(k) = map_.next_key()? {
16032 match k {
16033 GeneratedField::SourceId => {
16034 if source_id__.is_some() {
16035 return Err(serde::de::Error::duplicate_field("sourceId"));
16036 }
16037 source_id__ =
16038 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16039 ;
16040 }
16041 }
16042 }
16043 Ok(ResetSourceSplitsRequest {
16044 source_id: source_id__.unwrap_or_default(),
16045 })
16046 }
16047 }
16048 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
16049 }
16050}
16051impl serde::Serialize for ResetSourceSplitsResponse {
16052 #[allow(deprecated)]
16053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16054 where
16055 S: serde::Serializer,
16056 {
16057 use serde::ser::SerializeStruct;
16058 let len = 0;
16059 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
16060 struct_ser.end()
16061 }
16062}
16063impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
16064 #[allow(deprecated)]
16065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16066 where
16067 D: serde::Deserializer<'de>,
16068 {
16069 const FIELDS: &[&str] = &[
16070 ];
16071
16072 #[allow(clippy::enum_variant_names)]
16073 enum GeneratedField {
16074 }
16075 impl<'de> serde::Deserialize<'de> for GeneratedField {
16076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16077 where
16078 D: serde::Deserializer<'de>,
16079 {
16080 struct GeneratedVisitor;
16081
16082 impl serde::de::Visitor<'_> for GeneratedVisitor {
16083 type Value = GeneratedField;
16084
16085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16086 write!(formatter, "expected one of: {:?}", &FIELDS)
16087 }
16088
16089 #[allow(unused_variables)]
16090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16091 where
16092 E: serde::de::Error,
16093 {
16094 Err(serde::de::Error::unknown_field(value, FIELDS))
16095 }
16096 }
16097 deserializer.deserialize_identifier(GeneratedVisitor)
16098 }
16099 }
16100 struct GeneratedVisitor;
16101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16102 type Value = ResetSourceSplitsResponse;
16103
16104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16105 formatter.write_str("struct meta.ResetSourceSplitsResponse")
16106 }
16107
16108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
16109 where
16110 V: serde::de::MapAccess<'de>,
16111 {
16112 while map_.next_key::<GeneratedField>()?.is_some() {
16113 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16114 }
16115 Ok(ResetSourceSplitsResponse {
16116 })
16117 }
16118 }
16119 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
16120 }
16121}
16122impl serde::Serialize for ResumeRequest {
16123 #[allow(deprecated)]
16124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16125 where
16126 S: serde::Serializer,
16127 {
16128 use serde::ser::SerializeStruct;
16129 let len = 0;
16130 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
16131 struct_ser.end()
16132 }
16133}
16134impl<'de> serde::Deserialize<'de> for ResumeRequest {
16135 #[allow(deprecated)]
16136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16137 where
16138 D: serde::Deserializer<'de>,
16139 {
16140 const FIELDS: &[&str] = &[
16141 ];
16142
16143 #[allow(clippy::enum_variant_names)]
16144 enum GeneratedField {
16145 }
16146 impl<'de> serde::Deserialize<'de> for GeneratedField {
16147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16148 where
16149 D: serde::Deserializer<'de>,
16150 {
16151 struct GeneratedVisitor;
16152
16153 impl serde::de::Visitor<'_> for GeneratedVisitor {
16154 type Value = GeneratedField;
16155
16156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16157 write!(formatter, "expected one of: {:?}", &FIELDS)
16158 }
16159
16160 #[allow(unused_variables)]
16161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16162 where
16163 E: serde::de::Error,
16164 {
16165 Err(serde::de::Error::unknown_field(value, FIELDS))
16166 }
16167 }
16168 deserializer.deserialize_identifier(GeneratedVisitor)
16169 }
16170 }
16171 struct GeneratedVisitor;
16172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16173 type Value = ResumeRequest;
16174
16175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16176 formatter.write_str("struct meta.ResumeRequest")
16177 }
16178
16179 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
16180 where
16181 V: serde::de::MapAccess<'de>,
16182 {
16183 while map_.next_key::<GeneratedField>()?.is_some() {
16184 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16185 }
16186 Ok(ResumeRequest {
16187 })
16188 }
16189 }
16190 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
16191 }
16192}
16193impl serde::Serialize for ResumeResponse {
16194 #[allow(deprecated)]
16195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16196 where
16197 S: serde::Serializer,
16198 {
16199 use serde::ser::SerializeStruct;
16200 let len = 0;
16201 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
16202 struct_ser.end()
16203 }
16204}
16205impl<'de> serde::Deserialize<'de> for ResumeResponse {
16206 #[allow(deprecated)]
16207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16208 where
16209 D: serde::Deserializer<'de>,
16210 {
16211 const FIELDS: &[&str] = &[
16212 ];
16213
16214 #[allow(clippy::enum_variant_names)]
16215 enum GeneratedField {
16216 }
16217 impl<'de> serde::Deserialize<'de> for GeneratedField {
16218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16219 where
16220 D: serde::Deserializer<'de>,
16221 {
16222 struct GeneratedVisitor;
16223
16224 impl serde::de::Visitor<'_> for GeneratedVisitor {
16225 type Value = GeneratedField;
16226
16227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16228 write!(formatter, "expected one of: {:?}", &FIELDS)
16229 }
16230
16231 #[allow(unused_variables)]
16232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16233 where
16234 E: serde::de::Error,
16235 {
16236 Err(serde::de::Error::unknown_field(value, FIELDS))
16237 }
16238 }
16239 deserializer.deserialize_identifier(GeneratedVisitor)
16240 }
16241 }
16242 struct GeneratedVisitor;
16243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16244 type Value = ResumeResponse;
16245
16246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16247 formatter.write_str("struct meta.ResumeResponse")
16248 }
16249
16250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
16251 where
16252 V: serde::de::MapAccess<'de>,
16253 {
16254 while map_.next_key::<GeneratedField>()?.is_some() {
16255 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16256 }
16257 Ok(ResumeResponse {
16258 })
16259 }
16260 }
16261 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
16262 }
16263}
16264impl serde::Serialize for SetSessionParamRequest {
16265 #[allow(deprecated)]
16266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16267 where
16268 S: serde::Serializer,
16269 {
16270 use serde::ser::SerializeStruct;
16271 let mut len = 0;
16272 if !self.param.is_empty() {
16273 len += 1;
16274 }
16275 if self.value.is_some() {
16276 len += 1;
16277 }
16278 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
16279 if !self.param.is_empty() {
16280 struct_ser.serialize_field("param", &self.param)?;
16281 }
16282 if let Some(v) = self.value.as_ref() {
16283 struct_ser.serialize_field("value", v)?;
16284 }
16285 struct_ser.end()
16286 }
16287}
16288impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
16289 #[allow(deprecated)]
16290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16291 where
16292 D: serde::Deserializer<'de>,
16293 {
16294 const FIELDS: &[&str] = &[
16295 "param",
16296 "value",
16297 ];
16298
16299 #[allow(clippy::enum_variant_names)]
16300 enum GeneratedField {
16301 Param,
16302 Value,
16303 }
16304 impl<'de> serde::Deserialize<'de> for GeneratedField {
16305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16306 where
16307 D: serde::Deserializer<'de>,
16308 {
16309 struct GeneratedVisitor;
16310
16311 impl serde::de::Visitor<'_> for GeneratedVisitor {
16312 type Value = GeneratedField;
16313
16314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16315 write!(formatter, "expected one of: {:?}", &FIELDS)
16316 }
16317
16318 #[allow(unused_variables)]
16319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16320 where
16321 E: serde::de::Error,
16322 {
16323 match value {
16324 "param" => Ok(GeneratedField::Param),
16325 "value" => Ok(GeneratedField::Value),
16326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16327 }
16328 }
16329 }
16330 deserializer.deserialize_identifier(GeneratedVisitor)
16331 }
16332 }
16333 struct GeneratedVisitor;
16334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16335 type Value = SetSessionParamRequest;
16336
16337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16338 formatter.write_str("struct meta.SetSessionParamRequest")
16339 }
16340
16341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
16342 where
16343 V: serde::de::MapAccess<'de>,
16344 {
16345 let mut param__ = None;
16346 let mut value__ = None;
16347 while let Some(k) = map_.next_key()? {
16348 match k {
16349 GeneratedField::Param => {
16350 if param__.is_some() {
16351 return Err(serde::de::Error::duplicate_field("param"));
16352 }
16353 param__ = Some(map_.next_value()?);
16354 }
16355 GeneratedField::Value => {
16356 if value__.is_some() {
16357 return Err(serde::de::Error::duplicate_field("value"));
16358 }
16359 value__ = map_.next_value()?;
16360 }
16361 }
16362 }
16363 Ok(SetSessionParamRequest {
16364 param: param__.unwrap_or_default(),
16365 value: value__,
16366 })
16367 }
16368 }
16369 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
16370 }
16371}
16372impl serde::Serialize for SetSessionParamResponse {
16373 #[allow(deprecated)]
16374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16375 where
16376 S: serde::Serializer,
16377 {
16378 use serde::ser::SerializeStruct;
16379 let mut len = 0;
16380 if !self.param.is_empty() {
16381 len += 1;
16382 }
16383 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
16384 if !self.param.is_empty() {
16385 struct_ser.serialize_field("param", &self.param)?;
16386 }
16387 struct_ser.end()
16388 }
16389}
16390impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
16391 #[allow(deprecated)]
16392 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16393 where
16394 D: serde::Deserializer<'de>,
16395 {
16396 const FIELDS: &[&str] = &[
16397 "param",
16398 ];
16399
16400 #[allow(clippy::enum_variant_names)]
16401 enum GeneratedField {
16402 Param,
16403 }
16404 impl<'de> serde::Deserialize<'de> for GeneratedField {
16405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16406 where
16407 D: serde::Deserializer<'de>,
16408 {
16409 struct GeneratedVisitor;
16410
16411 impl serde::de::Visitor<'_> for GeneratedVisitor {
16412 type Value = GeneratedField;
16413
16414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16415 write!(formatter, "expected one of: {:?}", &FIELDS)
16416 }
16417
16418 #[allow(unused_variables)]
16419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16420 where
16421 E: serde::de::Error,
16422 {
16423 match value {
16424 "param" => Ok(GeneratedField::Param),
16425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16426 }
16427 }
16428 }
16429 deserializer.deserialize_identifier(GeneratedVisitor)
16430 }
16431 }
16432 struct GeneratedVisitor;
16433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16434 type Value = SetSessionParamResponse;
16435
16436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16437 formatter.write_str("struct meta.SetSessionParamResponse")
16438 }
16439
16440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16441 where
16442 V: serde::de::MapAccess<'de>,
16443 {
16444 let mut param__ = None;
16445 while let Some(k) = map_.next_key()? {
16446 match k {
16447 GeneratedField::Param => {
16448 if param__.is_some() {
16449 return Err(serde::de::Error::duplicate_field("param"));
16450 }
16451 param__ = Some(map_.next_value()?);
16452 }
16453 }
16454 }
16455 Ok(SetSessionParamResponse {
16456 param: param__.unwrap_or_default(),
16457 })
16458 }
16459 }
16460 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16461 }
16462}
16463impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16464 #[allow(deprecated)]
16465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16466 where
16467 S: serde::Serializer,
16468 {
16469 use serde::ser::SerializeStruct;
16470 let mut len = 0;
16471 if self.job_id != 0 {
16472 len += 1;
16473 }
16474 if self.aligned {
16475 len += 1;
16476 }
16477 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16478 if self.job_id != 0 {
16479 struct_ser.serialize_field("jobId", &self.job_id)?;
16480 }
16481 if self.aligned {
16482 struct_ser.serialize_field("aligned", &self.aligned)?;
16483 }
16484 struct_ser.end()
16485 }
16486}
16487impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16488 #[allow(deprecated)]
16489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16490 where
16491 D: serde::Deserializer<'de>,
16492 {
16493 const FIELDS: &[&str] = &[
16494 "job_id",
16495 "jobId",
16496 "aligned",
16497 ];
16498
16499 #[allow(clippy::enum_variant_names)]
16500 enum GeneratedField {
16501 JobId,
16502 Aligned,
16503 }
16504 impl<'de> serde::Deserialize<'de> for GeneratedField {
16505 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16506 where
16507 D: serde::Deserializer<'de>,
16508 {
16509 struct GeneratedVisitor;
16510
16511 impl serde::de::Visitor<'_> for GeneratedVisitor {
16512 type Value = GeneratedField;
16513
16514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16515 write!(formatter, "expected one of: {:?}", &FIELDS)
16516 }
16517
16518 #[allow(unused_variables)]
16519 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16520 where
16521 E: serde::de::Error,
16522 {
16523 match value {
16524 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16525 "aligned" => Ok(GeneratedField::Aligned),
16526 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16527 }
16528 }
16529 }
16530 deserializer.deserialize_identifier(GeneratedVisitor)
16531 }
16532 }
16533 struct GeneratedVisitor;
16534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16535 type Value = SetSyncLogStoreAlignedRequest;
16536
16537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16538 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16539 }
16540
16541 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16542 where
16543 V: serde::de::MapAccess<'de>,
16544 {
16545 let mut job_id__ = None;
16546 let mut aligned__ = None;
16547 while let Some(k) = map_.next_key()? {
16548 match k {
16549 GeneratedField::JobId => {
16550 if job_id__.is_some() {
16551 return Err(serde::de::Error::duplicate_field("jobId"));
16552 }
16553 job_id__ =
16554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16555 ;
16556 }
16557 GeneratedField::Aligned => {
16558 if aligned__.is_some() {
16559 return Err(serde::de::Error::duplicate_field("aligned"));
16560 }
16561 aligned__ = Some(map_.next_value()?);
16562 }
16563 }
16564 }
16565 Ok(SetSyncLogStoreAlignedRequest {
16566 job_id: job_id__.unwrap_or_default(),
16567 aligned: aligned__.unwrap_or_default(),
16568 })
16569 }
16570 }
16571 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16572 }
16573}
16574impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16575 #[allow(deprecated)]
16576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16577 where
16578 S: serde::Serializer,
16579 {
16580 use serde::ser::SerializeStruct;
16581 let len = 0;
16582 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16583 struct_ser.end()
16584 }
16585}
16586impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16587 #[allow(deprecated)]
16588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16589 where
16590 D: serde::Deserializer<'de>,
16591 {
16592 const FIELDS: &[&str] = &[
16593 ];
16594
16595 #[allow(clippy::enum_variant_names)]
16596 enum GeneratedField {
16597 }
16598 impl<'de> serde::Deserialize<'de> for GeneratedField {
16599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16600 where
16601 D: serde::Deserializer<'de>,
16602 {
16603 struct GeneratedVisitor;
16604
16605 impl serde::de::Visitor<'_> for GeneratedVisitor {
16606 type Value = GeneratedField;
16607
16608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16609 write!(formatter, "expected one of: {:?}", &FIELDS)
16610 }
16611
16612 #[allow(unused_variables)]
16613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16614 where
16615 E: serde::de::Error,
16616 {
16617 Err(serde::de::Error::unknown_field(value, FIELDS))
16618 }
16619 }
16620 deserializer.deserialize_identifier(GeneratedVisitor)
16621 }
16622 }
16623 struct GeneratedVisitor;
16624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16625 type Value = SetSyncLogStoreAlignedResponse;
16626
16627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16628 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
16629 }
16630
16631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
16632 where
16633 V: serde::de::MapAccess<'de>,
16634 {
16635 while map_.next_key::<GeneratedField>()?.is_some() {
16636 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16637 }
16638 Ok(SetSyncLogStoreAlignedResponse {
16639 })
16640 }
16641 }
16642 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
16643 }
16644}
16645impl serde::Serialize for SetSystemParamRequest {
16646 #[allow(deprecated)]
16647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16648 where
16649 S: serde::Serializer,
16650 {
16651 use serde::ser::SerializeStruct;
16652 let mut len = 0;
16653 if !self.param.is_empty() {
16654 len += 1;
16655 }
16656 if self.value.is_some() {
16657 len += 1;
16658 }
16659 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
16660 if !self.param.is_empty() {
16661 struct_ser.serialize_field("param", &self.param)?;
16662 }
16663 if let Some(v) = self.value.as_ref() {
16664 struct_ser.serialize_field("value", v)?;
16665 }
16666 struct_ser.end()
16667 }
16668}
16669impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
16670 #[allow(deprecated)]
16671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16672 where
16673 D: serde::Deserializer<'de>,
16674 {
16675 const FIELDS: &[&str] = &[
16676 "param",
16677 "value",
16678 ];
16679
16680 #[allow(clippy::enum_variant_names)]
16681 enum GeneratedField {
16682 Param,
16683 Value,
16684 }
16685 impl<'de> serde::Deserialize<'de> for GeneratedField {
16686 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16687 where
16688 D: serde::Deserializer<'de>,
16689 {
16690 struct GeneratedVisitor;
16691
16692 impl serde::de::Visitor<'_> for GeneratedVisitor {
16693 type Value = GeneratedField;
16694
16695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16696 write!(formatter, "expected one of: {:?}", &FIELDS)
16697 }
16698
16699 #[allow(unused_variables)]
16700 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16701 where
16702 E: serde::de::Error,
16703 {
16704 match value {
16705 "param" => Ok(GeneratedField::Param),
16706 "value" => Ok(GeneratedField::Value),
16707 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16708 }
16709 }
16710 }
16711 deserializer.deserialize_identifier(GeneratedVisitor)
16712 }
16713 }
16714 struct GeneratedVisitor;
16715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16716 type Value = SetSystemParamRequest;
16717
16718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16719 formatter.write_str("struct meta.SetSystemParamRequest")
16720 }
16721
16722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
16723 where
16724 V: serde::de::MapAccess<'de>,
16725 {
16726 let mut param__ = None;
16727 let mut value__ = None;
16728 while let Some(k) = map_.next_key()? {
16729 match k {
16730 GeneratedField::Param => {
16731 if param__.is_some() {
16732 return Err(serde::de::Error::duplicate_field("param"));
16733 }
16734 param__ = Some(map_.next_value()?);
16735 }
16736 GeneratedField::Value => {
16737 if value__.is_some() {
16738 return Err(serde::de::Error::duplicate_field("value"));
16739 }
16740 value__ = map_.next_value()?;
16741 }
16742 }
16743 }
16744 Ok(SetSystemParamRequest {
16745 param: param__.unwrap_or_default(),
16746 value: value__,
16747 })
16748 }
16749 }
16750 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
16751 }
16752}
16753impl serde::Serialize for SetSystemParamResponse {
16754 #[allow(deprecated)]
16755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16756 where
16757 S: serde::Serializer,
16758 {
16759 use serde::ser::SerializeStruct;
16760 let mut len = 0;
16761 if self.params.is_some() {
16762 len += 1;
16763 }
16764 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
16765 if let Some(v) = self.params.as_ref() {
16766 struct_ser.serialize_field("params", v)?;
16767 }
16768 struct_ser.end()
16769 }
16770}
16771impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
16772 #[allow(deprecated)]
16773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16774 where
16775 D: serde::Deserializer<'de>,
16776 {
16777 const FIELDS: &[&str] = &[
16778 "params",
16779 ];
16780
16781 #[allow(clippy::enum_variant_names)]
16782 enum GeneratedField {
16783 Params,
16784 }
16785 impl<'de> serde::Deserialize<'de> for GeneratedField {
16786 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16787 where
16788 D: serde::Deserializer<'de>,
16789 {
16790 struct GeneratedVisitor;
16791
16792 impl serde::de::Visitor<'_> for GeneratedVisitor {
16793 type Value = GeneratedField;
16794
16795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16796 write!(formatter, "expected one of: {:?}", &FIELDS)
16797 }
16798
16799 #[allow(unused_variables)]
16800 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16801 where
16802 E: serde::de::Error,
16803 {
16804 match value {
16805 "params" => Ok(GeneratedField::Params),
16806 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16807 }
16808 }
16809 }
16810 deserializer.deserialize_identifier(GeneratedVisitor)
16811 }
16812 }
16813 struct GeneratedVisitor;
16814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16815 type Value = SetSystemParamResponse;
16816
16817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16818 formatter.write_str("struct meta.SetSystemParamResponse")
16819 }
16820
16821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
16822 where
16823 V: serde::de::MapAccess<'de>,
16824 {
16825 let mut params__ = None;
16826 while let Some(k) = map_.next_key()? {
16827 match k {
16828 GeneratedField::Params => {
16829 if params__.is_some() {
16830 return Err(serde::de::Error::duplicate_field("params"));
16831 }
16832 params__ = map_.next_value()?;
16833 }
16834 }
16835 }
16836 Ok(SetSystemParamResponse {
16837 params: params__,
16838 })
16839 }
16840 }
16841 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
16842 }
16843}
16844impl serde::Serialize for SubscribeRequest {
16845 #[allow(deprecated)]
16846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16847 where
16848 S: serde::Serializer,
16849 {
16850 use serde::ser::SerializeStruct;
16851 let mut len = 0;
16852 if self.subscribe_type != 0 {
16853 len += 1;
16854 }
16855 if self.host.is_some() {
16856 len += 1;
16857 }
16858 if self.worker_id != 0 {
16859 len += 1;
16860 }
16861 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
16862 if self.subscribe_type != 0 {
16863 let v = SubscribeType::try_from(self.subscribe_type)
16864 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
16865 struct_ser.serialize_field("subscribeType", &v)?;
16866 }
16867 if let Some(v) = self.host.as_ref() {
16868 struct_ser.serialize_field("host", v)?;
16869 }
16870 if self.worker_id != 0 {
16871 struct_ser.serialize_field("workerId", &self.worker_id)?;
16872 }
16873 struct_ser.end()
16874 }
16875}
16876impl<'de> serde::Deserialize<'de> for SubscribeRequest {
16877 #[allow(deprecated)]
16878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16879 where
16880 D: serde::Deserializer<'de>,
16881 {
16882 const FIELDS: &[&str] = &[
16883 "subscribe_type",
16884 "subscribeType",
16885 "host",
16886 "worker_id",
16887 "workerId",
16888 ];
16889
16890 #[allow(clippy::enum_variant_names)]
16891 enum GeneratedField {
16892 SubscribeType,
16893 Host,
16894 WorkerId,
16895 }
16896 impl<'de> serde::Deserialize<'de> for GeneratedField {
16897 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16898 where
16899 D: serde::Deserializer<'de>,
16900 {
16901 struct GeneratedVisitor;
16902
16903 impl serde::de::Visitor<'_> for GeneratedVisitor {
16904 type Value = GeneratedField;
16905
16906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16907 write!(formatter, "expected one of: {:?}", &FIELDS)
16908 }
16909
16910 #[allow(unused_variables)]
16911 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16912 where
16913 E: serde::de::Error,
16914 {
16915 match value {
16916 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
16917 "host" => Ok(GeneratedField::Host),
16918 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
16919 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16920 }
16921 }
16922 }
16923 deserializer.deserialize_identifier(GeneratedVisitor)
16924 }
16925 }
16926 struct GeneratedVisitor;
16927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16928 type Value = SubscribeRequest;
16929
16930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16931 formatter.write_str("struct meta.SubscribeRequest")
16932 }
16933
16934 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
16935 where
16936 V: serde::de::MapAccess<'de>,
16937 {
16938 let mut subscribe_type__ = None;
16939 let mut host__ = None;
16940 let mut worker_id__ = None;
16941 while let Some(k) = map_.next_key()? {
16942 match k {
16943 GeneratedField::SubscribeType => {
16944 if subscribe_type__.is_some() {
16945 return Err(serde::de::Error::duplicate_field("subscribeType"));
16946 }
16947 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
16948 }
16949 GeneratedField::Host => {
16950 if host__.is_some() {
16951 return Err(serde::de::Error::duplicate_field("host"));
16952 }
16953 host__ = map_.next_value()?;
16954 }
16955 GeneratedField::WorkerId => {
16956 if worker_id__.is_some() {
16957 return Err(serde::de::Error::duplicate_field("workerId"));
16958 }
16959 worker_id__ =
16960 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16961 ;
16962 }
16963 }
16964 }
16965 Ok(SubscribeRequest {
16966 subscribe_type: subscribe_type__.unwrap_or_default(),
16967 host: host__,
16968 worker_id: worker_id__.unwrap_or_default(),
16969 })
16970 }
16971 }
16972 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
16973 }
16974}
16975impl serde::Serialize for SubscribeResponse {
16976 #[allow(deprecated)]
16977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16978 where
16979 S: serde::Serializer,
16980 {
16981 use serde::ser::SerializeStruct;
16982 let mut len = 0;
16983 if self.status.is_some() {
16984 len += 1;
16985 }
16986 if self.operation != 0 {
16987 len += 1;
16988 }
16989 if self.version != 0 {
16990 len += 1;
16991 }
16992 if self.info.is_some() {
16993 len += 1;
16994 }
16995 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
16996 if let Some(v) = self.status.as_ref() {
16997 struct_ser.serialize_field("status", v)?;
16998 }
16999 if self.operation != 0 {
17000 let v = subscribe_response::Operation::try_from(self.operation)
17001 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
17002 struct_ser.serialize_field("operation", &v)?;
17003 }
17004 if self.version != 0 {
17005 #[allow(clippy::needless_borrow)]
17006 #[allow(clippy::needless_borrows_for_generic_args)]
17007 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
17008 }
17009 if let Some(v) = self.info.as_ref() {
17010 match v {
17011 subscribe_response::Info::Database(v) => {
17012 struct_ser.serialize_field("database", v)?;
17013 }
17014 subscribe_response::Info::Schema(v) => {
17015 struct_ser.serialize_field("schema", v)?;
17016 }
17017 subscribe_response::Info::Function(v) => {
17018 struct_ser.serialize_field("function", v)?;
17019 }
17020 subscribe_response::Info::User(v) => {
17021 struct_ser.serialize_field("user", v)?;
17022 }
17023 subscribe_response::Info::SessionParam(v) => {
17024 struct_ser.serialize_field("sessionParam", v)?;
17025 }
17026 subscribe_response::Info::Node(v) => {
17027 struct_ser.serialize_field("node", v)?;
17028 }
17029 subscribe_response::Info::HummockVersionDeltas(v) => {
17030 struct_ser.serialize_field("hummockVersionDeltas", v)?;
17031 }
17032 subscribe_response::Info::Snapshot(v) => {
17033 struct_ser.serialize_field("snapshot", v)?;
17034 }
17035 subscribe_response::Info::MetaBackupManifestId(v) => {
17036 struct_ser.serialize_field("metaBackupManifestId", v)?;
17037 }
17038 subscribe_response::Info::SystemParams(v) => {
17039 struct_ser.serialize_field("systemParams", v)?;
17040 }
17041 subscribe_response::Info::HummockWriteLimits(v) => {
17042 struct_ser.serialize_field("hummockWriteLimits", v)?;
17043 }
17044 subscribe_response::Info::ObjectGroup(v) => {
17045 struct_ser.serialize_field("objectGroup", v)?;
17046 }
17047 subscribe_response::Info::Connection(v) => {
17048 struct_ser.serialize_field("connection", v)?;
17049 }
17050 subscribe_response::Info::HummockStats(v) => {
17051 struct_ser.serialize_field("hummockStats", v)?;
17052 }
17053 subscribe_response::Info::Recovery(v) => {
17054 struct_ser.serialize_field("recovery", v)?;
17055 }
17056 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
17057 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
17058 }
17059 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
17060 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
17061 }
17062 subscribe_response::Info::Secret(v) => {
17063 struct_ser.serialize_field("secret", v)?;
17064 }
17065 subscribe_response::Info::ClusterResource(v) => {
17066 struct_ser.serialize_field("clusterResource", v)?;
17067 }
17068 }
17069 }
17070 struct_ser.end()
17071 }
17072}
17073impl<'de> serde::Deserialize<'de> for SubscribeResponse {
17074 #[allow(deprecated)]
17075 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17076 where
17077 D: serde::Deserializer<'de>,
17078 {
17079 const FIELDS: &[&str] = &[
17080 "status",
17081 "operation",
17082 "version",
17083 "database",
17084 "schema",
17085 "function",
17086 "user",
17087 "session_param",
17088 "sessionParam",
17089 "node",
17090 "hummock_version_deltas",
17091 "hummockVersionDeltas",
17092 "snapshot",
17093 "meta_backup_manifest_id",
17094 "metaBackupManifestId",
17095 "system_params",
17096 "systemParams",
17097 "hummock_write_limits",
17098 "hummockWriteLimits",
17099 "object_group",
17100 "objectGroup",
17101 "connection",
17102 "hummock_stats",
17103 "hummockStats",
17104 "recovery",
17105 "streaming_worker_slot_mapping",
17106 "streamingWorkerSlotMapping",
17107 "serving_worker_slot_mappings",
17108 "servingWorkerSlotMappings",
17109 "secret",
17110 "cluster_resource",
17111 "clusterResource",
17112 ];
17113
17114 #[allow(clippy::enum_variant_names)]
17115 enum GeneratedField {
17116 Status,
17117 Operation,
17118 Version,
17119 Database,
17120 Schema,
17121 Function,
17122 User,
17123 SessionParam,
17124 Node,
17125 HummockVersionDeltas,
17126 Snapshot,
17127 MetaBackupManifestId,
17128 SystemParams,
17129 HummockWriteLimits,
17130 ObjectGroup,
17131 Connection,
17132 HummockStats,
17133 Recovery,
17134 StreamingWorkerSlotMapping,
17135 ServingWorkerSlotMappings,
17136 Secret,
17137 ClusterResource,
17138 }
17139 impl<'de> serde::Deserialize<'de> for GeneratedField {
17140 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17141 where
17142 D: serde::Deserializer<'de>,
17143 {
17144 struct GeneratedVisitor;
17145
17146 impl serde::de::Visitor<'_> for GeneratedVisitor {
17147 type Value = GeneratedField;
17148
17149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17150 write!(formatter, "expected one of: {:?}", &FIELDS)
17151 }
17152
17153 #[allow(unused_variables)]
17154 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17155 where
17156 E: serde::de::Error,
17157 {
17158 match value {
17159 "status" => Ok(GeneratedField::Status),
17160 "operation" => Ok(GeneratedField::Operation),
17161 "version" => Ok(GeneratedField::Version),
17162 "database" => Ok(GeneratedField::Database),
17163 "schema" => Ok(GeneratedField::Schema),
17164 "function" => Ok(GeneratedField::Function),
17165 "user" => Ok(GeneratedField::User),
17166 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
17167 "node" => Ok(GeneratedField::Node),
17168 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
17169 "snapshot" => Ok(GeneratedField::Snapshot),
17170 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
17171 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
17172 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
17173 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
17174 "connection" => Ok(GeneratedField::Connection),
17175 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
17176 "recovery" => Ok(GeneratedField::Recovery),
17177 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
17178 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
17179 "secret" => Ok(GeneratedField::Secret),
17180 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
17181 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17182 }
17183 }
17184 }
17185 deserializer.deserialize_identifier(GeneratedVisitor)
17186 }
17187 }
17188 struct GeneratedVisitor;
17189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17190 type Value = SubscribeResponse;
17191
17192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17193 formatter.write_str("struct meta.SubscribeResponse")
17194 }
17195
17196 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
17197 where
17198 V: serde::de::MapAccess<'de>,
17199 {
17200 let mut status__ = None;
17201 let mut operation__ = None;
17202 let mut version__ = None;
17203 let mut info__ = None;
17204 while let Some(k) = map_.next_key()? {
17205 match k {
17206 GeneratedField::Status => {
17207 if status__.is_some() {
17208 return Err(serde::de::Error::duplicate_field("status"));
17209 }
17210 status__ = map_.next_value()?;
17211 }
17212 GeneratedField::Operation => {
17213 if operation__.is_some() {
17214 return Err(serde::de::Error::duplicate_field("operation"));
17215 }
17216 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
17217 }
17218 GeneratedField::Version => {
17219 if version__.is_some() {
17220 return Err(serde::de::Error::duplicate_field("version"));
17221 }
17222 version__ =
17223 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17224 ;
17225 }
17226 GeneratedField::Database => {
17227 if info__.is_some() {
17228 return Err(serde::de::Error::duplicate_field("database"));
17229 }
17230 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
17231;
17232 }
17233 GeneratedField::Schema => {
17234 if info__.is_some() {
17235 return Err(serde::de::Error::duplicate_field("schema"));
17236 }
17237 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
17238;
17239 }
17240 GeneratedField::Function => {
17241 if info__.is_some() {
17242 return Err(serde::de::Error::duplicate_field("function"));
17243 }
17244 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
17245;
17246 }
17247 GeneratedField::User => {
17248 if info__.is_some() {
17249 return Err(serde::de::Error::duplicate_field("user"));
17250 }
17251 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
17252;
17253 }
17254 GeneratedField::SessionParam => {
17255 if info__.is_some() {
17256 return Err(serde::de::Error::duplicate_field("sessionParam"));
17257 }
17258 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
17259;
17260 }
17261 GeneratedField::Node => {
17262 if info__.is_some() {
17263 return Err(serde::de::Error::duplicate_field("node"));
17264 }
17265 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
17266;
17267 }
17268 GeneratedField::HummockVersionDeltas => {
17269 if info__.is_some() {
17270 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
17271 }
17272 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
17273;
17274 }
17275 GeneratedField::Snapshot => {
17276 if info__.is_some() {
17277 return Err(serde::de::Error::duplicate_field("snapshot"));
17278 }
17279 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
17280;
17281 }
17282 GeneratedField::MetaBackupManifestId => {
17283 if info__.is_some() {
17284 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
17285 }
17286 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
17287;
17288 }
17289 GeneratedField::SystemParams => {
17290 if info__.is_some() {
17291 return Err(serde::de::Error::duplicate_field("systemParams"));
17292 }
17293 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
17294;
17295 }
17296 GeneratedField::HummockWriteLimits => {
17297 if info__.is_some() {
17298 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
17299 }
17300 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
17301;
17302 }
17303 GeneratedField::ObjectGroup => {
17304 if info__.is_some() {
17305 return Err(serde::de::Error::duplicate_field("objectGroup"));
17306 }
17307 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
17308;
17309 }
17310 GeneratedField::Connection => {
17311 if info__.is_some() {
17312 return Err(serde::de::Error::duplicate_field("connection"));
17313 }
17314 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
17315;
17316 }
17317 GeneratedField::HummockStats => {
17318 if info__.is_some() {
17319 return Err(serde::de::Error::duplicate_field("hummockStats"));
17320 }
17321 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
17322;
17323 }
17324 GeneratedField::Recovery => {
17325 if info__.is_some() {
17326 return Err(serde::de::Error::duplicate_field("recovery"));
17327 }
17328 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
17329;
17330 }
17331 GeneratedField::StreamingWorkerSlotMapping => {
17332 if info__.is_some() {
17333 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
17334 }
17335 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
17336;
17337 }
17338 GeneratedField::ServingWorkerSlotMappings => {
17339 if info__.is_some() {
17340 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
17341 }
17342 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
17343;
17344 }
17345 GeneratedField::Secret => {
17346 if info__.is_some() {
17347 return Err(serde::de::Error::duplicate_field("secret"));
17348 }
17349 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
17350;
17351 }
17352 GeneratedField::ClusterResource => {
17353 if info__.is_some() {
17354 return Err(serde::de::Error::duplicate_field("clusterResource"));
17355 }
17356 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
17357;
17358 }
17359 }
17360 }
17361 Ok(SubscribeResponse {
17362 status: status__,
17363 operation: operation__.unwrap_or_default(),
17364 version: version__.unwrap_or_default(),
17365 info: info__,
17366 })
17367 }
17368 }
17369 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
17370 }
17371}
17372impl serde::Serialize for subscribe_response::Operation {
17373 #[allow(deprecated)]
17374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17375 where
17376 S: serde::Serializer,
17377 {
17378 let variant = match self {
17379 Self::Unspecified => "UNSPECIFIED",
17380 Self::Add => "ADD",
17381 Self::Delete => "DELETE",
17382 Self::Update => "UPDATE",
17383 Self::Snapshot => "SNAPSHOT",
17384 };
17385 serializer.serialize_str(variant)
17386 }
17387}
17388impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
17389 #[allow(deprecated)]
17390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17391 where
17392 D: serde::Deserializer<'de>,
17393 {
17394 const FIELDS: &[&str] = &[
17395 "UNSPECIFIED",
17396 "ADD",
17397 "DELETE",
17398 "UPDATE",
17399 "SNAPSHOT",
17400 ];
17401
17402 struct GeneratedVisitor;
17403
17404 impl serde::de::Visitor<'_> for GeneratedVisitor {
17405 type Value = subscribe_response::Operation;
17406
17407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17408 write!(formatter, "expected one of: {:?}", &FIELDS)
17409 }
17410
17411 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17412 where
17413 E: serde::de::Error,
17414 {
17415 i32::try_from(v)
17416 .ok()
17417 .and_then(|x| x.try_into().ok())
17418 .ok_or_else(|| {
17419 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17420 })
17421 }
17422
17423 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17424 where
17425 E: serde::de::Error,
17426 {
17427 i32::try_from(v)
17428 .ok()
17429 .and_then(|x| x.try_into().ok())
17430 .ok_or_else(|| {
17431 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17432 })
17433 }
17434
17435 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17436 where
17437 E: serde::de::Error,
17438 {
17439 match value {
17440 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17441 "ADD" => Ok(subscribe_response::Operation::Add),
17442 "DELETE" => Ok(subscribe_response::Operation::Delete),
17443 "UPDATE" => Ok(subscribe_response::Operation::Update),
17444 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17445 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17446 }
17447 }
17448 }
17449 deserializer.deserialize_any(GeneratedVisitor)
17450 }
17451}
17452impl serde::Serialize for SubscribeType {
17453 #[allow(deprecated)]
17454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17455 where
17456 S: serde::Serializer,
17457 {
17458 let variant = match self {
17459 Self::Unspecified => "UNSPECIFIED",
17460 Self::Frontend => "FRONTEND",
17461 Self::Hummock => "HUMMOCK",
17462 Self::Compactor => "COMPACTOR",
17463 Self::Compute => "COMPUTE",
17464 };
17465 serializer.serialize_str(variant)
17466 }
17467}
17468impl<'de> serde::Deserialize<'de> for SubscribeType {
17469 #[allow(deprecated)]
17470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17471 where
17472 D: serde::Deserializer<'de>,
17473 {
17474 const FIELDS: &[&str] = &[
17475 "UNSPECIFIED",
17476 "FRONTEND",
17477 "HUMMOCK",
17478 "COMPACTOR",
17479 "COMPUTE",
17480 ];
17481
17482 struct GeneratedVisitor;
17483
17484 impl serde::de::Visitor<'_> for GeneratedVisitor {
17485 type Value = SubscribeType;
17486
17487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17488 write!(formatter, "expected one of: {:?}", &FIELDS)
17489 }
17490
17491 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17492 where
17493 E: serde::de::Error,
17494 {
17495 i32::try_from(v)
17496 .ok()
17497 .and_then(|x| x.try_into().ok())
17498 .ok_or_else(|| {
17499 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17500 })
17501 }
17502
17503 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17504 where
17505 E: serde::de::Error,
17506 {
17507 i32::try_from(v)
17508 .ok()
17509 .and_then(|x| x.try_into().ok())
17510 .ok_or_else(|| {
17511 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17512 })
17513 }
17514
17515 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17516 where
17517 E: serde::de::Error,
17518 {
17519 match value {
17520 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17521 "FRONTEND" => Ok(SubscribeType::Frontend),
17522 "HUMMOCK" => Ok(SubscribeType::Hummock),
17523 "COMPACTOR" => Ok(SubscribeType::Compactor),
17524 "COMPUTE" => Ok(SubscribeType::Compute),
17525 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17526 }
17527 }
17528 }
17529 deserializer.deserialize_any(GeneratedVisitor)
17530 }
17531}
17532impl serde::Serialize for SystemParams {
17533 #[allow(deprecated)]
17534 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17535 where
17536 S: serde::Serializer,
17537 {
17538 use serde::ser::SerializeStruct;
17539 let mut len = 0;
17540 if self.barrier_interval_ms.is_some() {
17541 len += 1;
17542 }
17543 if self.checkpoint_frequency.is_some() {
17544 len += 1;
17545 }
17546 if self.sstable_size_mb.is_some() {
17547 len += 1;
17548 }
17549 if self.block_size_kb.is_some() {
17550 len += 1;
17551 }
17552 if self.bloom_false_positive.is_some() {
17553 len += 1;
17554 }
17555 if self.state_store.is_some() {
17556 len += 1;
17557 }
17558 if self.data_directory.is_some() {
17559 len += 1;
17560 }
17561 if self.backup_storage_url.is_some() {
17562 len += 1;
17563 }
17564 if self.backup_storage_directory.is_some() {
17565 len += 1;
17566 }
17567 if self.telemetry_enabled.is_some() {
17568 len += 1;
17569 }
17570 if self.parallel_compact_size_mb.is_some() {
17571 len += 1;
17572 }
17573 if self.max_concurrent_creating_streaming_jobs.is_some() {
17574 len += 1;
17575 }
17576 if self.pause_on_next_bootstrap.is_some() {
17577 len += 1;
17578 }
17579 if self.wasm_storage_url.is_some() {
17580 len += 1;
17581 }
17582 if self.enable_tracing.is_some() {
17583 len += 1;
17584 }
17585 if self.use_new_object_prefix_strategy.is_some() {
17586 len += 1;
17587 }
17588 if self.license_key.is_some() {
17589 len += 1;
17590 }
17591 if self.time_travel_retention_ms.is_some() {
17592 len += 1;
17593 }
17594 if self.adaptive_parallelism_strategy.is_some() {
17595 len += 1;
17596 }
17597 if self.per_database_isolation.is_some() {
17598 len += 1;
17599 }
17600 if self.enforce_secret.is_some() {
17601 len += 1;
17602 }
17603 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
17604 if let Some(v) = self.barrier_interval_ms.as_ref() {
17605 struct_ser.serialize_field("barrierIntervalMs", v)?;
17606 }
17607 if let Some(v) = self.checkpoint_frequency.as_ref() {
17608 #[allow(clippy::needless_borrow)]
17609 #[allow(clippy::needless_borrows_for_generic_args)]
17610 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
17611 }
17612 if let Some(v) = self.sstable_size_mb.as_ref() {
17613 struct_ser.serialize_field("sstableSizeMb", v)?;
17614 }
17615 if let Some(v) = self.block_size_kb.as_ref() {
17616 struct_ser.serialize_field("blockSizeKb", v)?;
17617 }
17618 if let Some(v) = self.bloom_false_positive.as_ref() {
17619 struct_ser.serialize_field("bloomFalsePositive", v)?;
17620 }
17621 if let Some(v) = self.state_store.as_ref() {
17622 struct_ser.serialize_field("stateStore", v)?;
17623 }
17624 if let Some(v) = self.data_directory.as_ref() {
17625 struct_ser.serialize_field("dataDirectory", v)?;
17626 }
17627 if let Some(v) = self.backup_storage_url.as_ref() {
17628 struct_ser.serialize_field("backupStorageUrl", v)?;
17629 }
17630 if let Some(v) = self.backup_storage_directory.as_ref() {
17631 struct_ser.serialize_field("backupStorageDirectory", v)?;
17632 }
17633 if let Some(v) = self.telemetry_enabled.as_ref() {
17634 struct_ser.serialize_field("telemetryEnabled", v)?;
17635 }
17636 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
17637 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
17638 }
17639 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
17640 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
17641 }
17642 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
17643 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
17644 }
17645 if let Some(v) = self.wasm_storage_url.as_ref() {
17646 struct_ser.serialize_field("wasmStorageUrl", v)?;
17647 }
17648 if let Some(v) = self.enable_tracing.as_ref() {
17649 struct_ser.serialize_field("enableTracing", v)?;
17650 }
17651 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
17652 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
17653 }
17654 if let Some(v) = self.license_key.as_ref() {
17655 struct_ser.serialize_field("licenseKey", v)?;
17656 }
17657 if let Some(v) = self.time_travel_retention_ms.as_ref() {
17658 #[allow(clippy::needless_borrow)]
17659 #[allow(clippy::needless_borrows_for_generic_args)]
17660 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
17661 }
17662 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
17663 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
17664 }
17665 if let Some(v) = self.per_database_isolation.as_ref() {
17666 struct_ser.serialize_field("perDatabaseIsolation", v)?;
17667 }
17668 if let Some(v) = self.enforce_secret.as_ref() {
17669 struct_ser.serialize_field("enforceSecret", v)?;
17670 }
17671 struct_ser.end()
17672 }
17673}
17674impl<'de> serde::Deserialize<'de> for SystemParams {
17675 #[allow(deprecated)]
17676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17677 where
17678 D: serde::Deserializer<'de>,
17679 {
17680 const FIELDS: &[&str] = &[
17681 "barrier_interval_ms",
17682 "barrierIntervalMs",
17683 "checkpoint_frequency",
17684 "checkpointFrequency",
17685 "sstable_size_mb",
17686 "sstableSizeMb",
17687 "block_size_kb",
17688 "blockSizeKb",
17689 "bloom_false_positive",
17690 "bloomFalsePositive",
17691 "state_store",
17692 "stateStore",
17693 "data_directory",
17694 "dataDirectory",
17695 "backup_storage_url",
17696 "backupStorageUrl",
17697 "backup_storage_directory",
17698 "backupStorageDirectory",
17699 "telemetry_enabled",
17700 "telemetryEnabled",
17701 "parallel_compact_size_mb",
17702 "parallelCompactSizeMb",
17703 "max_concurrent_creating_streaming_jobs",
17704 "maxConcurrentCreatingStreamingJobs",
17705 "pause_on_next_bootstrap",
17706 "pauseOnNextBootstrap",
17707 "wasm_storage_url",
17708 "wasmStorageUrl",
17709 "enable_tracing",
17710 "enableTracing",
17711 "use_new_object_prefix_strategy",
17712 "useNewObjectPrefixStrategy",
17713 "license_key",
17714 "licenseKey",
17715 "time_travel_retention_ms",
17716 "timeTravelRetentionMs",
17717 "adaptive_parallelism_strategy",
17718 "adaptiveParallelismStrategy",
17719 "per_database_isolation",
17720 "perDatabaseIsolation",
17721 "enforce_secret",
17722 "enforceSecret",
17723 ];
17724
17725 #[allow(clippy::enum_variant_names)]
17726 enum GeneratedField {
17727 BarrierIntervalMs,
17728 CheckpointFrequency,
17729 SstableSizeMb,
17730 BlockSizeKb,
17731 BloomFalsePositive,
17732 StateStore,
17733 DataDirectory,
17734 BackupStorageUrl,
17735 BackupStorageDirectory,
17736 TelemetryEnabled,
17737 ParallelCompactSizeMb,
17738 MaxConcurrentCreatingStreamingJobs,
17739 PauseOnNextBootstrap,
17740 WasmStorageUrl,
17741 EnableTracing,
17742 UseNewObjectPrefixStrategy,
17743 LicenseKey,
17744 TimeTravelRetentionMs,
17745 AdaptiveParallelismStrategy,
17746 PerDatabaseIsolation,
17747 EnforceSecret,
17748 }
17749 impl<'de> serde::Deserialize<'de> for GeneratedField {
17750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17751 where
17752 D: serde::Deserializer<'de>,
17753 {
17754 struct GeneratedVisitor;
17755
17756 impl serde::de::Visitor<'_> for GeneratedVisitor {
17757 type Value = GeneratedField;
17758
17759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17760 write!(formatter, "expected one of: {:?}", &FIELDS)
17761 }
17762
17763 #[allow(unused_variables)]
17764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17765 where
17766 E: serde::de::Error,
17767 {
17768 match value {
17769 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
17770 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
17771 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
17772 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
17773 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
17774 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
17775 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
17776 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
17777 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
17778 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
17779 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
17780 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
17781 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
17782 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
17783 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
17784 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
17785 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
17786 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
17787 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
17788 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
17789 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
17790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17791 }
17792 }
17793 }
17794 deserializer.deserialize_identifier(GeneratedVisitor)
17795 }
17796 }
17797 struct GeneratedVisitor;
17798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17799 type Value = SystemParams;
17800
17801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17802 formatter.write_str("struct meta.SystemParams")
17803 }
17804
17805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
17806 where
17807 V: serde::de::MapAccess<'de>,
17808 {
17809 let mut barrier_interval_ms__ = None;
17810 let mut checkpoint_frequency__ = None;
17811 let mut sstable_size_mb__ = None;
17812 let mut block_size_kb__ = None;
17813 let mut bloom_false_positive__ = None;
17814 let mut state_store__ = None;
17815 let mut data_directory__ = None;
17816 let mut backup_storage_url__ = None;
17817 let mut backup_storage_directory__ = None;
17818 let mut telemetry_enabled__ = None;
17819 let mut parallel_compact_size_mb__ = None;
17820 let mut max_concurrent_creating_streaming_jobs__ = None;
17821 let mut pause_on_next_bootstrap__ = None;
17822 let mut wasm_storage_url__ = None;
17823 let mut enable_tracing__ = None;
17824 let mut use_new_object_prefix_strategy__ = None;
17825 let mut license_key__ = None;
17826 let mut time_travel_retention_ms__ = None;
17827 let mut adaptive_parallelism_strategy__ = None;
17828 let mut per_database_isolation__ = None;
17829 let mut enforce_secret__ = None;
17830 while let Some(k) = map_.next_key()? {
17831 match k {
17832 GeneratedField::BarrierIntervalMs => {
17833 if barrier_interval_ms__.is_some() {
17834 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
17835 }
17836 barrier_interval_ms__ =
17837 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17838 ;
17839 }
17840 GeneratedField::CheckpointFrequency => {
17841 if checkpoint_frequency__.is_some() {
17842 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
17843 }
17844 checkpoint_frequency__ =
17845 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17846 ;
17847 }
17848 GeneratedField::SstableSizeMb => {
17849 if sstable_size_mb__.is_some() {
17850 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
17851 }
17852 sstable_size_mb__ =
17853 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17854 ;
17855 }
17856 GeneratedField::BlockSizeKb => {
17857 if block_size_kb__.is_some() {
17858 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
17859 }
17860 block_size_kb__ =
17861 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17862 ;
17863 }
17864 GeneratedField::BloomFalsePositive => {
17865 if bloom_false_positive__.is_some() {
17866 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
17867 }
17868 bloom_false_positive__ =
17869 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17870 ;
17871 }
17872 GeneratedField::StateStore => {
17873 if state_store__.is_some() {
17874 return Err(serde::de::Error::duplicate_field("stateStore"));
17875 }
17876 state_store__ = map_.next_value()?;
17877 }
17878 GeneratedField::DataDirectory => {
17879 if data_directory__.is_some() {
17880 return Err(serde::de::Error::duplicate_field("dataDirectory"));
17881 }
17882 data_directory__ = map_.next_value()?;
17883 }
17884 GeneratedField::BackupStorageUrl => {
17885 if backup_storage_url__.is_some() {
17886 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
17887 }
17888 backup_storage_url__ = map_.next_value()?;
17889 }
17890 GeneratedField::BackupStorageDirectory => {
17891 if backup_storage_directory__.is_some() {
17892 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
17893 }
17894 backup_storage_directory__ = map_.next_value()?;
17895 }
17896 GeneratedField::TelemetryEnabled => {
17897 if telemetry_enabled__.is_some() {
17898 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
17899 }
17900 telemetry_enabled__ = map_.next_value()?;
17901 }
17902 GeneratedField::ParallelCompactSizeMb => {
17903 if parallel_compact_size_mb__.is_some() {
17904 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
17905 }
17906 parallel_compact_size_mb__ =
17907 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17908 ;
17909 }
17910 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
17911 if max_concurrent_creating_streaming_jobs__.is_some() {
17912 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
17913 }
17914 max_concurrent_creating_streaming_jobs__ =
17915 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17916 ;
17917 }
17918 GeneratedField::PauseOnNextBootstrap => {
17919 if pause_on_next_bootstrap__.is_some() {
17920 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
17921 }
17922 pause_on_next_bootstrap__ = map_.next_value()?;
17923 }
17924 GeneratedField::WasmStorageUrl => {
17925 if wasm_storage_url__.is_some() {
17926 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
17927 }
17928 wasm_storage_url__ = map_.next_value()?;
17929 }
17930 GeneratedField::EnableTracing => {
17931 if enable_tracing__.is_some() {
17932 return Err(serde::de::Error::duplicate_field("enableTracing"));
17933 }
17934 enable_tracing__ = map_.next_value()?;
17935 }
17936 GeneratedField::UseNewObjectPrefixStrategy => {
17937 if use_new_object_prefix_strategy__.is_some() {
17938 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
17939 }
17940 use_new_object_prefix_strategy__ = map_.next_value()?;
17941 }
17942 GeneratedField::LicenseKey => {
17943 if license_key__.is_some() {
17944 return Err(serde::de::Error::duplicate_field("licenseKey"));
17945 }
17946 license_key__ = map_.next_value()?;
17947 }
17948 GeneratedField::TimeTravelRetentionMs => {
17949 if time_travel_retention_ms__.is_some() {
17950 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
17951 }
17952 time_travel_retention_ms__ =
17953 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17954 ;
17955 }
17956 GeneratedField::AdaptiveParallelismStrategy => {
17957 if adaptive_parallelism_strategy__.is_some() {
17958 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
17959 }
17960 adaptive_parallelism_strategy__ = map_.next_value()?;
17961 }
17962 GeneratedField::PerDatabaseIsolation => {
17963 if per_database_isolation__.is_some() {
17964 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
17965 }
17966 per_database_isolation__ = map_.next_value()?;
17967 }
17968 GeneratedField::EnforceSecret => {
17969 if enforce_secret__.is_some() {
17970 return Err(serde::de::Error::duplicate_field("enforceSecret"));
17971 }
17972 enforce_secret__ = map_.next_value()?;
17973 }
17974 }
17975 }
17976 Ok(SystemParams {
17977 barrier_interval_ms: barrier_interval_ms__,
17978 checkpoint_frequency: checkpoint_frequency__,
17979 sstable_size_mb: sstable_size_mb__,
17980 block_size_kb: block_size_kb__,
17981 bloom_false_positive: bloom_false_positive__,
17982 state_store: state_store__,
17983 data_directory: data_directory__,
17984 backup_storage_url: backup_storage_url__,
17985 backup_storage_directory: backup_storage_directory__,
17986 telemetry_enabled: telemetry_enabled__,
17987 parallel_compact_size_mb: parallel_compact_size_mb__,
17988 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
17989 pause_on_next_bootstrap: pause_on_next_bootstrap__,
17990 wasm_storage_url: wasm_storage_url__,
17991 enable_tracing: enable_tracing__,
17992 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
17993 license_key: license_key__,
17994 time_travel_retention_ms: time_travel_retention_ms__,
17995 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
17996 per_database_isolation: per_database_isolation__,
17997 enforce_secret: enforce_secret__,
17998 })
17999 }
18000 }
18001 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
18002 }
18003}
18004impl serde::Serialize for TableFragments {
18005 #[allow(deprecated)]
18006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18007 where
18008 S: serde::Serializer,
18009 {
18010 use serde::ser::SerializeStruct;
18011 let mut len = 0;
18012 if self.table_id != 0 {
18013 len += 1;
18014 }
18015 if self.state != 0 {
18016 len += 1;
18017 }
18018 if !self.fragments.is_empty() {
18019 len += 1;
18020 }
18021 if !self.actor_status.is_empty() {
18022 len += 1;
18023 }
18024 if self.ctx.is_some() {
18025 len += 1;
18026 }
18027 if self.parallelism.is_some() {
18028 len += 1;
18029 }
18030 if self.max_parallelism.is_some() {
18031 len += 1;
18032 }
18033 if !self.node_label.is_empty() {
18034 len += 1;
18035 }
18036 if self.backfill_done {
18037 len += 1;
18038 }
18039 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
18040 if self.table_id != 0 {
18041 struct_ser.serialize_field("tableId", &self.table_id)?;
18042 }
18043 if self.state != 0 {
18044 let v = table_fragments::State::try_from(self.state)
18045 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
18046 struct_ser.serialize_field("state", &v)?;
18047 }
18048 if !self.fragments.is_empty() {
18049 struct_ser.serialize_field("fragments", &self.fragments)?;
18050 }
18051 if !self.actor_status.is_empty() {
18052 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
18053 }
18054 if let Some(v) = self.ctx.as_ref() {
18055 struct_ser.serialize_field("ctx", v)?;
18056 }
18057 if let Some(v) = self.parallelism.as_ref() {
18058 struct_ser.serialize_field("parallelism", v)?;
18059 }
18060 if let Some(v) = self.max_parallelism.as_ref() {
18061 struct_ser.serialize_field("maxParallelism", v)?;
18062 }
18063 if !self.node_label.is_empty() {
18064 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18065 }
18066 if self.backfill_done {
18067 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
18068 }
18069 struct_ser.end()
18070 }
18071}
18072impl<'de> serde::Deserialize<'de> for TableFragments {
18073 #[allow(deprecated)]
18074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18075 where
18076 D: serde::Deserializer<'de>,
18077 {
18078 const FIELDS: &[&str] = &[
18079 "table_id",
18080 "tableId",
18081 "state",
18082 "fragments",
18083 "actor_status",
18084 "actorStatus",
18085 "ctx",
18086 "parallelism",
18087 "max_parallelism",
18088 "maxParallelism",
18089 "node_label",
18090 "nodeLabel",
18091 "backfill_done",
18092 "backfillDone",
18093 ];
18094
18095 #[allow(clippy::enum_variant_names)]
18096 enum GeneratedField {
18097 TableId,
18098 State,
18099 Fragments,
18100 ActorStatus,
18101 Ctx,
18102 Parallelism,
18103 MaxParallelism,
18104 NodeLabel,
18105 BackfillDone,
18106 }
18107 impl<'de> serde::Deserialize<'de> for GeneratedField {
18108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18109 where
18110 D: serde::Deserializer<'de>,
18111 {
18112 struct GeneratedVisitor;
18113
18114 impl serde::de::Visitor<'_> for GeneratedVisitor {
18115 type Value = GeneratedField;
18116
18117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18118 write!(formatter, "expected one of: {:?}", &FIELDS)
18119 }
18120
18121 #[allow(unused_variables)]
18122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18123 where
18124 E: serde::de::Error,
18125 {
18126 match value {
18127 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18128 "state" => Ok(GeneratedField::State),
18129 "fragments" => Ok(GeneratedField::Fragments),
18130 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
18131 "ctx" => Ok(GeneratedField::Ctx),
18132 "parallelism" => Ok(GeneratedField::Parallelism),
18133 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
18134 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18135 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
18136 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18137 }
18138 }
18139 }
18140 deserializer.deserialize_identifier(GeneratedVisitor)
18141 }
18142 }
18143 struct GeneratedVisitor;
18144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18145 type Value = TableFragments;
18146
18147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18148 formatter.write_str("struct meta.TableFragments")
18149 }
18150
18151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
18152 where
18153 V: serde::de::MapAccess<'de>,
18154 {
18155 let mut table_id__ = None;
18156 let mut state__ = None;
18157 let mut fragments__ = None;
18158 let mut actor_status__ = None;
18159 let mut ctx__ = None;
18160 let mut parallelism__ = None;
18161 let mut max_parallelism__ = None;
18162 let mut node_label__ = None;
18163 let mut backfill_done__ = None;
18164 while let Some(k) = map_.next_key()? {
18165 match k {
18166 GeneratedField::TableId => {
18167 if table_id__.is_some() {
18168 return Err(serde::de::Error::duplicate_field("tableId"));
18169 }
18170 table_id__ =
18171 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18172 ;
18173 }
18174 GeneratedField::State => {
18175 if state__.is_some() {
18176 return Err(serde::de::Error::duplicate_field("state"));
18177 }
18178 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
18179 }
18180 GeneratedField::Fragments => {
18181 if fragments__.is_some() {
18182 return Err(serde::de::Error::duplicate_field("fragments"));
18183 }
18184 fragments__ = Some(
18185 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18186 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18187 );
18188 }
18189 GeneratedField::ActorStatus => {
18190 if actor_status__.is_some() {
18191 return Err(serde::de::Error::duplicate_field("actorStatus"));
18192 }
18193 actor_status__ = Some(
18194 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18195 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18196 );
18197 }
18198 GeneratedField::Ctx => {
18199 if ctx__.is_some() {
18200 return Err(serde::de::Error::duplicate_field("ctx"));
18201 }
18202 ctx__ = map_.next_value()?;
18203 }
18204 GeneratedField::Parallelism => {
18205 if parallelism__.is_some() {
18206 return Err(serde::de::Error::duplicate_field("parallelism"));
18207 }
18208 parallelism__ = map_.next_value()?;
18209 }
18210 GeneratedField::MaxParallelism => {
18211 if max_parallelism__.is_some() {
18212 return Err(serde::de::Error::duplicate_field("maxParallelism"));
18213 }
18214 max_parallelism__ =
18215 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18216 ;
18217 }
18218 GeneratedField::NodeLabel => {
18219 if node_label__.is_some() {
18220 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18221 }
18222 node_label__ = Some(map_.next_value()?);
18223 }
18224 GeneratedField::BackfillDone => {
18225 if backfill_done__.is_some() {
18226 return Err(serde::de::Error::duplicate_field("backfillDone"));
18227 }
18228 backfill_done__ = Some(map_.next_value()?);
18229 }
18230 }
18231 }
18232 Ok(TableFragments {
18233 table_id: table_id__.unwrap_or_default(),
18234 state: state__.unwrap_or_default(),
18235 fragments: fragments__.unwrap_or_default(),
18236 actor_status: actor_status__.unwrap_or_default(),
18237 ctx: ctx__,
18238 parallelism: parallelism__,
18239 max_parallelism: max_parallelism__,
18240 node_label: node_label__.unwrap_or_default(),
18241 backfill_done: backfill_done__.unwrap_or_default(),
18242 })
18243 }
18244 }
18245 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
18246 }
18247}
18248impl serde::Serialize for table_fragments::ActorStatus {
18249 #[allow(deprecated)]
18250 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18251 where
18252 S: serde::Serializer,
18253 {
18254 use serde::ser::SerializeStruct;
18255 let mut len = 0;
18256 if self.location.is_some() {
18257 len += 1;
18258 }
18259 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
18260 if let Some(v) = self.location.as_ref() {
18261 struct_ser.serialize_field("location", v)?;
18262 }
18263 struct_ser.end()
18264 }
18265}
18266impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
18267 #[allow(deprecated)]
18268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18269 where
18270 D: serde::Deserializer<'de>,
18271 {
18272 const FIELDS: &[&str] = &[
18273 "location",
18274 ];
18275
18276 #[allow(clippy::enum_variant_names)]
18277 enum GeneratedField {
18278 Location,
18279 }
18280 impl<'de> serde::Deserialize<'de> for GeneratedField {
18281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18282 where
18283 D: serde::Deserializer<'de>,
18284 {
18285 struct GeneratedVisitor;
18286
18287 impl serde::de::Visitor<'_> for GeneratedVisitor {
18288 type Value = GeneratedField;
18289
18290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18291 write!(formatter, "expected one of: {:?}", &FIELDS)
18292 }
18293
18294 #[allow(unused_variables)]
18295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18296 where
18297 E: serde::de::Error,
18298 {
18299 match value {
18300 "location" => Ok(GeneratedField::Location),
18301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18302 }
18303 }
18304 }
18305 deserializer.deserialize_identifier(GeneratedVisitor)
18306 }
18307 }
18308 struct GeneratedVisitor;
18309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18310 type Value = table_fragments::ActorStatus;
18311
18312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18313 formatter.write_str("struct meta.TableFragments.ActorStatus")
18314 }
18315
18316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
18317 where
18318 V: serde::de::MapAccess<'de>,
18319 {
18320 let mut location__ = None;
18321 while let Some(k) = map_.next_key()? {
18322 match k {
18323 GeneratedField::Location => {
18324 if location__.is_some() {
18325 return Err(serde::de::Error::duplicate_field("location"));
18326 }
18327 location__ = map_.next_value()?;
18328 }
18329 }
18330 }
18331 Ok(table_fragments::ActorStatus {
18332 location: location__,
18333 })
18334 }
18335 }
18336 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
18337 }
18338}
18339impl serde::Serialize for table_fragments::Fragment {
18340 #[allow(deprecated)]
18341 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18342 where
18343 S: serde::Serializer,
18344 {
18345 use serde::ser::SerializeStruct;
18346 let mut len = 0;
18347 if self.fragment_id != 0 {
18348 len += 1;
18349 }
18350 if self.fragment_type_mask != 0 {
18351 len += 1;
18352 }
18353 if self.distribution_type != 0 {
18354 len += 1;
18355 }
18356 if !self.actors.is_empty() {
18357 len += 1;
18358 }
18359 if !self.state_table_ids.is_empty() {
18360 len += 1;
18361 }
18362 if !self.upstream_fragment_ids.is_empty() {
18363 len += 1;
18364 }
18365 if self.maybe_vnode_count.is_some() {
18366 len += 1;
18367 }
18368 if self.nodes.is_some() {
18369 len += 1;
18370 }
18371 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
18372 if self.fragment_id != 0 {
18373 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
18374 }
18375 if self.fragment_type_mask != 0 {
18376 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
18377 }
18378 if self.distribution_type != 0 {
18379 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
18380 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
18381 struct_ser.serialize_field("distributionType", &v)?;
18382 }
18383 if !self.actors.is_empty() {
18384 struct_ser.serialize_field("actors", &self.actors)?;
18385 }
18386 if !self.state_table_ids.is_empty() {
18387 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
18388 }
18389 if !self.upstream_fragment_ids.is_empty() {
18390 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
18391 }
18392 if let Some(v) = self.maybe_vnode_count.as_ref() {
18393 struct_ser.serialize_field("maybeVnodeCount", v)?;
18394 }
18395 if let Some(v) = self.nodes.as_ref() {
18396 struct_ser.serialize_field("nodes", v)?;
18397 }
18398 struct_ser.end()
18399 }
18400}
18401impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
18402 #[allow(deprecated)]
18403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18404 where
18405 D: serde::Deserializer<'de>,
18406 {
18407 const FIELDS: &[&str] = &[
18408 "fragment_id",
18409 "fragmentId",
18410 "fragment_type_mask",
18411 "fragmentTypeMask",
18412 "distribution_type",
18413 "distributionType",
18414 "actors",
18415 "state_table_ids",
18416 "stateTableIds",
18417 "upstream_fragment_ids",
18418 "upstreamFragmentIds",
18419 "maybe_vnode_count",
18420 "maybeVnodeCount",
18421 "nodes",
18422 ];
18423
18424 #[allow(clippy::enum_variant_names)]
18425 enum GeneratedField {
18426 FragmentId,
18427 FragmentTypeMask,
18428 DistributionType,
18429 Actors,
18430 StateTableIds,
18431 UpstreamFragmentIds,
18432 MaybeVnodeCount,
18433 Nodes,
18434 }
18435 impl<'de> serde::Deserialize<'de> for GeneratedField {
18436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18437 where
18438 D: serde::Deserializer<'de>,
18439 {
18440 struct GeneratedVisitor;
18441
18442 impl serde::de::Visitor<'_> for GeneratedVisitor {
18443 type Value = GeneratedField;
18444
18445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18446 write!(formatter, "expected one of: {:?}", &FIELDS)
18447 }
18448
18449 #[allow(unused_variables)]
18450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18451 where
18452 E: serde::de::Error,
18453 {
18454 match value {
18455 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
18456 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
18457 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
18458 "actors" => Ok(GeneratedField::Actors),
18459 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
18460 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
18461 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
18462 "nodes" => Ok(GeneratedField::Nodes),
18463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18464 }
18465 }
18466 }
18467 deserializer.deserialize_identifier(GeneratedVisitor)
18468 }
18469 }
18470 struct GeneratedVisitor;
18471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18472 type Value = table_fragments::Fragment;
18473
18474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18475 formatter.write_str("struct meta.TableFragments.Fragment")
18476 }
18477
18478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
18479 where
18480 V: serde::de::MapAccess<'de>,
18481 {
18482 let mut fragment_id__ = None;
18483 let mut fragment_type_mask__ = None;
18484 let mut distribution_type__ = None;
18485 let mut actors__ = None;
18486 let mut state_table_ids__ = None;
18487 let mut upstream_fragment_ids__ = None;
18488 let mut maybe_vnode_count__ = None;
18489 let mut nodes__ = None;
18490 while let Some(k) = map_.next_key()? {
18491 match k {
18492 GeneratedField::FragmentId => {
18493 if fragment_id__.is_some() {
18494 return Err(serde::de::Error::duplicate_field("fragmentId"));
18495 }
18496 fragment_id__ =
18497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18498 ;
18499 }
18500 GeneratedField::FragmentTypeMask => {
18501 if fragment_type_mask__.is_some() {
18502 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
18503 }
18504 fragment_type_mask__ =
18505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18506 ;
18507 }
18508 GeneratedField::DistributionType => {
18509 if distribution_type__.is_some() {
18510 return Err(serde::de::Error::duplicate_field("distributionType"));
18511 }
18512 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
18513 }
18514 GeneratedField::Actors => {
18515 if actors__.is_some() {
18516 return Err(serde::de::Error::duplicate_field("actors"));
18517 }
18518 actors__ = Some(map_.next_value()?);
18519 }
18520 GeneratedField::StateTableIds => {
18521 if state_table_ids__.is_some() {
18522 return Err(serde::de::Error::duplicate_field("stateTableIds"));
18523 }
18524 state_table_ids__ =
18525 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18526 .into_iter().map(|x| x.0).collect())
18527 ;
18528 }
18529 GeneratedField::UpstreamFragmentIds => {
18530 if upstream_fragment_ids__.is_some() {
18531 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
18532 }
18533 upstream_fragment_ids__ =
18534 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18535 .into_iter().map(|x| x.0).collect())
18536 ;
18537 }
18538 GeneratedField::MaybeVnodeCount => {
18539 if maybe_vnode_count__.is_some() {
18540 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
18541 }
18542 maybe_vnode_count__ =
18543 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18544 ;
18545 }
18546 GeneratedField::Nodes => {
18547 if nodes__.is_some() {
18548 return Err(serde::de::Error::duplicate_field("nodes"));
18549 }
18550 nodes__ = map_.next_value()?;
18551 }
18552 }
18553 }
18554 Ok(table_fragments::Fragment {
18555 fragment_id: fragment_id__.unwrap_or_default(),
18556 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
18557 distribution_type: distribution_type__.unwrap_or_default(),
18558 actors: actors__.unwrap_or_default(),
18559 state_table_ids: state_table_ids__.unwrap_or_default(),
18560 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
18561 maybe_vnode_count: maybe_vnode_count__,
18562 nodes: nodes__,
18563 })
18564 }
18565 }
18566 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
18567 }
18568}
18569impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
18570 #[allow(deprecated)]
18571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18572 where
18573 S: serde::Serializer,
18574 {
18575 let variant = match self {
18576 Self::Unspecified => "UNSPECIFIED",
18577 Self::Single => "SINGLE",
18578 Self::Hash => "HASH",
18579 };
18580 serializer.serialize_str(variant)
18581 }
18582}
18583impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
18584 #[allow(deprecated)]
18585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18586 where
18587 D: serde::Deserializer<'de>,
18588 {
18589 const FIELDS: &[&str] = &[
18590 "UNSPECIFIED",
18591 "SINGLE",
18592 "HASH",
18593 ];
18594
18595 struct GeneratedVisitor;
18596
18597 impl serde::de::Visitor<'_> for GeneratedVisitor {
18598 type Value = table_fragments::fragment::FragmentDistributionType;
18599
18600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18601 write!(formatter, "expected one of: {:?}", &FIELDS)
18602 }
18603
18604 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18605 where
18606 E: serde::de::Error,
18607 {
18608 i32::try_from(v)
18609 .ok()
18610 .and_then(|x| x.try_into().ok())
18611 .ok_or_else(|| {
18612 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18613 })
18614 }
18615
18616 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18617 where
18618 E: serde::de::Error,
18619 {
18620 i32::try_from(v)
18621 .ok()
18622 .and_then(|x| x.try_into().ok())
18623 .ok_or_else(|| {
18624 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18625 })
18626 }
18627
18628 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18629 where
18630 E: serde::de::Error,
18631 {
18632 match value {
18633 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
18634 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
18635 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
18636 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18637 }
18638 }
18639 }
18640 deserializer.deserialize_any(GeneratedVisitor)
18641 }
18642}
18643impl serde::Serialize for table_fragments::State {
18644 #[allow(deprecated)]
18645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18646 where
18647 S: serde::Serializer,
18648 {
18649 let variant = match self {
18650 Self::Unspecified => "UNSPECIFIED",
18651 Self::Initial => "INITIAL",
18652 Self::Creating => "CREATING",
18653 Self::Created => "CREATED",
18654 };
18655 serializer.serialize_str(variant)
18656 }
18657}
18658impl<'de> serde::Deserialize<'de> for table_fragments::State {
18659 #[allow(deprecated)]
18660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18661 where
18662 D: serde::Deserializer<'de>,
18663 {
18664 const FIELDS: &[&str] = &[
18665 "UNSPECIFIED",
18666 "INITIAL",
18667 "CREATING",
18668 "CREATED",
18669 ];
18670
18671 struct GeneratedVisitor;
18672
18673 impl serde::de::Visitor<'_> for GeneratedVisitor {
18674 type Value = table_fragments::State;
18675
18676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18677 write!(formatter, "expected one of: {:?}", &FIELDS)
18678 }
18679
18680 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18681 where
18682 E: serde::de::Error,
18683 {
18684 i32::try_from(v)
18685 .ok()
18686 .and_then(|x| x.try_into().ok())
18687 .ok_or_else(|| {
18688 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18689 })
18690 }
18691
18692 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18693 where
18694 E: serde::de::Error,
18695 {
18696 i32::try_from(v)
18697 .ok()
18698 .and_then(|x| x.try_into().ok())
18699 .ok_or_else(|| {
18700 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18701 })
18702 }
18703
18704 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18705 where
18706 E: serde::de::Error,
18707 {
18708 match value {
18709 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
18710 "INITIAL" => Ok(table_fragments::State::Initial),
18711 "CREATING" => Ok(table_fragments::State::Creating),
18712 "CREATED" => Ok(table_fragments::State::Created),
18713 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18714 }
18715 }
18716 }
18717 deserializer.deserialize_any(GeneratedVisitor)
18718 }
18719}
18720impl serde::Serialize for TableParallelism {
18721 #[allow(deprecated)]
18722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18723 where
18724 S: serde::Serializer,
18725 {
18726 use serde::ser::SerializeStruct;
18727 let mut len = 0;
18728 if self.parallelism.is_some() {
18729 len += 1;
18730 }
18731 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
18732 if let Some(v) = self.parallelism.as_ref() {
18733 match v {
18734 table_parallelism::Parallelism::Fixed(v) => {
18735 struct_ser.serialize_field("fixed", v)?;
18736 }
18737 table_parallelism::Parallelism::Auto(v) => {
18738 struct_ser.serialize_field("auto", v)?;
18739 }
18740 table_parallelism::Parallelism::Custom(v) => {
18741 struct_ser.serialize_field("custom", v)?;
18742 }
18743 table_parallelism::Parallelism::Adaptive(v) => {
18744 struct_ser.serialize_field("adaptive", v)?;
18745 }
18746 }
18747 }
18748 struct_ser.end()
18749 }
18750}
18751impl<'de> serde::Deserialize<'de> for TableParallelism {
18752 #[allow(deprecated)]
18753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18754 where
18755 D: serde::Deserializer<'de>,
18756 {
18757 const FIELDS: &[&str] = &[
18758 "fixed",
18759 "auto",
18760 "custom",
18761 "adaptive",
18762 ];
18763
18764 #[allow(clippy::enum_variant_names)]
18765 enum GeneratedField {
18766 Fixed,
18767 Auto,
18768 Custom,
18769 Adaptive,
18770 }
18771 impl<'de> serde::Deserialize<'de> for GeneratedField {
18772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18773 where
18774 D: serde::Deserializer<'de>,
18775 {
18776 struct GeneratedVisitor;
18777
18778 impl serde::de::Visitor<'_> for GeneratedVisitor {
18779 type Value = GeneratedField;
18780
18781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18782 write!(formatter, "expected one of: {:?}", &FIELDS)
18783 }
18784
18785 #[allow(unused_variables)]
18786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18787 where
18788 E: serde::de::Error,
18789 {
18790 match value {
18791 "fixed" => Ok(GeneratedField::Fixed),
18792 "auto" => Ok(GeneratedField::Auto),
18793 "custom" => Ok(GeneratedField::Custom),
18794 "adaptive" => Ok(GeneratedField::Adaptive),
18795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18796 }
18797 }
18798 }
18799 deserializer.deserialize_identifier(GeneratedVisitor)
18800 }
18801 }
18802 struct GeneratedVisitor;
18803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18804 type Value = TableParallelism;
18805
18806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18807 formatter.write_str("struct meta.TableParallelism")
18808 }
18809
18810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
18811 where
18812 V: serde::de::MapAccess<'de>,
18813 {
18814 let mut parallelism__ = None;
18815 while let Some(k) = map_.next_key()? {
18816 match k {
18817 GeneratedField::Fixed => {
18818 if parallelism__.is_some() {
18819 return Err(serde::de::Error::duplicate_field("fixed"));
18820 }
18821 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
18822;
18823 }
18824 GeneratedField::Auto => {
18825 if parallelism__.is_some() {
18826 return Err(serde::de::Error::duplicate_field("auto"));
18827 }
18828 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
18829;
18830 }
18831 GeneratedField::Custom => {
18832 if parallelism__.is_some() {
18833 return Err(serde::de::Error::duplicate_field("custom"));
18834 }
18835 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
18836;
18837 }
18838 GeneratedField::Adaptive => {
18839 if parallelism__.is_some() {
18840 return Err(serde::de::Error::duplicate_field("adaptive"));
18841 }
18842 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
18843;
18844 }
18845 }
18846 }
18847 Ok(TableParallelism {
18848 parallelism: parallelism__,
18849 })
18850 }
18851 }
18852 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
18853 }
18854}
18855impl serde::Serialize for table_parallelism::AdaptiveParallelism {
18856 #[allow(deprecated)]
18857 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18858 where
18859 S: serde::Serializer,
18860 {
18861 use serde::ser::SerializeStruct;
18862 let len = 0;
18863 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
18864 struct_ser.end()
18865 }
18866}
18867impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
18868 #[allow(deprecated)]
18869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18870 where
18871 D: serde::Deserializer<'de>,
18872 {
18873 const FIELDS: &[&str] = &[
18874 ];
18875
18876 #[allow(clippy::enum_variant_names)]
18877 enum GeneratedField {
18878 }
18879 impl<'de> serde::Deserialize<'de> for GeneratedField {
18880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18881 where
18882 D: serde::Deserializer<'de>,
18883 {
18884 struct GeneratedVisitor;
18885
18886 impl serde::de::Visitor<'_> for GeneratedVisitor {
18887 type Value = GeneratedField;
18888
18889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18890 write!(formatter, "expected one of: {:?}", &FIELDS)
18891 }
18892
18893 #[allow(unused_variables)]
18894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18895 where
18896 E: serde::de::Error,
18897 {
18898 Err(serde::de::Error::unknown_field(value, FIELDS))
18899 }
18900 }
18901 deserializer.deserialize_identifier(GeneratedVisitor)
18902 }
18903 }
18904 struct GeneratedVisitor;
18905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18906 type Value = table_parallelism::AdaptiveParallelism;
18907
18908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18909 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
18910 }
18911
18912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
18913 where
18914 V: serde::de::MapAccess<'de>,
18915 {
18916 while map_.next_key::<GeneratedField>()?.is_some() {
18917 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18918 }
18919 Ok(table_parallelism::AdaptiveParallelism {
18920 })
18921 }
18922 }
18923 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
18924 }
18925}
18926impl serde::Serialize for table_parallelism::AutoParallelism {
18927 #[allow(deprecated)]
18928 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18929 where
18930 S: serde::Serializer,
18931 {
18932 use serde::ser::SerializeStruct;
18933 let len = 0;
18934 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
18935 struct_ser.end()
18936 }
18937}
18938impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
18939 #[allow(deprecated)]
18940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18941 where
18942 D: serde::Deserializer<'de>,
18943 {
18944 const FIELDS: &[&str] = &[
18945 ];
18946
18947 #[allow(clippy::enum_variant_names)]
18948 enum GeneratedField {
18949 }
18950 impl<'de> serde::Deserialize<'de> for GeneratedField {
18951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18952 where
18953 D: serde::Deserializer<'de>,
18954 {
18955 struct GeneratedVisitor;
18956
18957 impl serde::de::Visitor<'_> for GeneratedVisitor {
18958 type Value = GeneratedField;
18959
18960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18961 write!(formatter, "expected one of: {:?}", &FIELDS)
18962 }
18963
18964 #[allow(unused_variables)]
18965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18966 where
18967 E: serde::de::Error,
18968 {
18969 Err(serde::de::Error::unknown_field(value, FIELDS))
18970 }
18971 }
18972 deserializer.deserialize_identifier(GeneratedVisitor)
18973 }
18974 }
18975 struct GeneratedVisitor;
18976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18977 type Value = table_parallelism::AutoParallelism;
18978
18979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18980 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
18981 }
18982
18983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
18984 where
18985 V: serde::de::MapAccess<'de>,
18986 {
18987 while map_.next_key::<GeneratedField>()?.is_some() {
18988 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18989 }
18990 Ok(table_parallelism::AutoParallelism {
18991 })
18992 }
18993 }
18994 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
18995 }
18996}
18997impl serde::Serialize for table_parallelism::CustomParallelism {
18998 #[allow(deprecated)]
18999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19000 where
19001 S: serde::Serializer,
19002 {
19003 use serde::ser::SerializeStruct;
19004 let len = 0;
19005 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
19006 struct_ser.end()
19007 }
19008}
19009impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
19010 #[allow(deprecated)]
19011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19012 where
19013 D: serde::Deserializer<'de>,
19014 {
19015 const FIELDS: &[&str] = &[
19016 ];
19017
19018 #[allow(clippy::enum_variant_names)]
19019 enum GeneratedField {
19020 }
19021 impl<'de> serde::Deserialize<'de> for GeneratedField {
19022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19023 where
19024 D: serde::Deserializer<'de>,
19025 {
19026 struct GeneratedVisitor;
19027
19028 impl serde::de::Visitor<'_> for GeneratedVisitor {
19029 type Value = GeneratedField;
19030
19031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19032 write!(formatter, "expected one of: {:?}", &FIELDS)
19033 }
19034
19035 #[allow(unused_variables)]
19036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19037 where
19038 E: serde::de::Error,
19039 {
19040 Err(serde::de::Error::unknown_field(value, FIELDS))
19041 }
19042 }
19043 deserializer.deserialize_identifier(GeneratedVisitor)
19044 }
19045 }
19046 struct GeneratedVisitor;
19047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19048 type Value = table_parallelism::CustomParallelism;
19049
19050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19051 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
19052 }
19053
19054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
19055 where
19056 V: serde::de::MapAccess<'de>,
19057 {
19058 while map_.next_key::<GeneratedField>()?.is_some() {
19059 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19060 }
19061 Ok(table_parallelism::CustomParallelism {
19062 })
19063 }
19064 }
19065 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
19066 }
19067}
19068impl serde::Serialize for table_parallelism::FixedParallelism {
19069 #[allow(deprecated)]
19070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19071 where
19072 S: serde::Serializer,
19073 {
19074 use serde::ser::SerializeStruct;
19075 let mut len = 0;
19076 if self.parallelism != 0 {
19077 len += 1;
19078 }
19079 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
19080 if self.parallelism != 0 {
19081 struct_ser.serialize_field("parallelism", &self.parallelism)?;
19082 }
19083 struct_ser.end()
19084 }
19085}
19086impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
19087 #[allow(deprecated)]
19088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19089 where
19090 D: serde::Deserializer<'de>,
19091 {
19092 const FIELDS: &[&str] = &[
19093 "parallelism",
19094 ];
19095
19096 #[allow(clippy::enum_variant_names)]
19097 enum GeneratedField {
19098 Parallelism,
19099 }
19100 impl<'de> serde::Deserialize<'de> for GeneratedField {
19101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19102 where
19103 D: serde::Deserializer<'de>,
19104 {
19105 struct GeneratedVisitor;
19106
19107 impl serde::de::Visitor<'_> for GeneratedVisitor {
19108 type Value = GeneratedField;
19109
19110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19111 write!(formatter, "expected one of: {:?}", &FIELDS)
19112 }
19113
19114 #[allow(unused_variables)]
19115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19116 where
19117 E: serde::de::Error,
19118 {
19119 match value {
19120 "parallelism" => Ok(GeneratedField::Parallelism),
19121 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19122 }
19123 }
19124 }
19125 deserializer.deserialize_identifier(GeneratedVisitor)
19126 }
19127 }
19128 struct GeneratedVisitor;
19129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19130 type Value = table_parallelism::FixedParallelism;
19131
19132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19133 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
19134 }
19135
19136 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
19137 where
19138 V: serde::de::MapAccess<'de>,
19139 {
19140 let mut parallelism__ = None;
19141 while let Some(k) = map_.next_key()? {
19142 match k {
19143 GeneratedField::Parallelism => {
19144 if parallelism__.is_some() {
19145 return Err(serde::de::Error::duplicate_field("parallelism"));
19146 }
19147 parallelism__ =
19148 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19149 ;
19150 }
19151 }
19152 }
19153 Ok(table_parallelism::FixedParallelism {
19154 parallelism: parallelism__.unwrap_or_default(),
19155 })
19156 }
19157 }
19158 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
19159 }
19160}
19161impl serde::Serialize for TelemetryInfoResponse {
19162 #[allow(deprecated)]
19163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19164 where
19165 S: serde::Serializer,
19166 {
19167 use serde::ser::SerializeStruct;
19168 let mut len = 0;
19169 if self.tracking_id.is_some() {
19170 len += 1;
19171 }
19172 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
19173 if let Some(v) = self.tracking_id.as_ref() {
19174 struct_ser.serialize_field("trackingId", v)?;
19175 }
19176 struct_ser.end()
19177 }
19178}
19179impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
19180 #[allow(deprecated)]
19181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19182 where
19183 D: serde::Deserializer<'de>,
19184 {
19185 const FIELDS: &[&str] = &[
19186 "tracking_id",
19187 "trackingId",
19188 ];
19189
19190 #[allow(clippy::enum_variant_names)]
19191 enum GeneratedField {
19192 TrackingId,
19193 }
19194 impl<'de> serde::Deserialize<'de> for GeneratedField {
19195 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19196 where
19197 D: serde::Deserializer<'de>,
19198 {
19199 struct GeneratedVisitor;
19200
19201 impl serde::de::Visitor<'_> for GeneratedVisitor {
19202 type Value = GeneratedField;
19203
19204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19205 write!(formatter, "expected one of: {:?}", &FIELDS)
19206 }
19207
19208 #[allow(unused_variables)]
19209 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19210 where
19211 E: serde::de::Error,
19212 {
19213 match value {
19214 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
19215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19216 }
19217 }
19218 }
19219 deserializer.deserialize_identifier(GeneratedVisitor)
19220 }
19221 }
19222 struct GeneratedVisitor;
19223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19224 type Value = TelemetryInfoResponse;
19225
19226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19227 formatter.write_str("struct meta.TelemetryInfoResponse")
19228 }
19229
19230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
19231 where
19232 V: serde::de::MapAccess<'de>,
19233 {
19234 let mut tracking_id__ = None;
19235 while let Some(k) = map_.next_key()? {
19236 match k {
19237 GeneratedField::TrackingId => {
19238 if tracking_id__.is_some() {
19239 return Err(serde::de::Error::duplicate_field("trackingId"));
19240 }
19241 tracking_id__ = map_.next_value()?;
19242 }
19243 }
19244 }
19245 Ok(TelemetryInfoResponse {
19246 tracking_id: tracking_id__,
19247 })
19248 }
19249 }
19250 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
19251 }
19252}
19253impl serde::Serialize for ThrottleTarget {
19254 #[allow(deprecated)]
19255 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19256 where
19257 S: serde::Serializer,
19258 {
19259 let variant = match self {
19260 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
19261 Self::Source => "SOURCE",
19262 Self::Mv => "MV",
19263 Self::Table => "TABLE",
19264 Self::Sink => "SINK",
19265 Self::Fragment => "FRAGMENT",
19266 };
19267 serializer.serialize_str(variant)
19268 }
19269}
19270impl<'de> serde::Deserialize<'de> for ThrottleTarget {
19271 #[allow(deprecated)]
19272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19273 where
19274 D: serde::Deserializer<'de>,
19275 {
19276 const FIELDS: &[&str] = &[
19277 "THROTTLE_TARGET_UNSPECIFIED",
19278 "SOURCE",
19279 "MV",
19280 "TABLE",
19281 "SINK",
19282 "FRAGMENT",
19283 ];
19284
19285 struct GeneratedVisitor;
19286
19287 impl serde::de::Visitor<'_> for GeneratedVisitor {
19288 type Value = ThrottleTarget;
19289
19290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19291 write!(formatter, "expected one of: {:?}", &FIELDS)
19292 }
19293
19294 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19295 where
19296 E: serde::de::Error,
19297 {
19298 i32::try_from(v)
19299 .ok()
19300 .and_then(|x| x.try_into().ok())
19301 .ok_or_else(|| {
19302 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19303 })
19304 }
19305
19306 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19307 where
19308 E: serde::de::Error,
19309 {
19310 i32::try_from(v)
19311 .ok()
19312 .and_then(|x| x.try_into().ok())
19313 .ok_or_else(|| {
19314 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19315 })
19316 }
19317
19318 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19319 where
19320 E: serde::de::Error,
19321 {
19322 match value {
19323 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
19324 "SOURCE" => Ok(ThrottleTarget::Source),
19325 "MV" => Ok(ThrottleTarget::Mv),
19326 "TABLE" => Ok(ThrottleTarget::Table),
19327 "SINK" => Ok(ThrottleTarget::Sink),
19328 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
19329 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19330 }
19331 }
19332 }
19333 deserializer.deserialize_any(GeneratedVisitor)
19334 }
19335}
19336impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
19337 #[allow(deprecated)]
19338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19339 where
19340 S: serde::Serializer,
19341 {
19342 use serde::ser::SerializeStruct;
19343 let mut len = 0;
19344 if self.id != 0 {
19345 len += 1;
19346 }
19347 if !self.node_label.is_empty() {
19348 len += 1;
19349 }
19350 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
19351 if self.id != 0 {
19352 struct_ser.serialize_field("id", &self.id)?;
19353 }
19354 if !self.node_label.is_empty() {
19355 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
19356 }
19357 struct_ser.end()
19358 }
19359}
19360impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
19361 #[allow(deprecated)]
19362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19363 where
19364 D: serde::Deserializer<'de>,
19365 {
19366 const FIELDS: &[&str] = &[
19367 "id",
19368 "node_label",
19369 "nodeLabel",
19370 ];
19371
19372 #[allow(clippy::enum_variant_names)]
19373 enum GeneratedField {
19374 Id,
19375 NodeLabel,
19376 }
19377 impl<'de> serde::Deserialize<'de> for GeneratedField {
19378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19379 where
19380 D: serde::Deserializer<'de>,
19381 {
19382 struct GeneratedVisitor;
19383
19384 impl serde::de::Visitor<'_> for GeneratedVisitor {
19385 type Value = GeneratedField;
19386
19387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19388 write!(formatter, "expected one of: {:?}", &FIELDS)
19389 }
19390
19391 #[allow(unused_variables)]
19392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19393 where
19394 E: serde::de::Error,
19395 {
19396 match value {
19397 "id" => Ok(GeneratedField::Id),
19398 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
19399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19400 }
19401 }
19402 }
19403 deserializer.deserialize_identifier(GeneratedVisitor)
19404 }
19405 }
19406 struct GeneratedVisitor;
19407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19408 type Value = UpdateStreamingJobNodeLabelsRequest;
19409
19410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19411 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
19412 }
19413
19414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
19415 where
19416 V: serde::de::MapAccess<'de>,
19417 {
19418 let mut id__ = None;
19419 let mut node_label__ = None;
19420 while let Some(k) = map_.next_key()? {
19421 match k {
19422 GeneratedField::Id => {
19423 if id__.is_some() {
19424 return Err(serde::de::Error::duplicate_field("id"));
19425 }
19426 id__ =
19427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19428 ;
19429 }
19430 GeneratedField::NodeLabel => {
19431 if node_label__.is_some() {
19432 return Err(serde::de::Error::duplicate_field("nodeLabel"));
19433 }
19434 node_label__ = Some(map_.next_value()?);
19435 }
19436 }
19437 }
19438 Ok(UpdateStreamingJobNodeLabelsRequest {
19439 id: id__.unwrap_or_default(),
19440 node_label: node_label__.unwrap_or_default(),
19441 })
19442 }
19443 }
19444 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
19445 }
19446}
19447impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
19448 #[allow(deprecated)]
19449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19450 where
19451 S: serde::Serializer,
19452 {
19453 use serde::ser::SerializeStruct;
19454 let len = 0;
19455 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
19456 struct_ser.end()
19457 }
19458}
19459impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
19460 #[allow(deprecated)]
19461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19462 where
19463 D: serde::Deserializer<'de>,
19464 {
19465 const FIELDS: &[&str] = &[
19466 ];
19467
19468 #[allow(clippy::enum_variant_names)]
19469 enum GeneratedField {
19470 }
19471 impl<'de> serde::Deserialize<'de> for GeneratedField {
19472 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19473 where
19474 D: serde::Deserializer<'de>,
19475 {
19476 struct GeneratedVisitor;
19477
19478 impl serde::de::Visitor<'_> for GeneratedVisitor {
19479 type Value = GeneratedField;
19480
19481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19482 write!(formatter, "expected one of: {:?}", &FIELDS)
19483 }
19484
19485 #[allow(unused_variables)]
19486 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19487 where
19488 E: serde::de::Error,
19489 {
19490 Err(serde::de::Error::unknown_field(value, FIELDS))
19491 }
19492 }
19493 deserializer.deserialize_identifier(GeneratedVisitor)
19494 }
19495 }
19496 struct GeneratedVisitor;
19497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19498 type Value = UpdateStreamingJobNodeLabelsResponse;
19499
19500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19501 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
19502 }
19503
19504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
19505 where
19506 V: serde::de::MapAccess<'de>,
19507 {
19508 while map_.next_key::<GeneratedField>()?.is_some() {
19509 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19510 }
19511 Ok(UpdateStreamingJobNodeLabelsResponse {
19512 })
19513 }
19514 }
19515 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
19516 }
19517}
19518impl serde::Serialize for WorkerReschedule {
19519 #[allow(deprecated)]
19520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19521 where
19522 S: serde::Serializer,
19523 {
19524 use serde::ser::SerializeStruct;
19525 let mut len = 0;
19526 if !self.worker_actor_diff.is_empty() {
19527 len += 1;
19528 }
19529 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
19530 if !self.worker_actor_diff.is_empty() {
19531 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
19532 }
19533 struct_ser.end()
19534 }
19535}
19536impl<'de> serde::Deserialize<'de> for WorkerReschedule {
19537 #[allow(deprecated)]
19538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19539 where
19540 D: serde::Deserializer<'de>,
19541 {
19542 const FIELDS: &[&str] = &[
19543 "worker_actor_diff",
19544 "workerActorDiff",
19545 ];
19546
19547 #[allow(clippy::enum_variant_names)]
19548 enum GeneratedField {
19549 WorkerActorDiff,
19550 }
19551 impl<'de> serde::Deserialize<'de> for GeneratedField {
19552 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19553 where
19554 D: serde::Deserializer<'de>,
19555 {
19556 struct GeneratedVisitor;
19557
19558 impl serde::de::Visitor<'_> for GeneratedVisitor {
19559 type Value = GeneratedField;
19560
19561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19562 write!(formatter, "expected one of: {:?}", &FIELDS)
19563 }
19564
19565 #[allow(unused_variables)]
19566 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19567 where
19568 E: serde::de::Error,
19569 {
19570 match value {
19571 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
19572 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19573 }
19574 }
19575 }
19576 deserializer.deserialize_identifier(GeneratedVisitor)
19577 }
19578 }
19579 struct GeneratedVisitor;
19580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19581 type Value = WorkerReschedule;
19582
19583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19584 formatter.write_str("struct meta.WorkerReschedule")
19585 }
19586
19587 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
19588 where
19589 V: serde::de::MapAccess<'de>,
19590 {
19591 let mut worker_actor_diff__ = None;
19592 while let Some(k) = map_.next_key()? {
19593 match k {
19594 GeneratedField::WorkerActorDiff => {
19595 if worker_actor_diff__.is_some() {
19596 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
19597 }
19598 worker_actor_diff__ = Some(
19599 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
19600 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
19601 );
19602 }
19603 }
19604 }
19605 Ok(WorkerReschedule {
19606 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
19607 })
19608 }
19609 }
19610 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
19611 }
19612}