1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::meta::*;
4impl serde::Serialize for ActivateWorkerNodeRequest {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if self.host.is_some() {
13 len += 1;
14 }
15 if self.node_id != 0 {
16 len += 1;
17 }
18 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
19 if let Some(v) = self.host.as_ref() {
20 struct_ser.serialize_field("host", v)?;
21 }
22 if self.node_id != 0 {
23 struct_ser.serialize_field("nodeId", &self.node_id)?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "host",
36 "node_id",
37 "nodeId",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 Host,
43 NodeId,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl serde::de::Visitor<'_> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "host" => Ok(GeneratedField::Host),
66 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ActivateWorkerNodeRequest;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut host__ = None;
87 let mut node_id__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::Host => {
91 if host__.is_some() {
92 return Err(serde::de::Error::duplicate_field("host"));
93 }
94 host__ = map_.next_value()?;
95 }
96 GeneratedField::NodeId => {
97 if node_id__.is_some() {
98 return Err(serde::de::Error::duplicate_field("nodeId"));
99 }
100 node_id__ =
101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
102 ;
103 }
104 }
105 }
106 Ok(ActivateWorkerNodeRequest {
107 host: host__,
108 node_id: node_id__.unwrap_or_default(),
109 })
110 }
111 }
112 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
113 }
114}
115impl serde::Serialize for ActivateWorkerNodeResponse {
116 #[allow(deprecated)]
117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
118 where
119 S: serde::Serializer,
120 {
121 use serde::ser::SerializeStruct;
122 let mut len = 0;
123 if self.status.is_some() {
124 len += 1;
125 }
126 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
127 if let Some(v) = self.status.as_ref() {
128 struct_ser.serialize_field("status", v)?;
129 }
130 struct_ser.end()
131 }
132}
133impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
134 #[allow(deprecated)]
135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
136 where
137 D: serde::Deserializer<'de>,
138 {
139 const FIELDS: &[&str] = &[
140 "status",
141 ];
142
143 #[allow(clippy::enum_variant_names)]
144 enum GeneratedField {
145 Status,
146 }
147 impl<'de> serde::Deserialize<'de> for GeneratedField {
148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
149 where
150 D: serde::Deserializer<'de>,
151 {
152 struct GeneratedVisitor;
153
154 impl serde::de::Visitor<'_> for GeneratedVisitor {
155 type Value = GeneratedField;
156
157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158 write!(formatter, "expected one of: {:?}", &FIELDS)
159 }
160
161 #[allow(unused_variables)]
162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
163 where
164 E: serde::de::Error,
165 {
166 match value {
167 "status" => Ok(GeneratedField::Status),
168 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
169 }
170 }
171 }
172 deserializer.deserialize_identifier(GeneratedVisitor)
173 }
174 }
175 struct GeneratedVisitor;
176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
177 type Value = ActivateWorkerNodeResponse;
178
179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
180 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
181 }
182
183 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
184 where
185 V: serde::de::MapAccess<'de>,
186 {
187 let mut status__ = None;
188 while let Some(k) = map_.next_key()? {
189 match k {
190 GeneratedField::Status => {
191 if status__.is_some() {
192 return Err(serde::de::Error::duplicate_field("status"));
193 }
194 status__ = map_.next_value()?;
195 }
196 }
197 }
198 Ok(ActivateWorkerNodeResponse {
199 status: status__,
200 })
201 }
202 }
203 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
204 }
205}
206impl serde::Serialize for ActorCountPerParallelism {
207 #[allow(deprecated)]
208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
209 where
210 S: serde::Serializer,
211 {
212 use serde::ser::SerializeStruct;
213 let mut len = 0;
214 if !self.worker_id_to_actor_count.is_empty() {
215 len += 1;
216 }
217 if self.hard_limit != 0 {
218 len += 1;
219 }
220 if self.soft_limit != 0 {
221 len += 1;
222 }
223 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
224 if !self.worker_id_to_actor_count.is_empty() {
225 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
226 }
227 if self.hard_limit != 0 {
228 #[allow(clippy::needless_borrow)]
229 #[allow(clippy::needless_borrows_for_generic_args)]
230 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
231 }
232 if self.soft_limit != 0 {
233 #[allow(clippy::needless_borrow)]
234 #[allow(clippy::needless_borrows_for_generic_args)]
235 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
236 }
237 struct_ser.end()
238 }
239}
240impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
241 #[allow(deprecated)]
242 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
243 where
244 D: serde::Deserializer<'de>,
245 {
246 const FIELDS: &[&str] = &[
247 "worker_id_to_actor_count",
248 "workerIdToActorCount",
249 "hard_limit",
250 "hardLimit",
251 "soft_limit",
252 "softLimit",
253 ];
254
255 #[allow(clippy::enum_variant_names)]
256 enum GeneratedField {
257 WorkerIdToActorCount,
258 HardLimit,
259 SoftLimit,
260 }
261 impl<'de> serde::Deserialize<'de> for GeneratedField {
262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
263 where
264 D: serde::Deserializer<'de>,
265 {
266 struct GeneratedVisitor;
267
268 impl serde::de::Visitor<'_> for GeneratedVisitor {
269 type Value = GeneratedField;
270
271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 write!(formatter, "expected one of: {:?}", &FIELDS)
273 }
274
275 #[allow(unused_variables)]
276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
277 where
278 E: serde::de::Error,
279 {
280 match value {
281 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
282 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
283 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
285 }
286 }
287 }
288 deserializer.deserialize_identifier(GeneratedVisitor)
289 }
290 }
291 struct GeneratedVisitor;
292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
293 type Value = ActorCountPerParallelism;
294
295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
296 formatter.write_str("struct meta.ActorCountPerParallelism")
297 }
298
299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
300 where
301 V: serde::de::MapAccess<'de>,
302 {
303 let mut worker_id_to_actor_count__ = None;
304 let mut hard_limit__ = None;
305 let mut soft_limit__ = None;
306 while let Some(k) = map_.next_key()? {
307 match k {
308 GeneratedField::WorkerIdToActorCount => {
309 if worker_id_to_actor_count__.is_some() {
310 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
311 }
312 worker_id_to_actor_count__ = Some(
313 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
314 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
315 );
316 }
317 GeneratedField::HardLimit => {
318 if hard_limit__.is_some() {
319 return Err(serde::de::Error::duplicate_field("hardLimit"));
320 }
321 hard_limit__ =
322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
323 ;
324 }
325 GeneratedField::SoftLimit => {
326 if soft_limit__.is_some() {
327 return Err(serde::de::Error::duplicate_field("softLimit"));
328 }
329 soft_limit__ =
330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
331 ;
332 }
333 }
334 }
335 Ok(ActorCountPerParallelism {
336 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
337 hard_limit: hard_limit__.unwrap_or_default(),
338 soft_limit: soft_limit__.unwrap_or_default(),
339 })
340 }
341 }
342 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
343 }
344}
345impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
346 #[allow(deprecated)]
347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
348 where
349 S: serde::Serializer,
350 {
351 use serde::ser::SerializeStruct;
352 let mut len = 0;
353 if self.actor_count != 0 {
354 len += 1;
355 }
356 if self.parallelism != 0 {
357 len += 1;
358 }
359 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
360 if self.actor_count != 0 {
361 #[allow(clippy::needless_borrow)]
362 #[allow(clippy::needless_borrows_for_generic_args)]
363 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
364 }
365 if self.parallelism != 0 {
366 #[allow(clippy::needless_borrow)]
367 #[allow(clippy::needless_borrows_for_generic_args)]
368 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
369 }
370 struct_ser.end()
371 }
372}
373impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
374 #[allow(deprecated)]
375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
376 where
377 D: serde::Deserializer<'de>,
378 {
379 const FIELDS: &[&str] = &[
380 "actor_count",
381 "actorCount",
382 "parallelism",
383 ];
384
385 #[allow(clippy::enum_variant_names)]
386 enum GeneratedField {
387 ActorCount,
388 Parallelism,
389 }
390 impl<'de> serde::Deserialize<'de> for GeneratedField {
391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
392 where
393 D: serde::Deserializer<'de>,
394 {
395 struct GeneratedVisitor;
396
397 impl serde::de::Visitor<'_> for GeneratedVisitor {
398 type Value = GeneratedField;
399
400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401 write!(formatter, "expected one of: {:?}", &FIELDS)
402 }
403
404 #[allow(unused_variables)]
405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
406 where
407 E: serde::de::Error,
408 {
409 match value {
410 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
411 "parallelism" => Ok(GeneratedField::Parallelism),
412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
413 }
414 }
415 }
416 deserializer.deserialize_identifier(GeneratedVisitor)
417 }
418 }
419 struct GeneratedVisitor;
420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
421 type Value = actor_count_per_parallelism::WorkerActorCount;
422
423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
424 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
425 }
426
427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
428 where
429 V: serde::de::MapAccess<'de>,
430 {
431 let mut actor_count__ = None;
432 let mut parallelism__ = None;
433 while let Some(k) = map_.next_key()? {
434 match k {
435 GeneratedField::ActorCount => {
436 if actor_count__.is_some() {
437 return Err(serde::de::Error::duplicate_field("actorCount"));
438 }
439 actor_count__ =
440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
441 ;
442 }
443 GeneratedField::Parallelism => {
444 if parallelism__.is_some() {
445 return Err(serde::de::Error::duplicate_field("parallelism"));
446 }
447 parallelism__ =
448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
449 ;
450 }
451 }
452 }
453 Ok(actor_count_per_parallelism::WorkerActorCount {
454 actor_count: actor_count__.unwrap_or_default(),
455 parallelism: parallelism__.unwrap_or_default(),
456 })
457 }
458 }
459 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
460 }
461}
462impl serde::Serialize for ActorIds {
463 #[allow(deprecated)]
464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
465 where
466 S: serde::Serializer,
467 {
468 use serde::ser::SerializeStruct;
469 let mut len = 0;
470 if !self.ids.is_empty() {
471 len += 1;
472 }
473 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
474 if !self.ids.is_empty() {
475 struct_ser.serialize_field("ids", &self.ids)?;
476 }
477 struct_ser.end()
478 }
479}
480impl<'de> serde::Deserialize<'de> for ActorIds {
481 #[allow(deprecated)]
482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
483 where
484 D: serde::Deserializer<'de>,
485 {
486 const FIELDS: &[&str] = &[
487 "ids",
488 ];
489
490 #[allow(clippy::enum_variant_names)]
491 enum GeneratedField {
492 Ids,
493 }
494 impl<'de> serde::Deserialize<'de> for GeneratedField {
495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
496 where
497 D: serde::Deserializer<'de>,
498 {
499 struct GeneratedVisitor;
500
501 impl serde::de::Visitor<'_> for GeneratedVisitor {
502 type Value = GeneratedField;
503
504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
505 write!(formatter, "expected one of: {:?}", &FIELDS)
506 }
507
508 #[allow(unused_variables)]
509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
510 where
511 E: serde::de::Error,
512 {
513 match value {
514 "ids" => Ok(GeneratedField::Ids),
515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
516 }
517 }
518 }
519 deserializer.deserialize_identifier(GeneratedVisitor)
520 }
521 }
522 struct GeneratedVisitor;
523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
524 type Value = ActorIds;
525
526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
527 formatter.write_str("struct meta.ActorIds")
528 }
529
530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
531 where
532 V: serde::de::MapAccess<'de>,
533 {
534 let mut ids__ = None;
535 while let Some(k) = map_.next_key()? {
536 match k {
537 GeneratedField::Ids => {
538 if ids__.is_some() {
539 return Err(serde::de::Error::duplicate_field("ids"));
540 }
541 ids__ =
542 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
543 .into_iter().map(|x| x.0).collect())
544 ;
545 }
546 }
547 }
548 Ok(ActorIds {
549 ids: ids__.unwrap_or_default(),
550 })
551 }
552 }
553 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
554 }
555}
556impl serde::Serialize for ActorLocation {
557 #[allow(deprecated)]
558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
559 where
560 S: serde::Serializer,
561 {
562 use serde::ser::SerializeStruct;
563 let mut len = 0;
564 if self.node.is_some() {
565 len += 1;
566 }
567 if !self.actors.is_empty() {
568 len += 1;
569 }
570 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
571 if let Some(v) = self.node.as_ref() {
572 struct_ser.serialize_field("node", v)?;
573 }
574 if !self.actors.is_empty() {
575 struct_ser.serialize_field("actors", &self.actors)?;
576 }
577 struct_ser.end()
578 }
579}
580impl<'de> serde::Deserialize<'de> for ActorLocation {
581 #[allow(deprecated)]
582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
583 where
584 D: serde::Deserializer<'de>,
585 {
586 const FIELDS: &[&str] = &[
587 "node",
588 "actors",
589 ];
590
591 #[allow(clippy::enum_variant_names)]
592 enum GeneratedField {
593 Node,
594 Actors,
595 }
596 impl<'de> serde::Deserialize<'de> for GeneratedField {
597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
598 where
599 D: serde::Deserializer<'de>,
600 {
601 struct GeneratedVisitor;
602
603 impl serde::de::Visitor<'_> for GeneratedVisitor {
604 type Value = GeneratedField;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 write!(formatter, "expected one of: {:?}", &FIELDS)
608 }
609
610 #[allow(unused_variables)]
611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
612 where
613 E: serde::de::Error,
614 {
615 match value {
616 "node" => Ok(GeneratedField::Node),
617 "actors" => Ok(GeneratedField::Actors),
618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
619 }
620 }
621 }
622 deserializer.deserialize_identifier(GeneratedVisitor)
623 }
624 }
625 struct GeneratedVisitor;
626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
627 type Value = ActorLocation;
628
629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
630 formatter.write_str("struct meta.ActorLocation")
631 }
632
633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
634 where
635 V: serde::de::MapAccess<'de>,
636 {
637 let mut node__ = None;
638 let mut actors__ = None;
639 while let Some(k) = map_.next_key()? {
640 match k {
641 GeneratedField::Node => {
642 if node__.is_some() {
643 return Err(serde::de::Error::duplicate_field("node"));
644 }
645 node__ = map_.next_value()?;
646 }
647 GeneratedField::Actors => {
648 if actors__.is_some() {
649 return Err(serde::de::Error::duplicate_field("actors"));
650 }
651 actors__ = Some(map_.next_value()?);
652 }
653 }
654 }
655 Ok(ActorLocation {
656 node: node__,
657 actors: actors__.unwrap_or_default(),
658 })
659 }
660 }
661 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
662 }
663}
664impl serde::Serialize for AddEventLogRequest {
665 #[allow(deprecated)]
666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
667 where
668 S: serde::Serializer,
669 {
670 use serde::ser::SerializeStruct;
671 let mut len = 0;
672 if self.event.is_some() {
673 len += 1;
674 }
675 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
676 if let Some(v) = self.event.as_ref() {
677 match v {
678 add_event_log_request::Event::WorkerNodePanic(v) => {
679 struct_ser.serialize_field("workerNodePanic", v)?;
680 }
681 add_event_log_request::Event::SinkFail(v) => {
682 struct_ser.serialize_field("sinkFail", v)?;
683 }
684 add_event_log_request::Event::AutoSchemaChangeFail(v) => {
685 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
686 }
687 }
688 }
689 struct_ser.end()
690 }
691}
692impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
693 #[allow(deprecated)]
694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
695 where
696 D: serde::Deserializer<'de>,
697 {
698 const FIELDS: &[&str] = &[
699 "worker_node_panic",
700 "workerNodePanic",
701 "sink_fail",
702 "sinkFail",
703 "auto_schema_change_fail",
704 "autoSchemaChangeFail",
705 ];
706
707 #[allow(clippy::enum_variant_names)]
708 enum GeneratedField {
709 WorkerNodePanic,
710 SinkFail,
711 AutoSchemaChangeFail,
712 }
713 impl<'de> serde::Deserialize<'de> for GeneratedField {
714 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
715 where
716 D: serde::Deserializer<'de>,
717 {
718 struct GeneratedVisitor;
719
720 impl serde::de::Visitor<'_> for GeneratedVisitor {
721 type Value = GeneratedField;
722
723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
724 write!(formatter, "expected one of: {:?}", &FIELDS)
725 }
726
727 #[allow(unused_variables)]
728 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
729 where
730 E: serde::de::Error,
731 {
732 match value {
733 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
734 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
735 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
737 }
738 }
739 }
740 deserializer.deserialize_identifier(GeneratedVisitor)
741 }
742 }
743 struct GeneratedVisitor;
744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
745 type Value = AddEventLogRequest;
746
747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
748 formatter.write_str("struct meta.AddEventLogRequest")
749 }
750
751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
752 where
753 V: serde::de::MapAccess<'de>,
754 {
755 let mut event__ = None;
756 while let Some(k) = map_.next_key()? {
757 match k {
758 GeneratedField::WorkerNodePanic => {
759 if event__.is_some() {
760 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
761 }
762 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
763;
764 }
765 GeneratedField::SinkFail => {
766 if event__.is_some() {
767 return Err(serde::de::Error::duplicate_field("sinkFail"));
768 }
769 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
770;
771 }
772 GeneratedField::AutoSchemaChangeFail => {
773 if event__.is_some() {
774 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
775 }
776 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
777;
778 }
779 }
780 }
781 Ok(AddEventLogRequest {
782 event: event__,
783 })
784 }
785 }
786 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
787 }
788}
789impl serde::Serialize for AddEventLogResponse {
790 #[allow(deprecated)]
791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
792 where
793 S: serde::Serializer,
794 {
795 use serde::ser::SerializeStruct;
796 let len = 0;
797 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
798 struct_ser.end()
799 }
800}
801impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
802 #[allow(deprecated)]
803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
804 where
805 D: serde::Deserializer<'de>,
806 {
807 const FIELDS: &[&str] = &[
808 ];
809
810 #[allow(clippy::enum_variant_names)]
811 enum GeneratedField {
812 }
813 impl<'de> serde::Deserialize<'de> for GeneratedField {
814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
815 where
816 D: serde::Deserializer<'de>,
817 {
818 struct GeneratedVisitor;
819
820 impl serde::de::Visitor<'_> for GeneratedVisitor {
821 type Value = GeneratedField;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 #[allow(unused_variables)]
828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
829 where
830 E: serde::de::Error,
831 {
832 Err(serde::de::Error::unknown_field(value, FIELDS))
833 }
834 }
835 deserializer.deserialize_identifier(GeneratedVisitor)
836 }
837 }
838 struct GeneratedVisitor;
839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
840 type Value = AddEventLogResponse;
841
842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
843 formatter.write_str("struct meta.AddEventLogResponse")
844 }
845
846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
847 where
848 V: serde::de::MapAccess<'de>,
849 {
850 while map_.next_key::<GeneratedField>()?.is_some() {
851 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
852 }
853 Ok(AddEventLogResponse {
854 })
855 }
856 }
857 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
858 }
859}
860impl serde::Serialize for AddWorkerNodeRequest {
861 #[allow(deprecated)]
862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
863 where
864 S: serde::Serializer,
865 {
866 use serde::ser::SerializeStruct;
867 let mut len = 0;
868 if self.worker_type != 0 {
869 len += 1;
870 }
871 if self.host.is_some() {
872 len += 1;
873 }
874 if self.resource.is_some() {
875 len += 1;
876 }
877 if self.property.is_some() {
878 len += 1;
879 }
880 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
881 if self.worker_type != 0 {
882 let v = super::common::WorkerType::try_from(self.worker_type)
883 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
884 struct_ser.serialize_field("workerType", &v)?;
885 }
886 if let Some(v) = self.host.as_ref() {
887 struct_ser.serialize_field("host", v)?;
888 }
889 if let Some(v) = self.resource.as_ref() {
890 struct_ser.serialize_field("resource", v)?;
891 }
892 if let Some(v) = self.property.as_ref() {
893 struct_ser.serialize_field("property", v)?;
894 }
895 struct_ser.end()
896 }
897}
898impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
899 #[allow(deprecated)]
900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
901 where
902 D: serde::Deserializer<'de>,
903 {
904 const FIELDS: &[&str] = &[
905 "worker_type",
906 "workerType",
907 "host",
908 "resource",
909 "property",
910 ];
911
912 #[allow(clippy::enum_variant_names)]
913 enum GeneratedField {
914 WorkerType,
915 Host,
916 Resource,
917 Property,
918 }
919 impl<'de> serde::Deserialize<'de> for GeneratedField {
920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
921 where
922 D: serde::Deserializer<'de>,
923 {
924 struct GeneratedVisitor;
925
926 impl serde::de::Visitor<'_> for GeneratedVisitor {
927 type Value = GeneratedField;
928
929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
930 write!(formatter, "expected one of: {:?}", &FIELDS)
931 }
932
933 #[allow(unused_variables)]
934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
935 where
936 E: serde::de::Error,
937 {
938 match value {
939 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
940 "host" => Ok(GeneratedField::Host),
941 "resource" => Ok(GeneratedField::Resource),
942 "property" => Ok(GeneratedField::Property),
943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
944 }
945 }
946 }
947 deserializer.deserialize_identifier(GeneratedVisitor)
948 }
949 }
950 struct GeneratedVisitor;
951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
952 type Value = AddWorkerNodeRequest;
953
954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
955 formatter.write_str("struct meta.AddWorkerNodeRequest")
956 }
957
958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
959 where
960 V: serde::de::MapAccess<'de>,
961 {
962 let mut worker_type__ = None;
963 let mut host__ = None;
964 let mut resource__ = None;
965 let mut property__ = None;
966 while let Some(k) = map_.next_key()? {
967 match k {
968 GeneratedField::WorkerType => {
969 if worker_type__.is_some() {
970 return Err(serde::de::Error::duplicate_field("workerType"));
971 }
972 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
973 }
974 GeneratedField::Host => {
975 if host__.is_some() {
976 return Err(serde::de::Error::duplicate_field("host"));
977 }
978 host__ = map_.next_value()?;
979 }
980 GeneratedField::Resource => {
981 if resource__.is_some() {
982 return Err(serde::de::Error::duplicate_field("resource"));
983 }
984 resource__ = map_.next_value()?;
985 }
986 GeneratedField::Property => {
987 if property__.is_some() {
988 return Err(serde::de::Error::duplicate_field("property"));
989 }
990 property__ = map_.next_value()?;
991 }
992 }
993 }
994 Ok(AddWorkerNodeRequest {
995 worker_type: worker_type__.unwrap_or_default(),
996 host: host__,
997 resource: resource__,
998 property: property__,
999 })
1000 }
1001 }
1002 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1003 }
1004}
1005impl serde::Serialize for AddWorkerNodeResponse {
1006 #[allow(deprecated)]
1007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1008 where
1009 S: serde::Serializer,
1010 {
1011 use serde::ser::SerializeStruct;
1012 let mut len = 0;
1013 if self.node_id.is_some() {
1014 len += 1;
1015 }
1016 if !self.cluster_id.is_empty() {
1017 len += 1;
1018 }
1019 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1020 if let Some(v) = self.node_id.as_ref() {
1021 struct_ser.serialize_field("nodeId", v)?;
1022 }
1023 if !self.cluster_id.is_empty() {
1024 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1025 }
1026 struct_ser.end()
1027 }
1028}
1029impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1030 #[allow(deprecated)]
1031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1032 where
1033 D: serde::Deserializer<'de>,
1034 {
1035 const FIELDS: &[&str] = &[
1036 "node_id",
1037 "nodeId",
1038 "cluster_id",
1039 "clusterId",
1040 ];
1041
1042 #[allow(clippy::enum_variant_names)]
1043 enum GeneratedField {
1044 NodeId,
1045 ClusterId,
1046 }
1047 impl<'de> serde::Deserialize<'de> for GeneratedField {
1048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1049 where
1050 D: serde::Deserializer<'de>,
1051 {
1052 struct GeneratedVisitor;
1053
1054 impl serde::de::Visitor<'_> for GeneratedVisitor {
1055 type Value = GeneratedField;
1056
1057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1058 write!(formatter, "expected one of: {:?}", &FIELDS)
1059 }
1060
1061 #[allow(unused_variables)]
1062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1063 where
1064 E: serde::de::Error,
1065 {
1066 match value {
1067 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1068 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1069 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1070 }
1071 }
1072 }
1073 deserializer.deserialize_identifier(GeneratedVisitor)
1074 }
1075 }
1076 struct GeneratedVisitor;
1077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1078 type Value = AddWorkerNodeResponse;
1079
1080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1081 formatter.write_str("struct meta.AddWorkerNodeResponse")
1082 }
1083
1084 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1085 where
1086 V: serde::de::MapAccess<'de>,
1087 {
1088 let mut node_id__ = None;
1089 let mut cluster_id__ = None;
1090 while let Some(k) = map_.next_key()? {
1091 match k {
1092 GeneratedField::NodeId => {
1093 if node_id__.is_some() {
1094 return Err(serde::de::Error::duplicate_field("nodeId"));
1095 }
1096 node_id__ =
1097 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1098 ;
1099 }
1100 GeneratedField::ClusterId => {
1101 if cluster_id__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("clusterId"));
1103 }
1104 cluster_id__ = Some(map_.next_value()?);
1105 }
1106 }
1107 }
1108 Ok(AddWorkerNodeResponse {
1109 node_id: node_id__,
1110 cluster_id: cluster_id__.unwrap_or_default(),
1111 })
1112 }
1113 }
1114 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1115 }
1116}
1117impl serde::Serialize for AlterConnectorPropsRequest {
1118 #[allow(deprecated)]
1119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1120 where
1121 S: serde::Serializer,
1122 {
1123 use serde::ser::SerializeStruct;
1124 let mut len = 0;
1125 if self.object_id != 0 {
1126 len += 1;
1127 }
1128 if !self.changed_props.is_empty() {
1129 len += 1;
1130 }
1131 if !self.changed_secret_refs.is_empty() {
1132 len += 1;
1133 }
1134 if self.connector_conn_ref.is_some() {
1135 len += 1;
1136 }
1137 if self.object_type != 0 {
1138 len += 1;
1139 }
1140 if self.extra_options.is_some() {
1141 len += 1;
1142 }
1143 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1144 if self.object_id != 0 {
1145 struct_ser.serialize_field("objectId", &self.object_id)?;
1146 }
1147 if !self.changed_props.is_empty() {
1148 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1149 }
1150 if !self.changed_secret_refs.is_empty() {
1151 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1152 }
1153 if let Some(v) = self.connector_conn_ref.as_ref() {
1154 struct_ser.serialize_field("connectorConnRef", v)?;
1155 }
1156 if self.object_type != 0 {
1157 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1158 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1159 struct_ser.serialize_field("objectType", &v)?;
1160 }
1161 if let Some(v) = self.extra_options.as_ref() {
1162 match v {
1163 alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1164 struct_ser.serialize_field("alterIcebergTableIds", v)?;
1165 }
1166 }
1167 }
1168 struct_ser.end()
1169 }
1170}
1171impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1172 #[allow(deprecated)]
1173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1174 where
1175 D: serde::Deserializer<'de>,
1176 {
1177 const FIELDS: &[&str] = &[
1178 "object_id",
1179 "objectId",
1180 "changed_props",
1181 "changedProps",
1182 "changed_secret_refs",
1183 "changedSecretRefs",
1184 "connector_conn_ref",
1185 "connectorConnRef",
1186 "object_type",
1187 "objectType",
1188 "alter_iceberg_table_ids",
1189 "alterIcebergTableIds",
1190 ];
1191
1192 #[allow(clippy::enum_variant_names)]
1193 enum GeneratedField {
1194 ObjectId,
1195 ChangedProps,
1196 ChangedSecretRefs,
1197 ConnectorConnRef,
1198 ObjectType,
1199 AlterIcebergTableIds,
1200 }
1201 impl<'de> serde::Deserialize<'de> for GeneratedField {
1202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1203 where
1204 D: serde::Deserializer<'de>,
1205 {
1206 struct GeneratedVisitor;
1207
1208 impl serde::de::Visitor<'_> for GeneratedVisitor {
1209 type Value = GeneratedField;
1210
1211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1212 write!(formatter, "expected one of: {:?}", &FIELDS)
1213 }
1214
1215 #[allow(unused_variables)]
1216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1217 where
1218 E: serde::de::Error,
1219 {
1220 match value {
1221 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1222 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1223 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1224 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1225 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1226 "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1228 }
1229 }
1230 }
1231 deserializer.deserialize_identifier(GeneratedVisitor)
1232 }
1233 }
1234 struct GeneratedVisitor;
1235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1236 type Value = AlterConnectorPropsRequest;
1237
1238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1239 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1240 }
1241
1242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1243 where
1244 V: serde::de::MapAccess<'de>,
1245 {
1246 let mut object_id__ = None;
1247 let mut changed_props__ = None;
1248 let mut changed_secret_refs__ = None;
1249 let mut connector_conn_ref__ = None;
1250 let mut object_type__ = None;
1251 let mut extra_options__ = None;
1252 while let Some(k) = map_.next_key()? {
1253 match k {
1254 GeneratedField::ObjectId => {
1255 if object_id__.is_some() {
1256 return Err(serde::de::Error::duplicate_field("objectId"));
1257 }
1258 object_id__ =
1259 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1260 ;
1261 }
1262 GeneratedField::ChangedProps => {
1263 if changed_props__.is_some() {
1264 return Err(serde::de::Error::duplicate_field("changedProps"));
1265 }
1266 changed_props__ = Some(
1267 map_.next_value::<std::collections::HashMap<_, _>>()?
1268 );
1269 }
1270 GeneratedField::ChangedSecretRefs => {
1271 if changed_secret_refs__.is_some() {
1272 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1273 }
1274 changed_secret_refs__ = Some(
1275 map_.next_value::<std::collections::HashMap<_, _>>()?
1276 );
1277 }
1278 GeneratedField::ConnectorConnRef => {
1279 if connector_conn_ref__.is_some() {
1280 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1281 }
1282 connector_conn_ref__ =
1283 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1284 ;
1285 }
1286 GeneratedField::ObjectType => {
1287 if object_type__.is_some() {
1288 return Err(serde::de::Error::duplicate_field("objectType"));
1289 }
1290 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1291 }
1292 GeneratedField::AlterIcebergTableIds => {
1293 if extra_options__.is_some() {
1294 return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1295 }
1296 extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1297;
1298 }
1299 }
1300 }
1301 Ok(AlterConnectorPropsRequest {
1302 object_id: object_id__.unwrap_or_default(),
1303 changed_props: changed_props__.unwrap_or_default(),
1304 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1305 connector_conn_ref: connector_conn_ref__,
1306 object_type: object_type__.unwrap_or_default(),
1307 extra_options: extra_options__,
1308 })
1309 }
1310 }
1311 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1312 }
1313}
1314impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1315 #[allow(deprecated)]
1316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1317 where
1318 S: serde::Serializer,
1319 {
1320 let variant = match self {
1321 Self::Unspecified => "UNSPECIFIED",
1322 Self::Source => "SOURCE",
1323 Self::Sink => "SINK",
1324 Self::Connection => "CONNECTION",
1325 Self::IcebergTable => "ICEBERG_TABLE",
1326 };
1327 serializer.serialize_str(variant)
1328 }
1329}
1330impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1331 #[allow(deprecated)]
1332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1333 where
1334 D: serde::Deserializer<'de>,
1335 {
1336 const FIELDS: &[&str] = &[
1337 "UNSPECIFIED",
1338 "SOURCE",
1339 "SINK",
1340 "CONNECTION",
1341 "ICEBERG_TABLE",
1342 ];
1343
1344 struct GeneratedVisitor;
1345
1346 impl serde::de::Visitor<'_> for GeneratedVisitor {
1347 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1348
1349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1350 write!(formatter, "expected one of: {:?}", &FIELDS)
1351 }
1352
1353 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1354 where
1355 E: serde::de::Error,
1356 {
1357 i32::try_from(v)
1358 .ok()
1359 .and_then(|x| x.try_into().ok())
1360 .ok_or_else(|| {
1361 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1362 })
1363 }
1364
1365 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1366 where
1367 E: serde::de::Error,
1368 {
1369 i32::try_from(v)
1370 .ok()
1371 .and_then(|x| x.try_into().ok())
1372 .ok_or_else(|| {
1373 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1374 })
1375 }
1376
1377 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1378 where
1379 E: serde::de::Error,
1380 {
1381 match value {
1382 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1383 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1384 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1385 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1386 "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1387 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1388 }
1389 }
1390 }
1391 deserializer.deserialize_any(GeneratedVisitor)
1392 }
1393}
1394impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1395 #[allow(deprecated)]
1396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1397 where
1398 S: serde::Serializer,
1399 {
1400 use serde::ser::SerializeStruct;
1401 let mut len = 0;
1402 if self.source_id != 0 {
1403 len += 1;
1404 }
1405 if self.sink_id != 0 {
1406 len += 1;
1407 }
1408 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1409 if self.source_id != 0 {
1410 struct_ser.serialize_field("sourceId", &self.source_id)?;
1411 }
1412 if self.sink_id != 0 {
1413 struct_ser.serialize_field("sinkId", &self.sink_id)?;
1414 }
1415 struct_ser.end()
1416 }
1417}
1418impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1419 #[allow(deprecated)]
1420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1421 where
1422 D: serde::Deserializer<'de>,
1423 {
1424 const FIELDS: &[&str] = &[
1425 "source_id",
1426 "sourceId",
1427 "sink_id",
1428 "sinkId",
1429 ];
1430
1431 #[allow(clippy::enum_variant_names)]
1432 enum GeneratedField {
1433 SourceId,
1434 SinkId,
1435 }
1436 impl<'de> serde::Deserialize<'de> for GeneratedField {
1437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1438 where
1439 D: serde::Deserializer<'de>,
1440 {
1441 struct GeneratedVisitor;
1442
1443 impl serde::de::Visitor<'_> for GeneratedVisitor {
1444 type Value = GeneratedField;
1445
1446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1447 write!(formatter, "expected one of: {:?}", &FIELDS)
1448 }
1449
1450 #[allow(unused_variables)]
1451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1452 where
1453 E: serde::de::Error,
1454 {
1455 match value {
1456 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1457 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1459 }
1460 }
1461 }
1462 deserializer.deserialize_identifier(GeneratedVisitor)
1463 }
1464 }
1465 struct GeneratedVisitor;
1466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1467 type Value = alter_connector_props_request::AlterIcebergTableIds;
1468
1469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1470 formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1471 }
1472
1473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1474 where
1475 V: serde::de::MapAccess<'de>,
1476 {
1477 let mut source_id__ = None;
1478 let mut sink_id__ = None;
1479 while let Some(k) = map_.next_key()? {
1480 match k {
1481 GeneratedField::SourceId => {
1482 if source_id__.is_some() {
1483 return Err(serde::de::Error::duplicate_field("sourceId"));
1484 }
1485 source_id__ =
1486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1487 ;
1488 }
1489 GeneratedField::SinkId => {
1490 if sink_id__.is_some() {
1491 return Err(serde::de::Error::duplicate_field("sinkId"));
1492 }
1493 sink_id__ =
1494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1495 ;
1496 }
1497 }
1498 }
1499 Ok(alter_connector_props_request::AlterIcebergTableIds {
1500 source_id: source_id__.unwrap_or_default(),
1501 sink_id: sink_id__.unwrap_or_default(),
1502 })
1503 }
1504 }
1505 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1506 }
1507}
1508impl serde::Serialize for AlterConnectorPropsResponse {
1509 #[allow(deprecated)]
1510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1511 where
1512 S: serde::Serializer,
1513 {
1514 use serde::ser::SerializeStruct;
1515 let len = 0;
1516 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1517 struct_ser.end()
1518 }
1519}
1520impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1521 #[allow(deprecated)]
1522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1523 where
1524 D: serde::Deserializer<'de>,
1525 {
1526 const FIELDS: &[&str] = &[
1527 ];
1528
1529 #[allow(clippy::enum_variant_names)]
1530 enum GeneratedField {
1531 }
1532 impl<'de> serde::Deserialize<'de> for GeneratedField {
1533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1534 where
1535 D: serde::Deserializer<'de>,
1536 {
1537 struct GeneratedVisitor;
1538
1539 impl serde::de::Visitor<'_> for GeneratedVisitor {
1540 type Value = GeneratedField;
1541
1542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1543 write!(formatter, "expected one of: {:?}", &FIELDS)
1544 }
1545
1546 #[allow(unused_variables)]
1547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1548 where
1549 E: serde::de::Error,
1550 {
1551 Err(serde::de::Error::unknown_field(value, FIELDS))
1552 }
1553 }
1554 deserializer.deserialize_identifier(GeneratedVisitor)
1555 }
1556 }
1557 struct GeneratedVisitor;
1558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1559 type Value = AlterConnectorPropsResponse;
1560
1561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1562 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1563 }
1564
1565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1566 where
1567 V: serde::de::MapAccess<'de>,
1568 {
1569 while map_.next_key::<GeneratedField>()?.is_some() {
1570 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1571 }
1572 Ok(AlterConnectorPropsResponse {
1573 })
1574 }
1575 }
1576 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1577 }
1578}
1579impl serde::Serialize for AlterSourcePropertiesSafeRequest {
1580 #[allow(deprecated)]
1581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1582 where
1583 S: serde::Serializer,
1584 {
1585 use serde::ser::SerializeStruct;
1586 let mut len = 0;
1587 if self.source_id != 0 {
1588 len += 1;
1589 }
1590 if !self.changed_props.is_empty() {
1591 len += 1;
1592 }
1593 if !self.changed_secret_refs.is_empty() {
1594 len += 1;
1595 }
1596 if self.options.is_some() {
1597 len += 1;
1598 }
1599 let mut struct_ser = serializer.serialize_struct("meta.AlterSourcePropertiesSafeRequest", len)?;
1600 if self.source_id != 0 {
1601 struct_ser.serialize_field("sourceId", &self.source_id)?;
1602 }
1603 if !self.changed_props.is_empty() {
1604 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1605 }
1606 if !self.changed_secret_refs.is_empty() {
1607 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1608 }
1609 if let Some(v) = self.options.as_ref() {
1610 struct_ser.serialize_field("options", v)?;
1611 }
1612 struct_ser.end()
1613 }
1614}
1615impl<'de> serde::Deserialize<'de> for AlterSourcePropertiesSafeRequest {
1616 #[allow(deprecated)]
1617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1618 where
1619 D: serde::Deserializer<'de>,
1620 {
1621 const FIELDS: &[&str] = &[
1622 "source_id",
1623 "sourceId",
1624 "changed_props",
1625 "changedProps",
1626 "changed_secret_refs",
1627 "changedSecretRefs",
1628 "options",
1629 ];
1630
1631 #[allow(clippy::enum_variant_names)]
1632 enum GeneratedField {
1633 SourceId,
1634 ChangedProps,
1635 ChangedSecretRefs,
1636 Options,
1637 }
1638 impl<'de> serde::Deserialize<'de> for GeneratedField {
1639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1640 where
1641 D: serde::Deserializer<'de>,
1642 {
1643 struct GeneratedVisitor;
1644
1645 impl serde::de::Visitor<'_> for GeneratedVisitor {
1646 type Value = GeneratedField;
1647
1648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1649 write!(formatter, "expected one of: {:?}", &FIELDS)
1650 }
1651
1652 #[allow(unused_variables)]
1653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1654 where
1655 E: serde::de::Error,
1656 {
1657 match value {
1658 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1659 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1660 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1661 "options" => Ok(GeneratedField::Options),
1662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1663 }
1664 }
1665 }
1666 deserializer.deserialize_identifier(GeneratedVisitor)
1667 }
1668 }
1669 struct GeneratedVisitor;
1670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1671 type Value = AlterSourcePropertiesSafeRequest;
1672
1673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1674 formatter.write_str("struct meta.AlterSourcePropertiesSafeRequest")
1675 }
1676
1677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourcePropertiesSafeRequest, V::Error>
1678 where
1679 V: serde::de::MapAccess<'de>,
1680 {
1681 let mut source_id__ = None;
1682 let mut changed_props__ = None;
1683 let mut changed_secret_refs__ = None;
1684 let mut options__ = None;
1685 while let Some(k) = map_.next_key()? {
1686 match k {
1687 GeneratedField::SourceId => {
1688 if source_id__.is_some() {
1689 return Err(serde::de::Error::duplicate_field("sourceId"));
1690 }
1691 source_id__ =
1692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1693 ;
1694 }
1695 GeneratedField::ChangedProps => {
1696 if changed_props__.is_some() {
1697 return Err(serde::de::Error::duplicate_field("changedProps"));
1698 }
1699 changed_props__ = Some(
1700 map_.next_value::<std::collections::HashMap<_, _>>()?
1701 );
1702 }
1703 GeneratedField::ChangedSecretRefs => {
1704 if changed_secret_refs__.is_some() {
1705 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1706 }
1707 changed_secret_refs__ = Some(
1708 map_.next_value::<std::collections::HashMap<_, _>>()?
1709 );
1710 }
1711 GeneratedField::Options => {
1712 if options__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("options"));
1714 }
1715 options__ = map_.next_value()?;
1716 }
1717 }
1718 }
1719 Ok(AlterSourcePropertiesSafeRequest {
1720 source_id: source_id__.unwrap_or_default(),
1721 changed_props: changed_props__.unwrap_or_default(),
1722 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1723 options: options__,
1724 })
1725 }
1726 }
1727 deserializer.deserialize_struct("meta.AlterSourcePropertiesSafeRequest", FIELDS, GeneratedVisitor)
1728 }
1729}
1730impl serde::Serialize for AlterSourcePropertiesSafeResponse {
1731 #[allow(deprecated)]
1732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1733 where
1734 S: serde::Serializer,
1735 {
1736 use serde::ser::SerializeStruct;
1737 let len = 0;
1738 let struct_ser = serializer.serialize_struct("meta.AlterSourcePropertiesSafeResponse", len)?;
1739 struct_ser.end()
1740 }
1741}
1742impl<'de> serde::Deserialize<'de> for AlterSourcePropertiesSafeResponse {
1743 #[allow(deprecated)]
1744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1745 where
1746 D: serde::Deserializer<'de>,
1747 {
1748 const FIELDS: &[&str] = &[
1749 ];
1750
1751 #[allow(clippy::enum_variant_names)]
1752 enum GeneratedField {
1753 }
1754 impl<'de> serde::Deserialize<'de> for GeneratedField {
1755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1756 where
1757 D: serde::Deserializer<'de>,
1758 {
1759 struct GeneratedVisitor;
1760
1761 impl serde::de::Visitor<'_> for GeneratedVisitor {
1762 type Value = GeneratedField;
1763
1764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1765 write!(formatter, "expected one of: {:?}", &FIELDS)
1766 }
1767
1768 #[allow(unused_variables)]
1769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1770 where
1771 E: serde::de::Error,
1772 {
1773 Err(serde::de::Error::unknown_field(value, FIELDS))
1774 }
1775 }
1776 deserializer.deserialize_identifier(GeneratedVisitor)
1777 }
1778 }
1779 struct GeneratedVisitor;
1780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1781 type Value = AlterSourcePropertiesSafeResponse;
1782
1783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1784 formatter.write_str("struct meta.AlterSourcePropertiesSafeResponse")
1785 }
1786
1787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourcePropertiesSafeResponse, V::Error>
1788 where
1789 V: serde::de::MapAccess<'de>,
1790 {
1791 while map_.next_key::<GeneratedField>()?.is_some() {
1792 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1793 }
1794 Ok(AlterSourcePropertiesSafeResponse {
1795 })
1796 }
1797 }
1798 deserializer.deserialize_struct("meta.AlterSourcePropertiesSafeResponse", FIELDS, GeneratedVisitor)
1799 }
1800}
1801impl serde::Serialize for ApplyThrottleRequest {
1802 #[allow(deprecated)]
1803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1804 where
1805 S: serde::Serializer,
1806 {
1807 use serde::ser::SerializeStruct;
1808 let mut len = 0;
1809 if self.throttle_target != 0 {
1810 len += 1;
1811 }
1812 if self.throttle_type != 0 {
1813 len += 1;
1814 }
1815 if self.id != 0 {
1816 len += 1;
1817 }
1818 if self.rate.is_some() {
1819 len += 1;
1820 }
1821 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1822 if self.throttle_target != 0 {
1823 let v = ThrottleTarget::try_from(self.throttle_target)
1824 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_target)))?;
1825 struct_ser.serialize_field("throttleTarget", &v)?;
1826 }
1827 if self.throttle_type != 0 {
1828 let v = super::common::ThrottleType::try_from(self.throttle_type)
1829 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
1830 struct_ser.serialize_field("throttleType", &v)?;
1831 }
1832 if self.id != 0 {
1833 struct_ser.serialize_field("id", &self.id)?;
1834 }
1835 if let Some(v) = self.rate.as_ref() {
1836 struct_ser.serialize_field("rate", v)?;
1837 }
1838 struct_ser.end()
1839 }
1840}
1841impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1842 #[allow(deprecated)]
1843 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1844 where
1845 D: serde::Deserializer<'de>,
1846 {
1847 const FIELDS: &[&str] = &[
1848 "throttle_target",
1849 "throttleTarget",
1850 "throttle_type",
1851 "throttleType",
1852 "id",
1853 "rate",
1854 ];
1855
1856 #[allow(clippy::enum_variant_names)]
1857 enum GeneratedField {
1858 ThrottleTarget,
1859 ThrottleType,
1860 Id,
1861 Rate,
1862 }
1863 impl<'de> serde::Deserialize<'de> for GeneratedField {
1864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1865 where
1866 D: serde::Deserializer<'de>,
1867 {
1868 struct GeneratedVisitor;
1869
1870 impl serde::de::Visitor<'_> for GeneratedVisitor {
1871 type Value = GeneratedField;
1872
1873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1874 write!(formatter, "expected one of: {:?}", &FIELDS)
1875 }
1876
1877 #[allow(unused_variables)]
1878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1879 where
1880 E: serde::de::Error,
1881 {
1882 match value {
1883 "throttleTarget" | "throttle_target" => Ok(GeneratedField::ThrottleTarget),
1884 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
1885 "id" => Ok(GeneratedField::Id),
1886 "rate" => Ok(GeneratedField::Rate),
1887 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1888 }
1889 }
1890 }
1891 deserializer.deserialize_identifier(GeneratedVisitor)
1892 }
1893 }
1894 struct GeneratedVisitor;
1895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1896 type Value = ApplyThrottleRequest;
1897
1898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1899 formatter.write_str("struct meta.ApplyThrottleRequest")
1900 }
1901
1902 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1903 where
1904 V: serde::de::MapAccess<'de>,
1905 {
1906 let mut throttle_target__ = None;
1907 let mut throttle_type__ = None;
1908 let mut id__ = None;
1909 let mut rate__ = None;
1910 while let Some(k) = map_.next_key()? {
1911 match k {
1912 GeneratedField::ThrottleTarget => {
1913 if throttle_target__.is_some() {
1914 return Err(serde::de::Error::duplicate_field("throttleTarget"));
1915 }
1916 throttle_target__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1917 }
1918 GeneratedField::ThrottleType => {
1919 if throttle_type__.is_some() {
1920 return Err(serde::de::Error::duplicate_field("throttleType"));
1921 }
1922 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
1923 }
1924 GeneratedField::Id => {
1925 if id__.is_some() {
1926 return Err(serde::de::Error::duplicate_field("id"));
1927 }
1928 id__ =
1929 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1930 ;
1931 }
1932 GeneratedField::Rate => {
1933 if rate__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("rate"));
1935 }
1936 rate__ =
1937 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1938 ;
1939 }
1940 }
1941 }
1942 Ok(ApplyThrottleRequest {
1943 throttle_target: throttle_target__.unwrap_or_default(),
1944 throttle_type: throttle_type__.unwrap_or_default(),
1945 id: id__.unwrap_or_default(),
1946 rate: rate__,
1947 })
1948 }
1949 }
1950 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1951 }
1952}
1953impl serde::Serialize for ApplyThrottleResponse {
1954 #[allow(deprecated)]
1955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1956 where
1957 S: serde::Serializer,
1958 {
1959 use serde::ser::SerializeStruct;
1960 let mut len = 0;
1961 if self.status.is_some() {
1962 len += 1;
1963 }
1964 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1965 if let Some(v) = self.status.as_ref() {
1966 struct_ser.serialize_field("status", v)?;
1967 }
1968 struct_ser.end()
1969 }
1970}
1971impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1972 #[allow(deprecated)]
1973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1974 where
1975 D: serde::Deserializer<'de>,
1976 {
1977 const FIELDS: &[&str] = &[
1978 "status",
1979 ];
1980
1981 #[allow(clippy::enum_variant_names)]
1982 enum GeneratedField {
1983 Status,
1984 }
1985 impl<'de> serde::Deserialize<'de> for GeneratedField {
1986 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1987 where
1988 D: serde::Deserializer<'de>,
1989 {
1990 struct GeneratedVisitor;
1991
1992 impl serde::de::Visitor<'_> for GeneratedVisitor {
1993 type Value = GeneratedField;
1994
1995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1996 write!(formatter, "expected one of: {:?}", &FIELDS)
1997 }
1998
1999 #[allow(unused_variables)]
2000 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2001 where
2002 E: serde::de::Error,
2003 {
2004 match value {
2005 "status" => Ok(GeneratedField::Status),
2006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2007 }
2008 }
2009 }
2010 deserializer.deserialize_identifier(GeneratedVisitor)
2011 }
2012 }
2013 struct GeneratedVisitor;
2014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2015 type Value = ApplyThrottleResponse;
2016
2017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2018 formatter.write_str("struct meta.ApplyThrottleResponse")
2019 }
2020
2021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
2022 where
2023 V: serde::de::MapAccess<'de>,
2024 {
2025 let mut status__ = None;
2026 while let Some(k) = map_.next_key()? {
2027 match k {
2028 GeneratedField::Status => {
2029 if status__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("status"));
2031 }
2032 status__ = map_.next_value()?;
2033 }
2034 }
2035 }
2036 Ok(ApplyThrottleResponse {
2037 status: status__,
2038 })
2039 }
2040 }
2041 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
2042 }
2043}
2044impl serde::Serialize for CancelCreatingJobsRequest {
2045 #[allow(deprecated)]
2046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2047 where
2048 S: serde::Serializer,
2049 {
2050 use serde::ser::SerializeStruct;
2051 let mut len = 0;
2052 if self.jobs.is_some() {
2053 len += 1;
2054 }
2055 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
2056 if let Some(v) = self.jobs.as_ref() {
2057 match v {
2058 cancel_creating_jobs_request::Jobs::Infos(v) => {
2059 struct_ser.serialize_field("infos", v)?;
2060 }
2061 cancel_creating_jobs_request::Jobs::Ids(v) => {
2062 struct_ser.serialize_field("ids", v)?;
2063 }
2064 }
2065 }
2066 struct_ser.end()
2067 }
2068}
2069impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
2070 #[allow(deprecated)]
2071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2072 where
2073 D: serde::Deserializer<'de>,
2074 {
2075 const FIELDS: &[&str] = &[
2076 "infos",
2077 "ids",
2078 ];
2079
2080 #[allow(clippy::enum_variant_names)]
2081 enum GeneratedField {
2082 Infos,
2083 Ids,
2084 }
2085 impl<'de> serde::Deserialize<'de> for GeneratedField {
2086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2087 where
2088 D: serde::Deserializer<'de>,
2089 {
2090 struct GeneratedVisitor;
2091
2092 impl serde::de::Visitor<'_> for GeneratedVisitor {
2093 type Value = GeneratedField;
2094
2095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2096 write!(formatter, "expected one of: {:?}", &FIELDS)
2097 }
2098
2099 #[allow(unused_variables)]
2100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2101 where
2102 E: serde::de::Error,
2103 {
2104 match value {
2105 "infos" => Ok(GeneratedField::Infos),
2106 "ids" => Ok(GeneratedField::Ids),
2107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2108 }
2109 }
2110 }
2111 deserializer.deserialize_identifier(GeneratedVisitor)
2112 }
2113 }
2114 struct GeneratedVisitor;
2115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2116 type Value = CancelCreatingJobsRequest;
2117
2118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2119 formatter.write_str("struct meta.CancelCreatingJobsRequest")
2120 }
2121
2122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
2123 where
2124 V: serde::de::MapAccess<'de>,
2125 {
2126 let mut jobs__ = None;
2127 while let Some(k) = map_.next_key()? {
2128 match k {
2129 GeneratedField::Infos => {
2130 if jobs__.is_some() {
2131 return Err(serde::de::Error::duplicate_field("infos"));
2132 }
2133 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
2134;
2135 }
2136 GeneratedField::Ids => {
2137 if jobs__.is_some() {
2138 return Err(serde::de::Error::duplicate_field("ids"));
2139 }
2140 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
2141;
2142 }
2143 }
2144 }
2145 Ok(CancelCreatingJobsRequest {
2146 jobs: jobs__,
2147 })
2148 }
2149 }
2150 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
2151 }
2152}
2153impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
2154 #[allow(deprecated)]
2155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2156 where
2157 S: serde::Serializer,
2158 {
2159 use serde::ser::SerializeStruct;
2160 let mut len = 0;
2161 if !self.job_ids.is_empty() {
2162 len += 1;
2163 }
2164 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
2165 if !self.job_ids.is_empty() {
2166 struct_ser.serialize_field("jobIds", &self.job_ids)?;
2167 }
2168 struct_ser.end()
2169 }
2170}
2171impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
2172 #[allow(deprecated)]
2173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2174 where
2175 D: serde::Deserializer<'de>,
2176 {
2177 const FIELDS: &[&str] = &[
2178 "job_ids",
2179 "jobIds",
2180 ];
2181
2182 #[allow(clippy::enum_variant_names)]
2183 enum GeneratedField {
2184 JobIds,
2185 }
2186 impl<'de> serde::Deserialize<'de> for GeneratedField {
2187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2188 where
2189 D: serde::Deserializer<'de>,
2190 {
2191 struct GeneratedVisitor;
2192
2193 impl serde::de::Visitor<'_> for GeneratedVisitor {
2194 type Value = GeneratedField;
2195
2196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2197 write!(formatter, "expected one of: {:?}", &FIELDS)
2198 }
2199
2200 #[allow(unused_variables)]
2201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2202 where
2203 E: serde::de::Error,
2204 {
2205 match value {
2206 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
2207 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2208 }
2209 }
2210 }
2211 deserializer.deserialize_identifier(GeneratedVisitor)
2212 }
2213 }
2214 struct GeneratedVisitor;
2215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2216 type Value = cancel_creating_jobs_request::CreatingJobIds;
2217
2218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2219 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
2220 }
2221
2222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
2223 where
2224 V: serde::de::MapAccess<'de>,
2225 {
2226 let mut job_ids__ = None;
2227 while let Some(k) = map_.next_key()? {
2228 match k {
2229 GeneratedField::JobIds => {
2230 if job_ids__.is_some() {
2231 return Err(serde::de::Error::duplicate_field("jobIds"));
2232 }
2233 job_ids__ =
2234 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2235 .into_iter().map(|x| x.0).collect())
2236 ;
2237 }
2238 }
2239 }
2240 Ok(cancel_creating_jobs_request::CreatingJobIds {
2241 job_ids: job_ids__.unwrap_or_default(),
2242 })
2243 }
2244 }
2245 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2246 }
2247}
2248impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2249 #[allow(deprecated)]
2250 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2251 where
2252 S: serde::Serializer,
2253 {
2254 use serde::ser::SerializeStruct;
2255 let mut len = 0;
2256 if self.database_id != 0 {
2257 len += 1;
2258 }
2259 if self.schema_id != 0 {
2260 len += 1;
2261 }
2262 if !self.name.is_empty() {
2263 len += 1;
2264 }
2265 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2266 if self.database_id != 0 {
2267 struct_ser.serialize_field("databaseId", &self.database_id)?;
2268 }
2269 if self.schema_id != 0 {
2270 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2271 }
2272 if !self.name.is_empty() {
2273 struct_ser.serialize_field("name", &self.name)?;
2274 }
2275 struct_ser.end()
2276 }
2277}
2278impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2279 #[allow(deprecated)]
2280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2281 where
2282 D: serde::Deserializer<'de>,
2283 {
2284 const FIELDS: &[&str] = &[
2285 "database_id",
2286 "databaseId",
2287 "schema_id",
2288 "schemaId",
2289 "name",
2290 ];
2291
2292 #[allow(clippy::enum_variant_names)]
2293 enum GeneratedField {
2294 DatabaseId,
2295 SchemaId,
2296 Name,
2297 }
2298 impl<'de> serde::Deserialize<'de> for GeneratedField {
2299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2300 where
2301 D: serde::Deserializer<'de>,
2302 {
2303 struct GeneratedVisitor;
2304
2305 impl serde::de::Visitor<'_> for GeneratedVisitor {
2306 type Value = GeneratedField;
2307
2308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2309 write!(formatter, "expected one of: {:?}", &FIELDS)
2310 }
2311
2312 #[allow(unused_variables)]
2313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2314 where
2315 E: serde::de::Error,
2316 {
2317 match value {
2318 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2319 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2320 "name" => Ok(GeneratedField::Name),
2321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2322 }
2323 }
2324 }
2325 deserializer.deserialize_identifier(GeneratedVisitor)
2326 }
2327 }
2328 struct GeneratedVisitor;
2329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2330 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2331
2332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2333 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2334 }
2335
2336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2337 where
2338 V: serde::de::MapAccess<'de>,
2339 {
2340 let mut database_id__ = None;
2341 let mut schema_id__ = None;
2342 let mut name__ = None;
2343 while let Some(k) = map_.next_key()? {
2344 match k {
2345 GeneratedField::DatabaseId => {
2346 if database_id__.is_some() {
2347 return Err(serde::de::Error::duplicate_field("databaseId"));
2348 }
2349 database_id__ =
2350 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2351 ;
2352 }
2353 GeneratedField::SchemaId => {
2354 if schema_id__.is_some() {
2355 return Err(serde::de::Error::duplicate_field("schemaId"));
2356 }
2357 schema_id__ =
2358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2359 ;
2360 }
2361 GeneratedField::Name => {
2362 if name__.is_some() {
2363 return Err(serde::de::Error::duplicate_field("name"));
2364 }
2365 name__ = Some(map_.next_value()?);
2366 }
2367 }
2368 }
2369 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2370 database_id: database_id__.unwrap_or_default(),
2371 schema_id: schema_id__.unwrap_or_default(),
2372 name: name__.unwrap_or_default(),
2373 })
2374 }
2375 }
2376 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2377 }
2378}
2379impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2380 #[allow(deprecated)]
2381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2382 where
2383 S: serde::Serializer,
2384 {
2385 use serde::ser::SerializeStruct;
2386 let mut len = 0;
2387 if !self.infos.is_empty() {
2388 len += 1;
2389 }
2390 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2391 if !self.infos.is_empty() {
2392 struct_ser.serialize_field("infos", &self.infos)?;
2393 }
2394 struct_ser.end()
2395 }
2396}
2397impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2398 #[allow(deprecated)]
2399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2400 where
2401 D: serde::Deserializer<'de>,
2402 {
2403 const FIELDS: &[&str] = &[
2404 "infos",
2405 ];
2406
2407 #[allow(clippy::enum_variant_names)]
2408 enum GeneratedField {
2409 Infos,
2410 }
2411 impl<'de> serde::Deserialize<'de> for GeneratedField {
2412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2413 where
2414 D: serde::Deserializer<'de>,
2415 {
2416 struct GeneratedVisitor;
2417
2418 impl serde::de::Visitor<'_> for GeneratedVisitor {
2419 type Value = GeneratedField;
2420
2421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2422 write!(formatter, "expected one of: {:?}", &FIELDS)
2423 }
2424
2425 #[allow(unused_variables)]
2426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2427 where
2428 E: serde::de::Error,
2429 {
2430 match value {
2431 "infos" => Ok(GeneratedField::Infos),
2432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2433 }
2434 }
2435 }
2436 deserializer.deserialize_identifier(GeneratedVisitor)
2437 }
2438 }
2439 struct GeneratedVisitor;
2440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2441 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2442
2443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2444 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2445 }
2446
2447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2448 where
2449 V: serde::de::MapAccess<'de>,
2450 {
2451 let mut infos__ = None;
2452 while let Some(k) = map_.next_key()? {
2453 match k {
2454 GeneratedField::Infos => {
2455 if infos__.is_some() {
2456 return Err(serde::de::Error::duplicate_field("infos"));
2457 }
2458 infos__ = Some(map_.next_value()?);
2459 }
2460 }
2461 }
2462 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2463 infos: infos__.unwrap_or_default(),
2464 })
2465 }
2466 }
2467 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2468 }
2469}
2470impl serde::Serialize for CancelCreatingJobsResponse {
2471 #[allow(deprecated)]
2472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2473 where
2474 S: serde::Serializer,
2475 {
2476 use serde::ser::SerializeStruct;
2477 let mut len = 0;
2478 if self.status.is_some() {
2479 len += 1;
2480 }
2481 if !self.canceled_jobs.is_empty() {
2482 len += 1;
2483 }
2484 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2485 if let Some(v) = self.status.as_ref() {
2486 struct_ser.serialize_field("status", v)?;
2487 }
2488 if !self.canceled_jobs.is_empty() {
2489 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2490 }
2491 struct_ser.end()
2492 }
2493}
2494impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2495 #[allow(deprecated)]
2496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2497 where
2498 D: serde::Deserializer<'de>,
2499 {
2500 const FIELDS: &[&str] = &[
2501 "status",
2502 "canceled_jobs",
2503 "canceledJobs",
2504 ];
2505
2506 #[allow(clippy::enum_variant_names)]
2507 enum GeneratedField {
2508 Status,
2509 CanceledJobs,
2510 }
2511 impl<'de> serde::Deserialize<'de> for GeneratedField {
2512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2513 where
2514 D: serde::Deserializer<'de>,
2515 {
2516 struct GeneratedVisitor;
2517
2518 impl serde::de::Visitor<'_> for GeneratedVisitor {
2519 type Value = GeneratedField;
2520
2521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2522 write!(formatter, "expected one of: {:?}", &FIELDS)
2523 }
2524
2525 #[allow(unused_variables)]
2526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2527 where
2528 E: serde::de::Error,
2529 {
2530 match value {
2531 "status" => Ok(GeneratedField::Status),
2532 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2534 }
2535 }
2536 }
2537 deserializer.deserialize_identifier(GeneratedVisitor)
2538 }
2539 }
2540 struct GeneratedVisitor;
2541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2542 type Value = CancelCreatingJobsResponse;
2543
2544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2545 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2546 }
2547
2548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2549 where
2550 V: serde::de::MapAccess<'de>,
2551 {
2552 let mut status__ = None;
2553 let mut canceled_jobs__ = None;
2554 while let Some(k) = map_.next_key()? {
2555 match k {
2556 GeneratedField::Status => {
2557 if status__.is_some() {
2558 return Err(serde::de::Error::duplicate_field("status"));
2559 }
2560 status__ = map_.next_value()?;
2561 }
2562 GeneratedField::CanceledJobs => {
2563 if canceled_jobs__.is_some() {
2564 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2565 }
2566 canceled_jobs__ =
2567 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2568 .into_iter().map(|x| x.0).collect())
2569 ;
2570 }
2571 }
2572 }
2573 Ok(CancelCreatingJobsResponse {
2574 status: status__,
2575 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2576 })
2577 }
2578 }
2579 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2580 }
2581}
2582impl serde::Serialize for ClusterLimit {
2583 #[allow(deprecated)]
2584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2585 where
2586 S: serde::Serializer,
2587 {
2588 use serde::ser::SerializeStruct;
2589 let mut len = 0;
2590 if self.limit.is_some() {
2591 len += 1;
2592 }
2593 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2594 if let Some(v) = self.limit.as_ref() {
2595 match v {
2596 cluster_limit::Limit::ActorCount(v) => {
2597 struct_ser.serialize_field("actorCount", v)?;
2598 }
2599 }
2600 }
2601 struct_ser.end()
2602 }
2603}
2604impl<'de> serde::Deserialize<'de> for ClusterLimit {
2605 #[allow(deprecated)]
2606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2607 where
2608 D: serde::Deserializer<'de>,
2609 {
2610 const FIELDS: &[&str] = &[
2611 "actor_count",
2612 "actorCount",
2613 ];
2614
2615 #[allow(clippy::enum_variant_names)]
2616 enum GeneratedField {
2617 ActorCount,
2618 }
2619 impl<'de> serde::Deserialize<'de> for GeneratedField {
2620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2621 where
2622 D: serde::Deserializer<'de>,
2623 {
2624 struct GeneratedVisitor;
2625
2626 impl serde::de::Visitor<'_> for GeneratedVisitor {
2627 type Value = GeneratedField;
2628
2629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2630 write!(formatter, "expected one of: {:?}", &FIELDS)
2631 }
2632
2633 #[allow(unused_variables)]
2634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2635 where
2636 E: serde::de::Error,
2637 {
2638 match value {
2639 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2640 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2641 }
2642 }
2643 }
2644 deserializer.deserialize_identifier(GeneratedVisitor)
2645 }
2646 }
2647 struct GeneratedVisitor;
2648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2649 type Value = ClusterLimit;
2650
2651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2652 formatter.write_str("struct meta.ClusterLimit")
2653 }
2654
2655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2656 where
2657 V: serde::de::MapAccess<'de>,
2658 {
2659 let mut limit__ = None;
2660 while let Some(k) = map_.next_key()? {
2661 match k {
2662 GeneratedField::ActorCount => {
2663 if limit__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("actorCount"));
2665 }
2666 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2667;
2668 }
2669 }
2670 }
2671 Ok(ClusterLimit {
2672 limit: limit__,
2673 })
2674 }
2675 }
2676 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2677 }
2678}
2679impl serde::Serialize for DeleteWorkerNodeRequest {
2680 #[allow(deprecated)]
2681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2682 where
2683 S: serde::Serializer,
2684 {
2685 use serde::ser::SerializeStruct;
2686 let mut len = 0;
2687 if self.host.is_some() {
2688 len += 1;
2689 }
2690 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2691 if let Some(v) = self.host.as_ref() {
2692 struct_ser.serialize_field("host", v)?;
2693 }
2694 struct_ser.end()
2695 }
2696}
2697impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2698 #[allow(deprecated)]
2699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2700 where
2701 D: serde::Deserializer<'de>,
2702 {
2703 const FIELDS: &[&str] = &[
2704 "host",
2705 ];
2706
2707 #[allow(clippy::enum_variant_names)]
2708 enum GeneratedField {
2709 Host,
2710 }
2711 impl<'de> serde::Deserialize<'de> for GeneratedField {
2712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2713 where
2714 D: serde::Deserializer<'de>,
2715 {
2716 struct GeneratedVisitor;
2717
2718 impl serde::de::Visitor<'_> for GeneratedVisitor {
2719 type Value = GeneratedField;
2720
2721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2722 write!(formatter, "expected one of: {:?}", &FIELDS)
2723 }
2724
2725 #[allow(unused_variables)]
2726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2727 where
2728 E: serde::de::Error,
2729 {
2730 match value {
2731 "host" => Ok(GeneratedField::Host),
2732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2733 }
2734 }
2735 }
2736 deserializer.deserialize_identifier(GeneratedVisitor)
2737 }
2738 }
2739 struct GeneratedVisitor;
2740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2741 type Value = DeleteWorkerNodeRequest;
2742
2743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2744 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2745 }
2746
2747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2748 where
2749 V: serde::de::MapAccess<'de>,
2750 {
2751 let mut host__ = None;
2752 while let Some(k) = map_.next_key()? {
2753 match k {
2754 GeneratedField::Host => {
2755 if host__.is_some() {
2756 return Err(serde::de::Error::duplicate_field("host"));
2757 }
2758 host__ = map_.next_value()?;
2759 }
2760 }
2761 }
2762 Ok(DeleteWorkerNodeRequest {
2763 host: host__,
2764 })
2765 }
2766 }
2767 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2768 }
2769}
2770impl serde::Serialize for DeleteWorkerNodeResponse {
2771 #[allow(deprecated)]
2772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2773 where
2774 S: serde::Serializer,
2775 {
2776 use serde::ser::SerializeStruct;
2777 let mut len = 0;
2778 if self.status.is_some() {
2779 len += 1;
2780 }
2781 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2782 if let Some(v) = self.status.as_ref() {
2783 struct_ser.serialize_field("status", v)?;
2784 }
2785 struct_ser.end()
2786 }
2787}
2788impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2789 #[allow(deprecated)]
2790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2791 where
2792 D: serde::Deserializer<'de>,
2793 {
2794 const FIELDS: &[&str] = &[
2795 "status",
2796 ];
2797
2798 #[allow(clippy::enum_variant_names)]
2799 enum GeneratedField {
2800 Status,
2801 }
2802 impl<'de> serde::Deserialize<'de> for GeneratedField {
2803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2804 where
2805 D: serde::Deserializer<'de>,
2806 {
2807 struct GeneratedVisitor;
2808
2809 impl serde::de::Visitor<'_> for GeneratedVisitor {
2810 type Value = GeneratedField;
2811
2812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2813 write!(formatter, "expected one of: {:?}", &FIELDS)
2814 }
2815
2816 #[allow(unused_variables)]
2817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2818 where
2819 E: serde::de::Error,
2820 {
2821 match value {
2822 "status" => Ok(GeneratedField::Status),
2823 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2824 }
2825 }
2826 }
2827 deserializer.deserialize_identifier(GeneratedVisitor)
2828 }
2829 }
2830 struct GeneratedVisitor;
2831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2832 type Value = DeleteWorkerNodeResponse;
2833
2834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2835 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2836 }
2837
2838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2839 where
2840 V: serde::de::MapAccess<'de>,
2841 {
2842 let mut status__ = None;
2843 while let Some(k) = map_.next_key()? {
2844 match k {
2845 GeneratedField::Status => {
2846 if status__.is_some() {
2847 return Err(serde::de::Error::duplicate_field("status"));
2848 }
2849 status__ = map_.next_value()?;
2850 }
2851 }
2852 }
2853 Ok(DeleteWorkerNodeResponse {
2854 status: status__,
2855 })
2856 }
2857 }
2858 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2859 }
2860}
2861impl serde::Serialize for EventLog {
2862 #[allow(deprecated)]
2863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2864 where
2865 S: serde::Serializer,
2866 {
2867 use serde::ser::SerializeStruct;
2868 let mut len = 0;
2869 if self.unique_id.is_some() {
2870 len += 1;
2871 }
2872 if self.timestamp.is_some() {
2873 len += 1;
2874 }
2875 if self.event.is_some() {
2876 len += 1;
2877 }
2878 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2879 if let Some(v) = self.unique_id.as_ref() {
2880 struct_ser.serialize_field("uniqueId", v)?;
2881 }
2882 if let Some(v) = self.timestamp.as_ref() {
2883 #[allow(clippy::needless_borrow)]
2884 #[allow(clippy::needless_borrows_for_generic_args)]
2885 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2886 }
2887 if let Some(v) = self.event.as_ref() {
2888 match v {
2889 event_log::Event::CreateStreamJobFail(v) => {
2890 struct_ser.serialize_field("createStreamJobFail", v)?;
2891 }
2892 event_log::Event::DirtyStreamJobClear(v) => {
2893 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2894 }
2895 event_log::Event::MetaNodeStart(v) => {
2896 struct_ser.serialize_field("metaNodeStart", v)?;
2897 }
2898 event_log::Event::BarrierComplete(v) => {
2899 struct_ser.serialize_field("barrierComplete", v)?;
2900 }
2901 event_log::Event::InjectBarrierFail(v) => {
2902 struct_ser.serialize_field("injectBarrierFail", v)?;
2903 }
2904 event_log::Event::CollectBarrierFail(v) => {
2905 struct_ser.serialize_field("collectBarrierFail", v)?;
2906 }
2907 event_log::Event::WorkerNodePanic(v) => {
2908 struct_ser.serialize_field("workerNodePanic", v)?;
2909 }
2910 event_log::Event::AutoSchemaChangeFail(v) => {
2911 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2912 }
2913 event_log::Event::SinkFail(v) => {
2914 struct_ser.serialize_field("sinkFail", v)?;
2915 }
2916 event_log::Event::Recovery(v) => {
2917 struct_ser.serialize_field("recovery", v)?;
2918 }
2919 }
2920 }
2921 struct_ser.end()
2922 }
2923}
2924impl<'de> serde::Deserialize<'de> for EventLog {
2925 #[allow(deprecated)]
2926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2927 where
2928 D: serde::Deserializer<'de>,
2929 {
2930 const FIELDS: &[&str] = &[
2931 "unique_id",
2932 "uniqueId",
2933 "timestamp",
2934 "create_stream_job_fail",
2935 "createStreamJobFail",
2936 "dirty_stream_job_clear",
2937 "dirtyStreamJobClear",
2938 "meta_node_start",
2939 "metaNodeStart",
2940 "barrier_complete",
2941 "barrierComplete",
2942 "inject_barrier_fail",
2943 "injectBarrierFail",
2944 "collect_barrier_fail",
2945 "collectBarrierFail",
2946 "worker_node_panic",
2947 "workerNodePanic",
2948 "auto_schema_change_fail",
2949 "autoSchemaChangeFail",
2950 "sink_fail",
2951 "sinkFail",
2952 "recovery",
2953 ];
2954
2955 #[allow(clippy::enum_variant_names)]
2956 enum GeneratedField {
2957 UniqueId,
2958 Timestamp,
2959 CreateStreamJobFail,
2960 DirtyStreamJobClear,
2961 MetaNodeStart,
2962 BarrierComplete,
2963 InjectBarrierFail,
2964 CollectBarrierFail,
2965 WorkerNodePanic,
2966 AutoSchemaChangeFail,
2967 SinkFail,
2968 Recovery,
2969 }
2970 impl<'de> serde::Deserialize<'de> for GeneratedField {
2971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2972 where
2973 D: serde::Deserializer<'de>,
2974 {
2975 struct GeneratedVisitor;
2976
2977 impl serde::de::Visitor<'_> for GeneratedVisitor {
2978 type Value = GeneratedField;
2979
2980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2981 write!(formatter, "expected one of: {:?}", &FIELDS)
2982 }
2983
2984 #[allow(unused_variables)]
2985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2986 where
2987 E: serde::de::Error,
2988 {
2989 match value {
2990 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2991 "timestamp" => Ok(GeneratedField::Timestamp),
2992 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2993 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2994 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2995 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2996 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2997 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2998 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2999 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
3000 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
3001 "recovery" => Ok(GeneratedField::Recovery),
3002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3003 }
3004 }
3005 }
3006 deserializer.deserialize_identifier(GeneratedVisitor)
3007 }
3008 }
3009 struct GeneratedVisitor;
3010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3011 type Value = EventLog;
3012
3013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3014 formatter.write_str("struct meta.EventLog")
3015 }
3016
3017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
3018 where
3019 V: serde::de::MapAccess<'de>,
3020 {
3021 let mut unique_id__ = None;
3022 let mut timestamp__ = None;
3023 let mut event__ = None;
3024 while let Some(k) = map_.next_key()? {
3025 match k {
3026 GeneratedField::UniqueId => {
3027 if unique_id__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("uniqueId"));
3029 }
3030 unique_id__ = map_.next_value()?;
3031 }
3032 GeneratedField::Timestamp => {
3033 if timestamp__.is_some() {
3034 return Err(serde::de::Error::duplicate_field("timestamp"));
3035 }
3036 timestamp__ =
3037 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3038 ;
3039 }
3040 GeneratedField::CreateStreamJobFail => {
3041 if event__.is_some() {
3042 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
3043 }
3044 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
3045;
3046 }
3047 GeneratedField::DirtyStreamJobClear => {
3048 if event__.is_some() {
3049 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
3050 }
3051 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
3052;
3053 }
3054 GeneratedField::MetaNodeStart => {
3055 if event__.is_some() {
3056 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
3057 }
3058 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
3059;
3060 }
3061 GeneratedField::BarrierComplete => {
3062 if event__.is_some() {
3063 return Err(serde::de::Error::duplicate_field("barrierComplete"));
3064 }
3065 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
3066;
3067 }
3068 GeneratedField::InjectBarrierFail => {
3069 if event__.is_some() {
3070 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
3071 }
3072 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
3073;
3074 }
3075 GeneratedField::CollectBarrierFail => {
3076 if event__.is_some() {
3077 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
3078 }
3079 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
3080;
3081 }
3082 GeneratedField::WorkerNodePanic => {
3083 if event__.is_some() {
3084 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
3085 }
3086 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
3087;
3088 }
3089 GeneratedField::AutoSchemaChangeFail => {
3090 if event__.is_some() {
3091 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
3092 }
3093 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
3094;
3095 }
3096 GeneratedField::SinkFail => {
3097 if event__.is_some() {
3098 return Err(serde::de::Error::duplicate_field("sinkFail"));
3099 }
3100 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
3101;
3102 }
3103 GeneratedField::Recovery => {
3104 if event__.is_some() {
3105 return Err(serde::de::Error::duplicate_field("recovery"));
3106 }
3107 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
3108;
3109 }
3110 }
3111 }
3112 Ok(EventLog {
3113 unique_id: unique_id__,
3114 timestamp: timestamp__,
3115 event: event__,
3116 })
3117 }
3118 }
3119 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
3120 }
3121}
3122impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
3123 #[allow(deprecated)]
3124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3125 where
3126 S: serde::Serializer,
3127 {
3128 use serde::ser::SerializeStruct;
3129 let mut len = 0;
3130 if self.table_id != 0 {
3131 len += 1;
3132 }
3133 if !self.table_name.is_empty() {
3134 len += 1;
3135 }
3136 if !self.cdc_table_id.is_empty() {
3137 len += 1;
3138 }
3139 if !self.upstream_ddl.is_empty() {
3140 len += 1;
3141 }
3142 if !self.fail_info.is_empty() {
3143 len += 1;
3144 }
3145 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
3146 if self.table_id != 0 {
3147 struct_ser.serialize_field("tableId", &self.table_id)?;
3148 }
3149 if !self.table_name.is_empty() {
3150 struct_ser.serialize_field("tableName", &self.table_name)?;
3151 }
3152 if !self.cdc_table_id.is_empty() {
3153 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
3154 }
3155 if !self.upstream_ddl.is_empty() {
3156 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
3157 }
3158 if !self.fail_info.is_empty() {
3159 struct_ser.serialize_field("failInfo", &self.fail_info)?;
3160 }
3161 struct_ser.end()
3162 }
3163}
3164impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
3165 #[allow(deprecated)]
3166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3167 where
3168 D: serde::Deserializer<'de>,
3169 {
3170 const FIELDS: &[&str] = &[
3171 "table_id",
3172 "tableId",
3173 "table_name",
3174 "tableName",
3175 "cdc_table_id",
3176 "cdcTableId",
3177 "upstream_ddl",
3178 "upstreamDdl",
3179 "fail_info",
3180 "failInfo",
3181 ];
3182
3183 #[allow(clippy::enum_variant_names)]
3184 enum GeneratedField {
3185 TableId,
3186 TableName,
3187 CdcTableId,
3188 UpstreamDdl,
3189 FailInfo,
3190 }
3191 impl<'de> serde::Deserialize<'de> for GeneratedField {
3192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3193 where
3194 D: serde::Deserializer<'de>,
3195 {
3196 struct GeneratedVisitor;
3197
3198 impl serde::de::Visitor<'_> for GeneratedVisitor {
3199 type Value = GeneratedField;
3200
3201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3202 write!(formatter, "expected one of: {:?}", &FIELDS)
3203 }
3204
3205 #[allow(unused_variables)]
3206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3207 where
3208 E: serde::de::Error,
3209 {
3210 match value {
3211 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3212 "tableName" | "table_name" => Ok(GeneratedField::TableName),
3213 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
3214 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
3215 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
3216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3217 }
3218 }
3219 }
3220 deserializer.deserialize_identifier(GeneratedVisitor)
3221 }
3222 }
3223 struct GeneratedVisitor;
3224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3225 type Value = event_log::EventAutoSchemaChangeFail;
3226
3227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3228 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
3229 }
3230
3231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
3232 where
3233 V: serde::de::MapAccess<'de>,
3234 {
3235 let mut table_id__ = None;
3236 let mut table_name__ = None;
3237 let mut cdc_table_id__ = None;
3238 let mut upstream_ddl__ = None;
3239 let mut fail_info__ = None;
3240 while let Some(k) = map_.next_key()? {
3241 match k {
3242 GeneratedField::TableId => {
3243 if table_id__.is_some() {
3244 return Err(serde::de::Error::duplicate_field("tableId"));
3245 }
3246 table_id__ =
3247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3248 ;
3249 }
3250 GeneratedField::TableName => {
3251 if table_name__.is_some() {
3252 return Err(serde::de::Error::duplicate_field("tableName"));
3253 }
3254 table_name__ = Some(map_.next_value()?);
3255 }
3256 GeneratedField::CdcTableId => {
3257 if cdc_table_id__.is_some() {
3258 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3259 }
3260 cdc_table_id__ = Some(map_.next_value()?);
3261 }
3262 GeneratedField::UpstreamDdl => {
3263 if upstream_ddl__.is_some() {
3264 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3265 }
3266 upstream_ddl__ = Some(map_.next_value()?);
3267 }
3268 GeneratedField::FailInfo => {
3269 if fail_info__.is_some() {
3270 return Err(serde::de::Error::duplicate_field("failInfo"));
3271 }
3272 fail_info__ = Some(map_.next_value()?);
3273 }
3274 }
3275 }
3276 Ok(event_log::EventAutoSchemaChangeFail {
3277 table_id: table_id__.unwrap_or_default(),
3278 table_name: table_name__.unwrap_or_default(),
3279 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3280 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3281 fail_info: fail_info__.unwrap_or_default(),
3282 })
3283 }
3284 }
3285 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3286 }
3287}
3288impl serde::Serialize for event_log::EventBarrierComplete {
3289 #[allow(deprecated)]
3290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3291 where
3292 S: serde::Serializer,
3293 {
3294 use serde::ser::SerializeStruct;
3295 let mut len = 0;
3296 if self.prev_epoch != 0 {
3297 len += 1;
3298 }
3299 if self.cur_epoch != 0 {
3300 len += 1;
3301 }
3302 if self.duration_sec != 0. {
3303 len += 1;
3304 }
3305 if !self.command.is_empty() {
3306 len += 1;
3307 }
3308 if !self.barrier_kind.is_empty() {
3309 len += 1;
3310 }
3311 if self.database_id != 0 {
3312 len += 1;
3313 }
3314 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3315 if self.prev_epoch != 0 {
3316 #[allow(clippy::needless_borrow)]
3317 #[allow(clippy::needless_borrows_for_generic_args)]
3318 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3319 }
3320 if self.cur_epoch != 0 {
3321 #[allow(clippy::needless_borrow)]
3322 #[allow(clippy::needless_borrows_for_generic_args)]
3323 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3324 }
3325 if self.duration_sec != 0. {
3326 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3327 }
3328 if !self.command.is_empty() {
3329 struct_ser.serialize_field("command", &self.command)?;
3330 }
3331 if !self.barrier_kind.is_empty() {
3332 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3333 }
3334 if self.database_id != 0 {
3335 struct_ser.serialize_field("databaseId", &self.database_id)?;
3336 }
3337 struct_ser.end()
3338 }
3339}
3340impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3341 #[allow(deprecated)]
3342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3343 where
3344 D: serde::Deserializer<'de>,
3345 {
3346 const FIELDS: &[&str] = &[
3347 "prev_epoch",
3348 "prevEpoch",
3349 "cur_epoch",
3350 "curEpoch",
3351 "duration_sec",
3352 "durationSec",
3353 "command",
3354 "barrier_kind",
3355 "barrierKind",
3356 "database_id",
3357 "databaseId",
3358 ];
3359
3360 #[allow(clippy::enum_variant_names)]
3361 enum GeneratedField {
3362 PrevEpoch,
3363 CurEpoch,
3364 DurationSec,
3365 Command,
3366 BarrierKind,
3367 DatabaseId,
3368 }
3369 impl<'de> serde::Deserialize<'de> for GeneratedField {
3370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3371 where
3372 D: serde::Deserializer<'de>,
3373 {
3374 struct GeneratedVisitor;
3375
3376 impl serde::de::Visitor<'_> for GeneratedVisitor {
3377 type Value = GeneratedField;
3378
3379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3380 write!(formatter, "expected one of: {:?}", &FIELDS)
3381 }
3382
3383 #[allow(unused_variables)]
3384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3385 where
3386 E: serde::de::Error,
3387 {
3388 match value {
3389 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3390 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3391 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3392 "command" => Ok(GeneratedField::Command),
3393 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3394 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3396 }
3397 }
3398 }
3399 deserializer.deserialize_identifier(GeneratedVisitor)
3400 }
3401 }
3402 struct GeneratedVisitor;
3403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3404 type Value = event_log::EventBarrierComplete;
3405
3406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3407 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3408 }
3409
3410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3411 where
3412 V: serde::de::MapAccess<'de>,
3413 {
3414 let mut prev_epoch__ = None;
3415 let mut cur_epoch__ = None;
3416 let mut duration_sec__ = None;
3417 let mut command__ = None;
3418 let mut barrier_kind__ = None;
3419 let mut database_id__ = None;
3420 while let Some(k) = map_.next_key()? {
3421 match k {
3422 GeneratedField::PrevEpoch => {
3423 if prev_epoch__.is_some() {
3424 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3425 }
3426 prev_epoch__ =
3427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3428 ;
3429 }
3430 GeneratedField::CurEpoch => {
3431 if cur_epoch__.is_some() {
3432 return Err(serde::de::Error::duplicate_field("curEpoch"));
3433 }
3434 cur_epoch__ =
3435 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3436 ;
3437 }
3438 GeneratedField::DurationSec => {
3439 if duration_sec__.is_some() {
3440 return Err(serde::de::Error::duplicate_field("durationSec"));
3441 }
3442 duration_sec__ =
3443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3444 ;
3445 }
3446 GeneratedField::Command => {
3447 if command__.is_some() {
3448 return Err(serde::de::Error::duplicate_field("command"));
3449 }
3450 command__ = Some(map_.next_value()?);
3451 }
3452 GeneratedField::BarrierKind => {
3453 if barrier_kind__.is_some() {
3454 return Err(serde::de::Error::duplicate_field("barrierKind"));
3455 }
3456 barrier_kind__ = Some(map_.next_value()?);
3457 }
3458 GeneratedField::DatabaseId => {
3459 if database_id__.is_some() {
3460 return Err(serde::de::Error::duplicate_field("databaseId"));
3461 }
3462 database_id__ =
3463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3464 ;
3465 }
3466 }
3467 }
3468 Ok(event_log::EventBarrierComplete {
3469 prev_epoch: prev_epoch__.unwrap_or_default(),
3470 cur_epoch: cur_epoch__.unwrap_or_default(),
3471 duration_sec: duration_sec__.unwrap_or_default(),
3472 command: command__.unwrap_or_default(),
3473 barrier_kind: barrier_kind__.unwrap_or_default(),
3474 database_id: database_id__.unwrap_or_default(),
3475 })
3476 }
3477 }
3478 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3479 }
3480}
3481impl serde::Serialize for event_log::EventCollectBarrierFail {
3482 #[allow(deprecated)]
3483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3484 where
3485 S: serde::Serializer,
3486 {
3487 use serde::ser::SerializeStruct;
3488 let mut len = 0;
3489 if !self.error.is_empty() {
3490 len += 1;
3491 }
3492 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3493 if !self.error.is_empty() {
3494 struct_ser.serialize_field("error", &self.error)?;
3495 }
3496 struct_ser.end()
3497 }
3498}
3499impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3500 #[allow(deprecated)]
3501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3502 where
3503 D: serde::Deserializer<'de>,
3504 {
3505 const FIELDS: &[&str] = &[
3506 "error",
3507 ];
3508
3509 #[allow(clippy::enum_variant_names)]
3510 enum GeneratedField {
3511 Error,
3512 }
3513 impl<'de> serde::Deserialize<'de> for GeneratedField {
3514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3515 where
3516 D: serde::Deserializer<'de>,
3517 {
3518 struct GeneratedVisitor;
3519
3520 impl serde::de::Visitor<'_> for GeneratedVisitor {
3521 type Value = GeneratedField;
3522
3523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3524 write!(formatter, "expected one of: {:?}", &FIELDS)
3525 }
3526
3527 #[allow(unused_variables)]
3528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3529 where
3530 E: serde::de::Error,
3531 {
3532 match value {
3533 "error" => Ok(GeneratedField::Error),
3534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3535 }
3536 }
3537 }
3538 deserializer.deserialize_identifier(GeneratedVisitor)
3539 }
3540 }
3541 struct GeneratedVisitor;
3542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3543 type Value = event_log::EventCollectBarrierFail;
3544
3545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3546 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3547 }
3548
3549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3550 where
3551 V: serde::de::MapAccess<'de>,
3552 {
3553 let mut error__ = None;
3554 while let Some(k) = map_.next_key()? {
3555 match k {
3556 GeneratedField::Error => {
3557 if error__.is_some() {
3558 return Err(serde::de::Error::duplicate_field("error"));
3559 }
3560 error__ = Some(map_.next_value()?);
3561 }
3562 }
3563 }
3564 Ok(event_log::EventCollectBarrierFail {
3565 error: error__.unwrap_or_default(),
3566 })
3567 }
3568 }
3569 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3570 }
3571}
3572impl serde::Serialize for event_log::EventCreateStreamJobFail {
3573 #[allow(deprecated)]
3574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3575 where
3576 S: serde::Serializer,
3577 {
3578 use serde::ser::SerializeStruct;
3579 let mut len = 0;
3580 if self.id != 0 {
3581 len += 1;
3582 }
3583 if !self.name.is_empty() {
3584 len += 1;
3585 }
3586 if !self.definition.is_empty() {
3587 len += 1;
3588 }
3589 if !self.error.is_empty() {
3590 len += 1;
3591 }
3592 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3593 if self.id != 0 {
3594 struct_ser.serialize_field("id", &self.id)?;
3595 }
3596 if !self.name.is_empty() {
3597 struct_ser.serialize_field("name", &self.name)?;
3598 }
3599 if !self.definition.is_empty() {
3600 struct_ser.serialize_field("definition", &self.definition)?;
3601 }
3602 if !self.error.is_empty() {
3603 struct_ser.serialize_field("error", &self.error)?;
3604 }
3605 struct_ser.end()
3606 }
3607}
3608impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3609 #[allow(deprecated)]
3610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3611 where
3612 D: serde::Deserializer<'de>,
3613 {
3614 const FIELDS: &[&str] = &[
3615 "id",
3616 "name",
3617 "definition",
3618 "error",
3619 ];
3620
3621 #[allow(clippy::enum_variant_names)]
3622 enum GeneratedField {
3623 Id,
3624 Name,
3625 Definition,
3626 Error,
3627 }
3628 impl<'de> serde::Deserialize<'de> for GeneratedField {
3629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3630 where
3631 D: serde::Deserializer<'de>,
3632 {
3633 struct GeneratedVisitor;
3634
3635 impl serde::de::Visitor<'_> for GeneratedVisitor {
3636 type Value = GeneratedField;
3637
3638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3639 write!(formatter, "expected one of: {:?}", &FIELDS)
3640 }
3641
3642 #[allow(unused_variables)]
3643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3644 where
3645 E: serde::de::Error,
3646 {
3647 match value {
3648 "id" => Ok(GeneratedField::Id),
3649 "name" => Ok(GeneratedField::Name),
3650 "definition" => Ok(GeneratedField::Definition),
3651 "error" => Ok(GeneratedField::Error),
3652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3653 }
3654 }
3655 }
3656 deserializer.deserialize_identifier(GeneratedVisitor)
3657 }
3658 }
3659 struct GeneratedVisitor;
3660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3661 type Value = event_log::EventCreateStreamJobFail;
3662
3663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3664 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3665 }
3666
3667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3668 where
3669 V: serde::de::MapAccess<'de>,
3670 {
3671 let mut id__ = None;
3672 let mut name__ = None;
3673 let mut definition__ = None;
3674 let mut error__ = None;
3675 while let Some(k) = map_.next_key()? {
3676 match k {
3677 GeneratedField::Id => {
3678 if id__.is_some() {
3679 return Err(serde::de::Error::duplicate_field("id"));
3680 }
3681 id__ =
3682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3683 ;
3684 }
3685 GeneratedField::Name => {
3686 if name__.is_some() {
3687 return Err(serde::de::Error::duplicate_field("name"));
3688 }
3689 name__ = Some(map_.next_value()?);
3690 }
3691 GeneratedField::Definition => {
3692 if definition__.is_some() {
3693 return Err(serde::de::Error::duplicate_field("definition"));
3694 }
3695 definition__ = Some(map_.next_value()?);
3696 }
3697 GeneratedField::Error => {
3698 if error__.is_some() {
3699 return Err(serde::de::Error::duplicate_field("error"));
3700 }
3701 error__ = Some(map_.next_value()?);
3702 }
3703 }
3704 }
3705 Ok(event_log::EventCreateStreamJobFail {
3706 id: id__.unwrap_or_default(),
3707 name: name__.unwrap_or_default(),
3708 definition: definition__.unwrap_or_default(),
3709 error: error__.unwrap_or_default(),
3710 })
3711 }
3712 }
3713 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3714 }
3715}
3716impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3717 #[allow(deprecated)]
3718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3719 where
3720 S: serde::Serializer,
3721 {
3722 use serde::ser::SerializeStruct;
3723 let mut len = 0;
3724 if self.id != 0 {
3725 len += 1;
3726 }
3727 if !self.name.is_empty() {
3728 len += 1;
3729 }
3730 if !self.definition.is_empty() {
3731 len += 1;
3732 }
3733 if !self.error.is_empty() {
3734 len += 1;
3735 }
3736 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3737 if self.id != 0 {
3738 struct_ser.serialize_field("id", &self.id)?;
3739 }
3740 if !self.name.is_empty() {
3741 struct_ser.serialize_field("name", &self.name)?;
3742 }
3743 if !self.definition.is_empty() {
3744 struct_ser.serialize_field("definition", &self.definition)?;
3745 }
3746 if !self.error.is_empty() {
3747 struct_ser.serialize_field("error", &self.error)?;
3748 }
3749 struct_ser.end()
3750 }
3751}
3752impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3753 #[allow(deprecated)]
3754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3755 where
3756 D: serde::Deserializer<'de>,
3757 {
3758 const FIELDS: &[&str] = &[
3759 "id",
3760 "name",
3761 "definition",
3762 "error",
3763 ];
3764
3765 #[allow(clippy::enum_variant_names)]
3766 enum GeneratedField {
3767 Id,
3768 Name,
3769 Definition,
3770 Error,
3771 }
3772 impl<'de> serde::Deserialize<'de> for GeneratedField {
3773 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3774 where
3775 D: serde::Deserializer<'de>,
3776 {
3777 struct GeneratedVisitor;
3778
3779 impl serde::de::Visitor<'_> for GeneratedVisitor {
3780 type Value = GeneratedField;
3781
3782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3783 write!(formatter, "expected one of: {:?}", &FIELDS)
3784 }
3785
3786 #[allow(unused_variables)]
3787 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3788 where
3789 E: serde::de::Error,
3790 {
3791 match value {
3792 "id" => Ok(GeneratedField::Id),
3793 "name" => Ok(GeneratedField::Name),
3794 "definition" => Ok(GeneratedField::Definition),
3795 "error" => Ok(GeneratedField::Error),
3796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3797 }
3798 }
3799 }
3800 deserializer.deserialize_identifier(GeneratedVisitor)
3801 }
3802 }
3803 struct GeneratedVisitor;
3804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3805 type Value = event_log::EventDirtyStreamJobClear;
3806
3807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3808 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3809 }
3810
3811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3812 where
3813 V: serde::de::MapAccess<'de>,
3814 {
3815 let mut id__ = None;
3816 let mut name__ = None;
3817 let mut definition__ = None;
3818 let mut error__ = None;
3819 while let Some(k) = map_.next_key()? {
3820 match k {
3821 GeneratedField::Id => {
3822 if id__.is_some() {
3823 return Err(serde::de::Error::duplicate_field("id"));
3824 }
3825 id__ =
3826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3827 ;
3828 }
3829 GeneratedField::Name => {
3830 if name__.is_some() {
3831 return Err(serde::de::Error::duplicate_field("name"));
3832 }
3833 name__ = Some(map_.next_value()?);
3834 }
3835 GeneratedField::Definition => {
3836 if definition__.is_some() {
3837 return Err(serde::de::Error::duplicate_field("definition"));
3838 }
3839 definition__ = Some(map_.next_value()?);
3840 }
3841 GeneratedField::Error => {
3842 if error__.is_some() {
3843 return Err(serde::de::Error::duplicate_field("error"));
3844 }
3845 error__ = Some(map_.next_value()?);
3846 }
3847 }
3848 }
3849 Ok(event_log::EventDirtyStreamJobClear {
3850 id: id__.unwrap_or_default(),
3851 name: name__.unwrap_or_default(),
3852 definition: definition__.unwrap_or_default(),
3853 error: error__.unwrap_or_default(),
3854 })
3855 }
3856 }
3857 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3858 }
3859}
3860impl serde::Serialize for event_log::EventInjectBarrierFail {
3861 #[allow(deprecated)]
3862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3863 where
3864 S: serde::Serializer,
3865 {
3866 use serde::ser::SerializeStruct;
3867 let mut len = 0;
3868 if self.prev_epoch != 0 {
3869 len += 1;
3870 }
3871 if self.cur_epoch != 0 {
3872 len += 1;
3873 }
3874 if !self.error.is_empty() {
3875 len += 1;
3876 }
3877 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3878 if self.prev_epoch != 0 {
3879 #[allow(clippy::needless_borrow)]
3880 #[allow(clippy::needless_borrows_for_generic_args)]
3881 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3882 }
3883 if self.cur_epoch != 0 {
3884 #[allow(clippy::needless_borrow)]
3885 #[allow(clippy::needless_borrows_for_generic_args)]
3886 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3887 }
3888 if !self.error.is_empty() {
3889 struct_ser.serialize_field("error", &self.error)?;
3890 }
3891 struct_ser.end()
3892 }
3893}
3894impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3895 #[allow(deprecated)]
3896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3897 where
3898 D: serde::Deserializer<'de>,
3899 {
3900 const FIELDS: &[&str] = &[
3901 "prev_epoch",
3902 "prevEpoch",
3903 "cur_epoch",
3904 "curEpoch",
3905 "error",
3906 ];
3907
3908 #[allow(clippy::enum_variant_names)]
3909 enum GeneratedField {
3910 PrevEpoch,
3911 CurEpoch,
3912 Error,
3913 }
3914 impl<'de> serde::Deserialize<'de> for GeneratedField {
3915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3916 where
3917 D: serde::Deserializer<'de>,
3918 {
3919 struct GeneratedVisitor;
3920
3921 impl serde::de::Visitor<'_> for GeneratedVisitor {
3922 type Value = GeneratedField;
3923
3924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3925 write!(formatter, "expected one of: {:?}", &FIELDS)
3926 }
3927
3928 #[allow(unused_variables)]
3929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3930 where
3931 E: serde::de::Error,
3932 {
3933 match value {
3934 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3935 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3936 "error" => Ok(GeneratedField::Error),
3937 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3938 }
3939 }
3940 }
3941 deserializer.deserialize_identifier(GeneratedVisitor)
3942 }
3943 }
3944 struct GeneratedVisitor;
3945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3946 type Value = event_log::EventInjectBarrierFail;
3947
3948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3949 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3950 }
3951
3952 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3953 where
3954 V: serde::de::MapAccess<'de>,
3955 {
3956 let mut prev_epoch__ = None;
3957 let mut cur_epoch__ = None;
3958 let mut error__ = None;
3959 while let Some(k) = map_.next_key()? {
3960 match k {
3961 GeneratedField::PrevEpoch => {
3962 if prev_epoch__.is_some() {
3963 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3964 }
3965 prev_epoch__ =
3966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3967 ;
3968 }
3969 GeneratedField::CurEpoch => {
3970 if cur_epoch__.is_some() {
3971 return Err(serde::de::Error::duplicate_field("curEpoch"));
3972 }
3973 cur_epoch__ =
3974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3975 ;
3976 }
3977 GeneratedField::Error => {
3978 if error__.is_some() {
3979 return Err(serde::de::Error::duplicate_field("error"));
3980 }
3981 error__ = Some(map_.next_value()?);
3982 }
3983 }
3984 }
3985 Ok(event_log::EventInjectBarrierFail {
3986 prev_epoch: prev_epoch__.unwrap_or_default(),
3987 cur_epoch: cur_epoch__.unwrap_or_default(),
3988 error: error__.unwrap_or_default(),
3989 })
3990 }
3991 }
3992 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3993 }
3994}
3995impl serde::Serialize for event_log::EventMetaNodeStart {
3996 #[allow(deprecated)]
3997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3998 where
3999 S: serde::Serializer,
4000 {
4001 use serde::ser::SerializeStruct;
4002 let mut len = 0;
4003 if !self.advertise_addr.is_empty() {
4004 len += 1;
4005 }
4006 if !self.listen_addr.is_empty() {
4007 len += 1;
4008 }
4009 if !self.opts.is_empty() {
4010 len += 1;
4011 }
4012 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
4013 if !self.advertise_addr.is_empty() {
4014 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
4015 }
4016 if !self.listen_addr.is_empty() {
4017 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
4018 }
4019 if !self.opts.is_empty() {
4020 struct_ser.serialize_field("opts", &self.opts)?;
4021 }
4022 struct_ser.end()
4023 }
4024}
4025impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
4026 #[allow(deprecated)]
4027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4028 where
4029 D: serde::Deserializer<'de>,
4030 {
4031 const FIELDS: &[&str] = &[
4032 "advertise_addr",
4033 "advertiseAddr",
4034 "listen_addr",
4035 "listenAddr",
4036 "opts",
4037 ];
4038
4039 #[allow(clippy::enum_variant_names)]
4040 enum GeneratedField {
4041 AdvertiseAddr,
4042 ListenAddr,
4043 Opts,
4044 }
4045 impl<'de> serde::Deserialize<'de> for GeneratedField {
4046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4047 where
4048 D: serde::Deserializer<'de>,
4049 {
4050 struct GeneratedVisitor;
4051
4052 impl serde::de::Visitor<'_> for GeneratedVisitor {
4053 type Value = GeneratedField;
4054
4055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4056 write!(formatter, "expected one of: {:?}", &FIELDS)
4057 }
4058
4059 #[allow(unused_variables)]
4060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4061 where
4062 E: serde::de::Error,
4063 {
4064 match value {
4065 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
4066 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
4067 "opts" => Ok(GeneratedField::Opts),
4068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4069 }
4070 }
4071 }
4072 deserializer.deserialize_identifier(GeneratedVisitor)
4073 }
4074 }
4075 struct GeneratedVisitor;
4076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4077 type Value = event_log::EventMetaNodeStart;
4078
4079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4080 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
4081 }
4082
4083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
4084 where
4085 V: serde::de::MapAccess<'de>,
4086 {
4087 let mut advertise_addr__ = None;
4088 let mut listen_addr__ = None;
4089 let mut opts__ = None;
4090 while let Some(k) = map_.next_key()? {
4091 match k {
4092 GeneratedField::AdvertiseAddr => {
4093 if advertise_addr__.is_some() {
4094 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
4095 }
4096 advertise_addr__ = Some(map_.next_value()?);
4097 }
4098 GeneratedField::ListenAddr => {
4099 if listen_addr__.is_some() {
4100 return Err(serde::de::Error::duplicate_field("listenAddr"));
4101 }
4102 listen_addr__ = Some(map_.next_value()?);
4103 }
4104 GeneratedField::Opts => {
4105 if opts__.is_some() {
4106 return Err(serde::de::Error::duplicate_field("opts"));
4107 }
4108 opts__ = Some(map_.next_value()?);
4109 }
4110 }
4111 }
4112 Ok(event_log::EventMetaNodeStart {
4113 advertise_addr: advertise_addr__.unwrap_or_default(),
4114 listen_addr: listen_addr__.unwrap_or_default(),
4115 opts: opts__.unwrap_or_default(),
4116 })
4117 }
4118 }
4119 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
4120 }
4121}
4122impl serde::Serialize for event_log::EventRecovery {
4123 #[allow(deprecated)]
4124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4125 where
4126 S: serde::Serializer,
4127 {
4128 use serde::ser::SerializeStruct;
4129 let mut len = 0;
4130 if self.recovery_event.is_some() {
4131 len += 1;
4132 }
4133 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
4134 if let Some(v) = self.recovery_event.as_ref() {
4135 match v {
4136 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
4137 struct_ser.serialize_field("globalStart", v)?;
4138 }
4139 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
4140 struct_ser.serialize_field("globalSuccess", v)?;
4141 }
4142 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
4143 struct_ser.serialize_field("globalFailure", v)?;
4144 }
4145 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
4146 struct_ser.serialize_field("databaseStart", v)?;
4147 }
4148 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
4149 struct_ser.serialize_field("databaseFailure", v)?;
4150 }
4151 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
4152 struct_ser.serialize_field("databaseSuccess", v)?;
4153 }
4154 }
4155 }
4156 struct_ser.end()
4157 }
4158}
4159impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
4160 #[allow(deprecated)]
4161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4162 where
4163 D: serde::Deserializer<'de>,
4164 {
4165 const FIELDS: &[&str] = &[
4166 "global_start",
4167 "globalStart",
4168 "global_success",
4169 "globalSuccess",
4170 "global_failure",
4171 "globalFailure",
4172 "database_start",
4173 "databaseStart",
4174 "database_failure",
4175 "databaseFailure",
4176 "database_success",
4177 "databaseSuccess",
4178 ];
4179
4180 #[allow(clippy::enum_variant_names)]
4181 enum GeneratedField {
4182 GlobalStart,
4183 GlobalSuccess,
4184 GlobalFailure,
4185 DatabaseStart,
4186 DatabaseFailure,
4187 DatabaseSuccess,
4188 }
4189 impl<'de> serde::Deserialize<'de> for GeneratedField {
4190 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4191 where
4192 D: serde::Deserializer<'de>,
4193 {
4194 struct GeneratedVisitor;
4195
4196 impl serde::de::Visitor<'_> for GeneratedVisitor {
4197 type Value = GeneratedField;
4198
4199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4200 write!(formatter, "expected one of: {:?}", &FIELDS)
4201 }
4202
4203 #[allow(unused_variables)]
4204 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4205 where
4206 E: serde::de::Error,
4207 {
4208 match value {
4209 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
4210 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
4211 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
4212 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
4213 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
4214 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
4215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4216 }
4217 }
4218 }
4219 deserializer.deserialize_identifier(GeneratedVisitor)
4220 }
4221 }
4222 struct GeneratedVisitor;
4223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4224 type Value = event_log::EventRecovery;
4225
4226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4227 formatter.write_str("struct meta.EventLog.EventRecovery")
4228 }
4229
4230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
4231 where
4232 V: serde::de::MapAccess<'de>,
4233 {
4234 let mut recovery_event__ = None;
4235 while let Some(k) = map_.next_key()? {
4236 match k {
4237 GeneratedField::GlobalStart => {
4238 if recovery_event__.is_some() {
4239 return Err(serde::de::Error::duplicate_field("globalStart"));
4240 }
4241 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
4242;
4243 }
4244 GeneratedField::GlobalSuccess => {
4245 if recovery_event__.is_some() {
4246 return Err(serde::de::Error::duplicate_field("globalSuccess"));
4247 }
4248 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
4249;
4250 }
4251 GeneratedField::GlobalFailure => {
4252 if recovery_event__.is_some() {
4253 return Err(serde::de::Error::duplicate_field("globalFailure"));
4254 }
4255 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
4256;
4257 }
4258 GeneratedField::DatabaseStart => {
4259 if recovery_event__.is_some() {
4260 return Err(serde::de::Error::duplicate_field("databaseStart"));
4261 }
4262 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
4263;
4264 }
4265 GeneratedField::DatabaseFailure => {
4266 if recovery_event__.is_some() {
4267 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4268 }
4269 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4270;
4271 }
4272 GeneratedField::DatabaseSuccess => {
4273 if recovery_event__.is_some() {
4274 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4275 }
4276 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4277;
4278 }
4279 }
4280 }
4281 Ok(event_log::EventRecovery {
4282 recovery_event: recovery_event__,
4283 })
4284 }
4285 }
4286 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4287 }
4288}
4289impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4290 #[allow(deprecated)]
4291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4292 where
4293 S: serde::Serializer,
4294 {
4295 use serde::ser::SerializeStruct;
4296 let mut len = 0;
4297 if self.database_id != 0 {
4298 len += 1;
4299 }
4300 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4301 if self.database_id != 0 {
4302 struct_ser.serialize_field("databaseId", &self.database_id)?;
4303 }
4304 struct_ser.end()
4305 }
4306}
4307impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4308 #[allow(deprecated)]
4309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4310 where
4311 D: serde::Deserializer<'de>,
4312 {
4313 const FIELDS: &[&str] = &[
4314 "database_id",
4315 "databaseId",
4316 ];
4317
4318 #[allow(clippy::enum_variant_names)]
4319 enum GeneratedField {
4320 DatabaseId,
4321 }
4322 impl<'de> serde::Deserialize<'de> for GeneratedField {
4323 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4324 where
4325 D: serde::Deserializer<'de>,
4326 {
4327 struct GeneratedVisitor;
4328
4329 impl serde::de::Visitor<'_> for GeneratedVisitor {
4330 type Value = GeneratedField;
4331
4332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4333 write!(formatter, "expected one of: {:?}", &FIELDS)
4334 }
4335
4336 #[allow(unused_variables)]
4337 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4338 where
4339 E: serde::de::Error,
4340 {
4341 match value {
4342 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4344 }
4345 }
4346 }
4347 deserializer.deserialize_identifier(GeneratedVisitor)
4348 }
4349 }
4350 struct GeneratedVisitor;
4351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4352 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4353
4354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4355 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4356 }
4357
4358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4359 where
4360 V: serde::de::MapAccess<'de>,
4361 {
4362 let mut database_id__ = None;
4363 while let Some(k) = map_.next_key()? {
4364 match k {
4365 GeneratedField::DatabaseId => {
4366 if database_id__.is_some() {
4367 return Err(serde::de::Error::duplicate_field("databaseId"));
4368 }
4369 database_id__ =
4370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4371 ;
4372 }
4373 }
4374 }
4375 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4376 database_id: database_id__.unwrap_or_default(),
4377 })
4378 }
4379 }
4380 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4381 }
4382}
4383impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4384 #[allow(deprecated)]
4385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4386 where
4387 S: serde::Serializer,
4388 {
4389 use serde::ser::SerializeStruct;
4390 let mut len = 0;
4391 if self.database_id != 0 {
4392 len += 1;
4393 }
4394 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4395 if self.database_id != 0 {
4396 struct_ser.serialize_field("databaseId", &self.database_id)?;
4397 }
4398 struct_ser.end()
4399 }
4400}
4401impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4402 #[allow(deprecated)]
4403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4404 where
4405 D: serde::Deserializer<'de>,
4406 {
4407 const FIELDS: &[&str] = &[
4408 "database_id",
4409 "databaseId",
4410 ];
4411
4412 #[allow(clippy::enum_variant_names)]
4413 enum GeneratedField {
4414 DatabaseId,
4415 }
4416 impl<'de> serde::Deserialize<'de> for GeneratedField {
4417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4418 where
4419 D: serde::Deserializer<'de>,
4420 {
4421 struct GeneratedVisitor;
4422
4423 impl serde::de::Visitor<'_> for GeneratedVisitor {
4424 type Value = GeneratedField;
4425
4426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4427 write!(formatter, "expected one of: {:?}", &FIELDS)
4428 }
4429
4430 #[allow(unused_variables)]
4431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4432 where
4433 E: serde::de::Error,
4434 {
4435 match value {
4436 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4438 }
4439 }
4440 }
4441 deserializer.deserialize_identifier(GeneratedVisitor)
4442 }
4443 }
4444 struct GeneratedVisitor;
4445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4446 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4447
4448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4449 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4450 }
4451
4452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4453 where
4454 V: serde::de::MapAccess<'de>,
4455 {
4456 let mut database_id__ = None;
4457 while let Some(k) = map_.next_key()? {
4458 match k {
4459 GeneratedField::DatabaseId => {
4460 if database_id__.is_some() {
4461 return Err(serde::de::Error::duplicate_field("databaseId"));
4462 }
4463 database_id__ =
4464 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4465 ;
4466 }
4467 }
4468 }
4469 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4470 database_id: database_id__.unwrap_or_default(),
4471 })
4472 }
4473 }
4474 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4475 }
4476}
4477impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4478 #[allow(deprecated)]
4479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4480 where
4481 S: serde::Serializer,
4482 {
4483 use serde::ser::SerializeStruct;
4484 let mut len = 0;
4485 if self.database_id != 0 {
4486 len += 1;
4487 }
4488 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4489 if self.database_id != 0 {
4490 struct_ser.serialize_field("databaseId", &self.database_id)?;
4491 }
4492 struct_ser.end()
4493 }
4494}
4495impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4496 #[allow(deprecated)]
4497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4498 where
4499 D: serde::Deserializer<'de>,
4500 {
4501 const FIELDS: &[&str] = &[
4502 "database_id",
4503 "databaseId",
4504 ];
4505
4506 #[allow(clippy::enum_variant_names)]
4507 enum GeneratedField {
4508 DatabaseId,
4509 }
4510 impl<'de> serde::Deserialize<'de> for GeneratedField {
4511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4512 where
4513 D: serde::Deserializer<'de>,
4514 {
4515 struct GeneratedVisitor;
4516
4517 impl serde::de::Visitor<'_> for GeneratedVisitor {
4518 type Value = GeneratedField;
4519
4520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4521 write!(formatter, "expected one of: {:?}", &FIELDS)
4522 }
4523
4524 #[allow(unused_variables)]
4525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4526 where
4527 E: serde::de::Error,
4528 {
4529 match value {
4530 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4532 }
4533 }
4534 }
4535 deserializer.deserialize_identifier(GeneratedVisitor)
4536 }
4537 }
4538 struct GeneratedVisitor;
4539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4540 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4541
4542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4543 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4544 }
4545
4546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4547 where
4548 V: serde::de::MapAccess<'de>,
4549 {
4550 let mut database_id__ = None;
4551 while let Some(k) = map_.next_key()? {
4552 match k {
4553 GeneratedField::DatabaseId => {
4554 if database_id__.is_some() {
4555 return Err(serde::de::Error::duplicate_field("databaseId"));
4556 }
4557 database_id__ =
4558 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4559 ;
4560 }
4561 }
4562 }
4563 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4564 database_id: database_id__.unwrap_or_default(),
4565 })
4566 }
4567 }
4568 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4569 }
4570}
4571impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4572 #[allow(deprecated)]
4573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4574 where
4575 S: serde::Serializer,
4576 {
4577 use serde::ser::SerializeStruct;
4578 let mut len = 0;
4579 if !self.reason.is_empty() {
4580 len += 1;
4581 }
4582 if !self.error.is_empty() {
4583 len += 1;
4584 }
4585 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4586 if !self.reason.is_empty() {
4587 struct_ser.serialize_field("reason", &self.reason)?;
4588 }
4589 if !self.error.is_empty() {
4590 struct_ser.serialize_field("error", &self.error)?;
4591 }
4592 struct_ser.end()
4593 }
4594}
4595impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4596 #[allow(deprecated)]
4597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4598 where
4599 D: serde::Deserializer<'de>,
4600 {
4601 const FIELDS: &[&str] = &[
4602 "reason",
4603 "error",
4604 ];
4605
4606 #[allow(clippy::enum_variant_names)]
4607 enum GeneratedField {
4608 Reason,
4609 Error,
4610 }
4611 impl<'de> serde::Deserialize<'de> for GeneratedField {
4612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4613 where
4614 D: serde::Deserializer<'de>,
4615 {
4616 struct GeneratedVisitor;
4617
4618 impl serde::de::Visitor<'_> for GeneratedVisitor {
4619 type Value = GeneratedField;
4620
4621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4622 write!(formatter, "expected one of: {:?}", &FIELDS)
4623 }
4624
4625 #[allow(unused_variables)]
4626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4627 where
4628 E: serde::de::Error,
4629 {
4630 match value {
4631 "reason" => Ok(GeneratedField::Reason),
4632 "error" => Ok(GeneratedField::Error),
4633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4634 }
4635 }
4636 }
4637 deserializer.deserialize_identifier(GeneratedVisitor)
4638 }
4639 }
4640 struct GeneratedVisitor;
4641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4642 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4643
4644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4645 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4646 }
4647
4648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4649 where
4650 V: serde::de::MapAccess<'de>,
4651 {
4652 let mut reason__ = None;
4653 let mut error__ = None;
4654 while let Some(k) = map_.next_key()? {
4655 match k {
4656 GeneratedField::Reason => {
4657 if reason__.is_some() {
4658 return Err(serde::de::Error::duplicate_field("reason"));
4659 }
4660 reason__ = Some(map_.next_value()?);
4661 }
4662 GeneratedField::Error => {
4663 if error__.is_some() {
4664 return Err(serde::de::Error::duplicate_field("error"));
4665 }
4666 error__ = Some(map_.next_value()?);
4667 }
4668 }
4669 }
4670 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4671 reason: reason__.unwrap_or_default(),
4672 error: error__.unwrap_or_default(),
4673 })
4674 }
4675 }
4676 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4677 }
4678}
4679impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4680 #[allow(deprecated)]
4681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4682 where
4683 S: serde::Serializer,
4684 {
4685 use serde::ser::SerializeStruct;
4686 let mut len = 0;
4687 if !self.reason.is_empty() {
4688 len += 1;
4689 }
4690 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4691 if !self.reason.is_empty() {
4692 struct_ser.serialize_field("reason", &self.reason)?;
4693 }
4694 struct_ser.end()
4695 }
4696}
4697impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4698 #[allow(deprecated)]
4699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4700 where
4701 D: serde::Deserializer<'de>,
4702 {
4703 const FIELDS: &[&str] = &[
4704 "reason",
4705 ];
4706
4707 #[allow(clippy::enum_variant_names)]
4708 enum GeneratedField {
4709 Reason,
4710 }
4711 impl<'de> serde::Deserialize<'de> for GeneratedField {
4712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4713 where
4714 D: serde::Deserializer<'de>,
4715 {
4716 struct GeneratedVisitor;
4717
4718 impl serde::de::Visitor<'_> for GeneratedVisitor {
4719 type Value = GeneratedField;
4720
4721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4722 write!(formatter, "expected one of: {:?}", &FIELDS)
4723 }
4724
4725 #[allow(unused_variables)]
4726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4727 where
4728 E: serde::de::Error,
4729 {
4730 match value {
4731 "reason" => Ok(GeneratedField::Reason),
4732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4733 }
4734 }
4735 }
4736 deserializer.deserialize_identifier(GeneratedVisitor)
4737 }
4738 }
4739 struct GeneratedVisitor;
4740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4741 type Value = event_log::event_recovery::GlobalRecoveryStart;
4742
4743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4744 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4745 }
4746
4747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4748 where
4749 V: serde::de::MapAccess<'de>,
4750 {
4751 let mut reason__ = None;
4752 while let Some(k) = map_.next_key()? {
4753 match k {
4754 GeneratedField::Reason => {
4755 if reason__.is_some() {
4756 return Err(serde::de::Error::duplicate_field("reason"));
4757 }
4758 reason__ = Some(map_.next_value()?);
4759 }
4760 }
4761 }
4762 Ok(event_log::event_recovery::GlobalRecoveryStart {
4763 reason: reason__.unwrap_or_default(),
4764 })
4765 }
4766 }
4767 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4768 }
4769}
4770impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4771 #[allow(deprecated)]
4772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4773 where
4774 S: serde::Serializer,
4775 {
4776 use serde::ser::SerializeStruct;
4777 let mut len = 0;
4778 if !self.reason.is_empty() {
4779 len += 1;
4780 }
4781 if self.duration_secs != 0. {
4782 len += 1;
4783 }
4784 if !self.running_database_ids.is_empty() {
4785 len += 1;
4786 }
4787 if !self.recovering_database_ids.is_empty() {
4788 len += 1;
4789 }
4790 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4791 if !self.reason.is_empty() {
4792 struct_ser.serialize_field("reason", &self.reason)?;
4793 }
4794 if self.duration_secs != 0. {
4795 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4796 }
4797 if !self.running_database_ids.is_empty() {
4798 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4799 }
4800 if !self.recovering_database_ids.is_empty() {
4801 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4802 }
4803 struct_ser.end()
4804 }
4805}
4806impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4807 #[allow(deprecated)]
4808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4809 where
4810 D: serde::Deserializer<'de>,
4811 {
4812 const FIELDS: &[&str] = &[
4813 "reason",
4814 "duration_secs",
4815 "durationSecs",
4816 "running_database_ids",
4817 "runningDatabaseIds",
4818 "recovering_database_ids",
4819 "recoveringDatabaseIds",
4820 ];
4821
4822 #[allow(clippy::enum_variant_names)]
4823 enum GeneratedField {
4824 Reason,
4825 DurationSecs,
4826 RunningDatabaseIds,
4827 RecoveringDatabaseIds,
4828 }
4829 impl<'de> serde::Deserialize<'de> for GeneratedField {
4830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4831 where
4832 D: serde::Deserializer<'de>,
4833 {
4834 struct GeneratedVisitor;
4835
4836 impl serde::de::Visitor<'_> for GeneratedVisitor {
4837 type Value = GeneratedField;
4838
4839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4840 write!(formatter, "expected one of: {:?}", &FIELDS)
4841 }
4842
4843 #[allow(unused_variables)]
4844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4845 where
4846 E: serde::de::Error,
4847 {
4848 match value {
4849 "reason" => Ok(GeneratedField::Reason),
4850 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4851 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4852 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4853 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4854 }
4855 }
4856 }
4857 deserializer.deserialize_identifier(GeneratedVisitor)
4858 }
4859 }
4860 struct GeneratedVisitor;
4861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4862 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4863
4864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4865 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4866 }
4867
4868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4869 where
4870 V: serde::de::MapAccess<'de>,
4871 {
4872 let mut reason__ = None;
4873 let mut duration_secs__ = None;
4874 let mut running_database_ids__ = None;
4875 let mut recovering_database_ids__ = None;
4876 while let Some(k) = map_.next_key()? {
4877 match k {
4878 GeneratedField::Reason => {
4879 if reason__.is_some() {
4880 return Err(serde::de::Error::duplicate_field("reason"));
4881 }
4882 reason__ = Some(map_.next_value()?);
4883 }
4884 GeneratedField::DurationSecs => {
4885 if duration_secs__.is_some() {
4886 return Err(serde::de::Error::duplicate_field("durationSecs"));
4887 }
4888 duration_secs__ =
4889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4890 ;
4891 }
4892 GeneratedField::RunningDatabaseIds => {
4893 if running_database_ids__.is_some() {
4894 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4895 }
4896 running_database_ids__ =
4897 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4898 .into_iter().map(|x| x.0).collect())
4899 ;
4900 }
4901 GeneratedField::RecoveringDatabaseIds => {
4902 if recovering_database_ids__.is_some() {
4903 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4904 }
4905 recovering_database_ids__ =
4906 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4907 .into_iter().map(|x| x.0).collect())
4908 ;
4909 }
4910 }
4911 }
4912 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4913 reason: reason__.unwrap_or_default(),
4914 duration_secs: duration_secs__.unwrap_or_default(),
4915 running_database_ids: running_database_ids__.unwrap_or_default(),
4916 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4917 })
4918 }
4919 }
4920 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4921 }
4922}
4923impl serde::Serialize for event_log::EventSinkFail {
4924 #[allow(deprecated)]
4925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4926 where
4927 S: serde::Serializer,
4928 {
4929 use serde::ser::SerializeStruct;
4930 let mut len = 0;
4931 if self.sink_id != 0 {
4932 len += 1;
4933 }
4934 if !self.sink_name.is_empty() {
4935 len += 1;
4936 }
4937 if !self.connector.is_empty() {
4938 len += 1;
4939 }
4940 if !self.error.is_empty() {
4941 len += 1;
4942 }
4943 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4944 if self.sink_id != 0 {
4945 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4946 }
4947 if !self.sink_name.is_empty() {
4948 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4949 }
4950 if !self.connector.is_empty() {
4951 struct_ser.serialize_field("connector", &self.connector)?;
4952 }
4953 if !self.error.is_empty() {
4954 struct_ser.serialize_field("error", &self.error)?;
4955 }
4956 struct_ser.end()
4957 }
4958}
4959impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4960 #[allow(deprecated)]
4961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4962 where
4963 D: serde::Deserializer<'de>,
4964 {
4965 const FIELDS: &[&str] = &[
4966 "sink_id",
4967 "sinkId",
4968 "sink_name",
4969 "sinkName",
4970 "connector",
4971 "error",
4972 ];
4973
4974 #[allow(clippy::enum_variant_names)]
4975 enum GeneratedField {
4976 SinkId,
4977 SinkName,
4978 Connector,
4979 Error,
4980 }
4981 impl<'de> serde::Deserialize<'de> for GeneratedField {
4982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4983 where
4984 D: serde::Deserializer<'de>,
4985 {
4986 struct GeneratedVisitor;
4987
4988 impl serde::de::Visitor<'_> for GeneratedVisitor {
4989 type Value = GeneratedField;
4990
4991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4992 write!(formatter, "expected one of: {:?}", &FIELDS)
4993 }
4994
4995 #[allow(unused_variables)]
4996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4997 where
4998 E: serde::de::Error,
4999 {
5000 match value {
5001 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
5002 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
5003 "connector" => Ok(GeneratedField::Connector),
5004 "error" => Ok(GeneratedField::Error),
5005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5006 }
5007 }
5008 }
5009 deserializer.deserialize_identifier(GeneratedVisitor)
5010 }
5011 }
5012 struct GeneratedVisitor;
5013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5014 type Value = event_log::EventSinkFail;
5015
5016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5017 formatter.write_str("struct meta.EventLog.EventSinkFail")
5018 }
5019
5020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
5021 where
5022 V: serde::de::MapAccess<'de>,
5023 {
5024 let mut sink_id__ = None;
5025 let mut sink_name__ = None;
5026 let mut connector__ = None;
5027 let mut error__ = None;
5028 while let Some(k) = map_.next_key()? {
5029 match k {
5030 GeneratedField::SinkId => {
5031 if sink_id__.is_some() {
5032 return Err(serde::de::Error::duplicate_field("sinkId"));
5033 }
5034 sink_id__ =
5035 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5036 ;
5037 }
5038 GeneratedField::SinkName => {
5039 if sink_name__.is_some() {
5040 return Err(serde::de::Error::duplicate_field("sinkName"));
5041 }
5042 sink_name__ = Some(map_.next_value()?);
5043 }
5044 GeneratedField::Connector => {
5045 if connector__.is_some() {
5046 return Err(serde::de::Error::duplicate_field("connector"));
5047 }
5048 connector__ = Some(map_.next_value()?);
5049 }
5050 GeneratedField::Error => {
5051 if error__.is_some() {
5052 return Err(serde::de::Error::duplicate_field("error"));
5053 }
5054 error__ = Some(map_.next_value()?);
5055 }
5056 }
5057 }
5058 Ok(event_log::EventSinkFail {
5059 sink_id: sink_id__.unwrap_or_default(),
5060 sink_name: sink_name__.unwrap_or_default(),
5061 connector: connector__.unwrap_or_default(),
5062 error: error__.unwrap_or_default(),
5063 })
5064 }
5065 }
5066 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
5067 }
5068}
5069impl serde::Serialize for event_log::EventWorkerNodePanic {
5070 #[allow(deprecated)]
5071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5072 where
5073 S: serde::Serializer,
5074 {
5075 use serde::ser::SerializeStruct;
5076 let mut len = 0;
5077 if self.worker_id != 0 {
5078 len += 1;
5079 }
5080 if self.worker_type != 0 {
5081 len += 1;
5082 }
5083 if self.host_addr.is_some() {
5084 len += 1;
5085 }
5086 if !self.panic_info.is_empty() {
5087 len += 1;
5088 }
5089 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
5090 if self.worker_id != 0 {
5091 struct_ser.serialize_field("workerId", &self.worker_id)?;
5092 }
5093 if self.worker_type != 0 {
5094 let v = super::common::WorkerType::try_from(self.worker_type)
5095 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
5096 struct_ser.serialize_field("workerType", &v)?;
5097 }
5098 if let Some(v) = self.host_addr.as_ref() {
5099 struct_ser.serialize_field("hostAddr", v)?;
5100 }
5101 if !self.panic_info.is_empty() {
5102 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
5103 }
5104 struct_ser.end()
5105 }
5106}
5107impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
5108 #[allow(deprecated)]
5109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5110 where
5111 D: serde::Deserializer<'de>,
5112 {
5113 const FIELDS: &[&str] = &[
5114 "worker_id",
5115 "workerId",
5116 "worker_type",
5117 "workerType",
5118 "host_addr",
5119 "hostAddr",
5120 "panic_info",
5121 "panicInfo",
5122 ];
5123
5124 #[allow(clippy::enum_variant_names)]
5125 enum GeneratedField {
5126 WorkerId,
5127 WorkerType,
5128 HostAddr,
5129 PanicInfo,
5130 }
5131 impl<'de> serde::Deserialize<'de> for GeneratedField {
5132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5133 where
5134 D: serde::Deserializer<'de>,
5135 {
5136 struct GeneratedVisitor;
5137
5138 impl serde::de::Visitor<'_> for GeneratedVisitor {
5139 type Value = GeneratedField;
5140
5141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142 write!(formatter, "expected one of: {:?}", &FIELDS)
5143 }
5144
5145 #[allow(unused_variables)]
5146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5147 where
5148 E: serde::de::Error,
5149 {
5150 match value {
5151 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
5152 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
5153 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
5154 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
5155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5156 }
5157 }
5158 }
5159 deserializer.deserialize_identifier(GeneratedVisitor)
5160 }
5161 }
5162 struct GeneratedVisitor;
5163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5164 type Value = event_log::EventWorkerNodePanic;
5165
5166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5167 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
5168 }
5169
5170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
5171 where
5172 V: serde::de::MapAccess<'de>,
5173 {
5174 let mut worker_id__ = None;
5175 let mut worker_type__ = None;
5176 let mut host_addr__ = None;
5177 let mut panic_info__ = None;
5178 while let Some(k) = map_.next_key()? {
5179 match k {
5180 GeneratedField::WorkerId => {
5181 if worker_id__.is_some() {
5182 return Err(serde::de::Error::duplicate_field("workerId"));
5183 }
5184 worker_id__ =
5185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5186 ;
5187 }
5188 GeneratedField::WorkerType => {
5189 if worker_type__.is_some() {
5190 return Err(serde::de::Error::duplicate_field("workerType"));
5191 }
5192 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
5193 }
5194 GeneratedField::HostAddr => {
5195 if host_addr__.is_some() {
5196 return Err(serde::de::Error::duplicate_field("hostAddr"));
5197 }
5198 host_addr__ = map_.next_value()?;
5199 }
5200 GeneratedField::PanicInfo => {
5201 if panic_info__.is_some() {
5202 return Err(serde::de::Error::duplicate_field("panicInfo"));
5203 }
5204 panic_info__ = Some(map_.next_value()?);
5205 }
5206 }
5207 }
5208 Ok(event_log::EventWorkerNodePanic {
5209 worker_id: worker_id__.unwrap_or_default(),
5210 worker_type: worker_type__.unwrap_or_default(),
5211 host_addr: host_addr__,
5212 panic_info: panic_info__.unwrap_or_default(),
5213 })
5214 }
5215 }
5216 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
5217 }
5218}
5219impl serde::Serialize for FlushRequest {
5220 #[allow(deprecated)]
5221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5222 where
5223 S: serde::Serializer,
5224 {
5225 use serde::ser::SerializeStruct;
5226 let mut len = 0;
5227 if self.database_id != 0 {
5228 len += 1;
5229 }
5230 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
5231 if self.database_id != 0 {
5232 struct_ser.serialize_field("databaseId", &self.database_id)?;
5233 }
5234 struct_ser.end()
5235 }
5236}
5237impl<'de> serde::Deserialize<'de> for FlushRequest {
5238 #[allow(deprecated)]
5239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5240 where
5241 D: serde::Deserializer<'de>,
5242 {
5243 const FIELDS: &[&str] = &[
5244 "database_id",
5245 "databaseId",
5246 ];
5247
5248 #[allow(clippy::enum_variant_names)]
5249 enum GeneratedField {
5250 DatabaseId,
5251 }
5252 impl<'de> serde::Deserialize<'de> for GeneratedField {
5253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5254 where
5255 D: serde::Deserializer<'de>,
5256 {
5257 struct GeneratedVisitor;
5258
5259 impl serde::de::Visitor<'_> for GeneratedVisitor {
5260 type Value = GeneratedField;
5261
5262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5263 write!(formatter, "expected one of: {:?}", &FIELDS)
5264 }
5265
5266 #[allow(unused_variables)]
5267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5268 where
5269 E: serde::de::Error,
5270 {
5271 match value {
5272 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5273 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5274 }
5275 }
5276 }
5277 deserializer.deserialize_identifier(GeneratedVisitor)
5278 }
5279 }
5280 struct GeneratedVisitor;
5281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5282 type Value = FlushRequest;
5283
5284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5285 formatter.write_str("struct meta.FlushRequest")
5286 }
5287
5288 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5289 where
5290 V: serde::de::MapAccess<'de>,
5291 {
5292 let mut database_id__ = None;
5293 while let Some(k) = map_.next_key()? {
5294 match k {
5295 GeneratedField::DatabaseId => {
5296 if database_id__.is_some() {
5297 return Err(serde::de::Error::duplicate_field("databaseId"));
5298 }
5299 database_id__ =
5300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5301 ;
5302 }
5303 }
5304 }
5305 Ok(FlushRequest {
5306 database_id: database_id__.unwrap_or_default(),
5307 })
5308 }
5309 }
5310 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5311 }
5312}
5313impl serde::Serialize for FlushResponse {
5314 #[allow(deprecated)]
5315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5316 where
5317 S: serde::Serializer,
5318 {
5319 use serde::ser::SerializeStruct;
5320 let mut len = 0;
5321 if self.status.is_some() {
5322 len += 1;
5323 }
5324 if self.hummock_version_id != 0 {
5325 len += 1;
5326 }
5327 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5328 if let Some(v) = self.status.as_ref() {
5329 struct_ser.serialize_field("status", v)?;
5330 }
5331 if self.hummock_version_id != 0 {
5332 #[allow(clippy::needless_borrow)]
5333 #[allow(clippy::needless_borrows_for_generic_args)]
5334 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5335 }
5336 struct_ser.end()
5337 }
5338}
5339impl<'de> serde::Deserialize<'de> for FlushResponse {
5340 #[allow(deprecated)]
5341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5342 where
5343 D: serde::Deserializer<'de>,
5344 {
5345 const FIELDS: &[&str] = &[
5346 "status",
5347 "hummock_version_id",
5348 "hummockVersionId",
5349 ];
5350
5351 #[allow(clippy::enum_variant_names)]
5352 enum GeneratedField {
5353 Status,
5354 HummockVersionId,
5355 }
5356 impl<'de> serde::Deserialize<'de> for GeneratedField {
5357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5358 where
5359 D: serde::Deserializer<'de>,
5360 {
5361 struct GeneratedVisitor;
5362
5363 impl serde::de::Visitor<'_> for GeneratedVisitor {
5364 type Value = GeneratedField;
5365
5366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5367 write!(formatter, "expected one of: {:?}", &FIELDS)
5368 }
5369
5370 #[allow(unused_variables)]
5371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5372 where
5373 E: serde::de::Error,
5374 {
5375 match value {
5376 "status" => Ok(GeneratedField::Status),
5377 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5379 }
5380 }
5381 }
5382 deserializer.deserialize_identifier(GeneratedVisitor)
5383 }
5384 }
5385 struct GeneratedVisitor;
5386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5387 type Value = FlushResponse;
5388
5389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5390 formatter.write_str("struct meta.FlushResponse")
5391 }
5392
5393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5394 where
5395 V: serde::de::MapAccess<'de>,
5396 {
5397 let mut status__ = None;
5398 let mut hummock_version_id__ = None;
5399 while let Some(k) = map_.next_key()? {
5400 match k {
5401 GeneratedField::Status => {
5402 if status__.is_some() {
5403 return Err(serde::de::Error::duplicate_field("status"));
5404 }
5405 status__ = map_.next_value()?;
5406 }
5407 GeneratedField::HummockVersionId => {
5408 if hummock_version_id__.is_some() {
5409 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5410 }
5411 hummock_version_id__ =
5412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5413 ;
5414 }
5415 }
5416 }
5417 Ok(FlushResponse {
5418 status: status__,
5419 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5420 })
5421 }
5422 }
5423 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5424 }
5425}
5426impl serde::Serialize for FragmentDistribution {
5427 #[allow(deprecated)]
5428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5429 where
5430 S: serde::Serializer,
5431 {
5432 use serde::ser::SerializeStruct;
5433 let mut len = 0;
5434 if self.fragment_id != 0 {
5435 len += 1;
5436 }
5437 if self.table_id != 0 {
5438 len += 1;
5439 }
5440 if self.distribution_type != 0 {
5441 len += 1;
5442 }
5443 if !self.state_table_ids.is_empty() {
5444 len += 1;
5445 }
5446 if !self.upstream_fragment_ids.is_empty() {
5447 len += 1;
5448 }
5449 if self.fragment_type_mask != 0 {
5450 len += 1;
5451 }
5452 if self.parallelism != 0 {
5453 len += 1;
5454 }
5455 if self.vnode_count != 0 {
5456 len += 1;
5457 }
5458 if self.node.is_some() {
5459 len += 1;
5460 }
5461 if !self.parallelism_policy.is_empty() {
5462 len += 1;
5463 }
5464 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5465 if self.fragment_id != 0 {
5466 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5467 }
5468 if self.table_id != 0 {
5469 struct_ser.serialize_field("tableId", &self.table_id)?;
5470 }
5471 if self.distribution_type != 0 {
5472 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5473 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5474 struct_ser.serialize_field("distributionType", &v)?;
5475 }
5476 if !self.state_table_ids.is_empty() {
5477 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5478 }
5479 if !self.upstream_fragment_ids.is_empty() {
5480 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5481 }
5482 if self.fragment_type_mask != 0 {
5483 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5484 }
5485 if self.parallelism != 0 {
5486 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5487 }
5488 if self.vnode_count != 0 {
5489 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5490 }
5491 if let Some(v) = self.node.as_ref() {
5492 struct_ser.serialize_field("node", v)?;
5493 }
5494 if !self.parallelism_policy.is_empty() {
5495 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5496 }
5497 struct_ser.end()
5498 }
5499}
5500impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5501 #[allow(deprecated)]
5502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5503 where
5504 D: serde::Deserializer<'de>,
5505 {
5506 const FIELDS: &[&str] = &[
5507 "fragment_id",
5508 "fragmentId",
5509 "table_id",
5510 "tableId",
5511 "distribution_type",
5512 "distributionType",
5513 "state_table_ids",
5514 "stateTableIds",
5515 "upstream_fragment_ids",
5516 "upstreamFragmentIds",
5517 "fragment_type_mask",
5518 "fragmentTypeMask",
5519 "parallelism",
5520 "vnode_count",
5521 "vnodeCount",
5522 "node",
5523 "parallelism_policy",
5524 "parallelismPolicy",
5525 ];
5526
5527 #[allow(clippy::enum_variant_names)]
5528 enum GeneratedField {
5529 FragmentId,
5530 TableId,
5531 DistributionType,
5532 StateTableIds,
5533 UpstreamFragmentIds,
5534 FragmentTypeMask,
5535 Parallelism,
5536 VnodeCount,
5537 Node,
5538 ParallelismPolicy,
5539 }
5540 impl<'de> serde::Deserialize<'de> for GeneratedField {
5541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5542 where
5543 D: serde::Deserializer<'de>,
5544 {
5545 struct GeneratedVisitor;
5546
5547 impl serde::de::Visitor<'_> for GeneratedVisitor {
5548 type Value = GeneratedField;
5549
5550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5551 write!(formatter, "expected one of: {:?}", &FIELDS)
5552 }
5553
5554 #[allow(unused_variables)]
5555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5556 where
5557 E: serde::de::Error,
5558 {
5559 match value {
5560 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5561 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5562 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5563 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5564 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5565 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5566 "parallelism" => Ok(GeneratedField::Parallelism),
5567 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5568 "node" => Ok(GeneratedField::Node),
5569 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5570 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5571 }
5572 }
5573 }
5574 deserializer.deserialize_identifier(GeneratedVisitor)
5575 }
5576 }
5577 struct GeneratedVisitor;
5578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5579 type Value = FragmentDistribution;
5580
5581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5582 formatter.write_str("struct meta.FragmentDistribution")
5583 }
5584
5585 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5586 where
5587 V: serde::de::MapAccess<'de>,
5588 {
5589 let mut fragment_id__ = None;
5590 let mut table_id__ = None;
5591 let mut distribution_type__ = None;
5592 let mut state_table_ids__ = None;
5593 let mut upstream_fragment_ids__ = None;
5594 let mut fragment_type_mask__ = None;
5595 let mut parallelism__ = None;
5596 let mut vnode_count__ = None;
5597 let mut node__ = None;
5598 let mut parallelism_policy__ = None;
5599 while let Some(k) = map_.next_key()? {
5600 match k {
5601 GeneratedField::FragmentId => {
5602 if fragment_id__.is_some() {
5603 return Err(serde::de::Error::duplicate_field("fragmentId"));
5604 }
5605 fragment_id__ =
5606 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5607 ;
5608 }
5609 GeneratedField::TableId => {
5610 if table_id__.is_some() {
5611 return Err(serde::de::Error::duplicate_field("tableId"));
5612 }
5613 table_id__ =
5614 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5615 ;
5616 }
5617 GeneratedField::DistributionType => {
5618 if distribution_type__.is_some() {
5619 return Err(serde::de::Error::duplicate_field("distributionType"));
5620 }
5621 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5622 }
5623 GeneratedField::StateTableIds => {
5624 if state_table_ids__.is_some() {
5625 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5626 }
5627 state_table_ids__ =
5628 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5629 .into_iter().map(|x| x.0).collect())
5630 ;
5631 }
5632 GeneratedField::UpstreamFragmentIds => {
5633 if upstream_fragment_ids__.is_some() {
5634 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5635 }
5636 upstream_fragment_ids__ =
5637 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5638 .into_iter().map(|x| x.0).collect())
5639 ;
5640 }
5641 GeneratedField::FragmentTypeMask => {
5642 if fragment_type_mask__.is_some() {
5643 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5644 }
5645 fragment_type_mask__ =
5646 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5647 ;
5648 }
5649 GeneratedField::Parallelism => {
5650 if parallelism__.is_some() {
5651 return Err(serde::de::Error::duplicate_field("parallelism"));
5652 }
5653 parallelism__ =
5654 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5655 ;
5656 }
5657 GeneratedField::VnodeCount => {
5658 if vnode_count__.is_some() {
5659 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5660 }
5661 vnode_count__ =
5662 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5663 ;
5664 }
5665 GeneratedField::Node => {
5666 if node__.is_some() {
5667 return Err(serde::de::Error::duplicate_field("node"));
5668 }
5669 node__ = map_.next_value()?;
5670 }
5671 GeneratedField::ParallelismPolicy => {
5672 if parallelism_policy__.is_some() {
5673 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5674 }
5675 parallelism_policy__ = Some(map_.next_value()?);
5676 }
5677 }
5678 }
5679 Ok(FragmentDistribution {
5680 fragment_id: fragment_id__.unwrap_or_default(),
5681 table_id: table_id__.unwrap_or_default(),
5682 distribution_type: distribution_type__.unwrap_or_default(),
5683 state_table_ids: state_table_ids__.unwrap_or_default(),
5684 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5685 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5686 parallelism: parallelism__.unwrap_or_default(),
5687 vnode_count: vnode_count__.unwrap_or_default(),
5688 node: node__,
5689 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5690 })
5691 }
5692 }
5693 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5694 }
5695}
5696impl serde::Serialize for FragmentIdToActorIdMap {
5697 #[allow(deprecated)]
5698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5699 where
5700 S: serde::Serializer,
5701 {
5702 use serde::ser::SerializeStruct;
5703 let mut len = 0;
5704 if !self.map.is_empty() {
5705 len += 1;
5706 }
5707 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5708 if !self.map.is_empty() {
5709 struct_ser.serialize_field("map", &self.map)?;
5710 }
5711 struct_ser.end()
5712 }
5713}
5714impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5715 #[allow(deprecated)]
5716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5717 where
5718 D: serde::Deserializer<'de>,
5719 {
5720 const FIELDS: &[&str] = &[
5721 "map",
5722 ];
5723
5724 #[allow(clippy::enum_variant_names)]
5725 enum GeneratedField {
5726 Map,
5727 }
5728 impl<'de> serde::Deserialize<'de> for GeneratedField {
5729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5730 where
5731 D: serde::Deserializer<'de>,
5732 {
5733 struct GeneratedVisitor;
5734
5735 impl serde::de::Visitor<'_> for GeneratedVisitor {
5736 type Value = GeneratedField;
5737
5738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5739 write!(formatter, "expected one of: {:?}", &FIELDS)
5740 }
5741
5742 #[allow(unused_variables)]
5743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5744 where
5745 E: serde::de::Error,
5746 {
5747 match value {
5748 "map" => Ok(GeneratedField::Map),
5749 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5750 }
5751 }
5752 }
5753 deserializer.deserialize_identifier(GeneratedVisitor)
5754 }
5755 }
5756 struct GeneratedVisitor;
5757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5758 type Value = FragmentIdToActorIdMap;
5759
5760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5761 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5762 }
5763
5764 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5765 where
5766 V: serde::de::MapAccess<'de>,
5767 {
5768 let mut map__ = None;
5769 while let Some(k) = map_.next_key()? {
5770 match k {
5771 GeneratedField::Map => {
5772 if map__.is_some() {
5773 return Err(serde::de::Error::duplicate_field("map"));
5774 }
5775 map__ = Some(
5776 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5777 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5778 );
5779 }
5780 }
5781 }
5782 Ok(FragmentIdToActorIdMap {
5783 map: map__.unwrap_or_default(),
5784 })
5785 }
5786 }
5787 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5788 }
5789}
5790impl serde::Serialize for FragmentToRelationMap {
5791 #[allow(deprecated)]
5792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5793 where
5794 S: serde::Serializer,
5795 {
5796 use serde::ser::SerializeStruct;
5797 let mut len = 0;
5798 if !self.fragment_to_relation_map.is_empty() {
5799 len += 1;
5800 }
5801 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5802 if !self.fragment_to_relation_map.is_empty() {
5803 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5804 }
5805 struct_ser.end()
5806 }
5807}
5808impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5809 #[allow(deprecated)]
5810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5811 where
5812 D: serde::Deserializer<'de>,
5813 {
5814 const FIELDS: &[&str] = &[
5815 "fragment_to_relation_map",
5816 "fragmentToRelationMap",
5817 ];
5818
5819 #[allow(clippy::enum_variant_names)]
5820 enum GeneratedField {
5821 FragmentToRelationMap,
5822 }
5823 impl<'de> serde::Deserialize<'de> for GeneratedField {
5824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5825 where
5826 D: serde::Deserializer<'de>,
5827 {
5828 struct GeneratedVisitor;
5829
5830 impl serde::de::Visitor<'_> for GeneratedVisitor {
5831 type Value = GeneratedField;
5832
5833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5834 write!(formatter, "expected one of: {:?}", &FIELDS)
5835 }
5836
5837 #[allow(unused_variables)]
5838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5839 where
5840 E: serde::de::Error,
5841 {
5842 match value {
5843 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5844 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5845 }
5846 }
5847 }
5848 deserializer.deserialize_identifier(GeneratedVisitor)
5849 }
5850 }
5851 struct GeneratedVisitor;
5852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5853 type Value = FragmentToRelationMap;
5854
5855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5856 formatter.write_str("struct meta.FragmentToRelationMap")
5857 }
5858
5859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5860 where
5861 V: serde::de::MapAccess<'de>,
5862 {
5863 let mut fragment_to_relation_map__ = None;
5864 while let Some(k) = map_.next_key()? {
5865 match k {
5866 GeneratedField::FragmentToRelationMap => {
5867 if fragment_to_relation_map__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5869 }
5870 fragment_to_relation_map__ = Some(
5871 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5872 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
5873 );
5874 }
5875 }
5876 }
5877 Ok(FragmentToRelationMap {
5878 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5879 })
5880 }
5881 }
5882 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5883 }
5884}
5885impl serde::Serialize for FragmentWorkerSlotMapping {
5886 #[allow(deprecated)]
5887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5888 where
5889 S: serde::Serializer,
5890 {
5891 use serde::ser::SerializeStruct;
5892 let mut len = 0;
5893 if self.fragment_id != 0 {
5894 len += 1;
5895 }
5896 if self.mapping.is_some() {
5897 len += 1;
5898 }
5899 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5900 if self.fragment_id != 0 {
5901 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5902 }
5903 if let Some(v) = self.mapping.as_ref() {
5904 struct_ser.serialize_field("mapping", v)?;
5905 }
5906 struct_ser.end()
5907 }
5908}
5909impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5910 #[allow(deprecated)]
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 const FIELDS: &[&str] = &[
5916 "fragment_id",
5917 "fragmentId",
5918 "mapping",
5919 ];
5920
5921 #[allow(clippy::enum_variant_names)]
5922 enum GeneratedField {
5923 FragmentId,
5924 Mapping,
5925 }
5926 impl<'de> serde::Deserialize<'de> for GeneratedField {
5927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5928 where
5929 D: serde::Deserializer<'de>,
5930 {
5931 struct GeneratedVisitor;
5932
5933 impl serde::de::Visitor<'_> for GeneratedVisitor {
5934 type Value = GeneratedField;
5935
5936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5937 write!(formatter, "expected one of: {:?}", &FIELDS)
5938 }
5939
5940 #[allow(unused_variables)]
5941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5942 where
5943 E: serde::de::Error,
5944 {
5945 match value {
5946 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5947 "mapping" => Ok(GeneratedField::Mapping),
5948 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5949 }
5950 }
5951 }
5952 deserializer.deserialize_identifier(GeneratedVisitor)
5953 }
5954 }
5955 struct GeneratedVisitor;
5956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5957 type Value = FragmentWorkerSlotMapping;
5958
5959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5960 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5961 }
5962
5963 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5964 where
5965 V: serde::de::MapAccess<'de>,
5966 {
5967 let mut fragment_id__ = None;
5968 let mut mapping__ = None;
5969 while let Some(k) = map_.next_key()? {
5970 match k {
5971 GeneratedField::FragmentId => {
5972 if fragment_id__.is_some() {
5973 return Err(serde::de::Error::duplicate_field("fragmentId"));
5974 }
5975 fragment_id__ =
5976 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5977 ;
5978 }
5979 GeneratedField::Mapping => {
5980 if mapping__.is_some() {
5981 return Err(serde::de::Error::duplicate_field("mapping"));
5982 }
5983 mapping__ = map_.next_value()?;
5984 }
5985 }
5986 }
5987 Ok(FragmentWorkerSlotMapping {
5988 fragment_id: fragment_id__.unwrap_or_default(),
5989 mapping: mapping__,
5990 })
5991 }
5992 }
5993 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5994 }
5995}
5996impl serde::Serialize for FragmentWorkerSlotMappings {
5997 #[allow(deprecated)]
5998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5999 where
6000 S: serde::Serializer,
6001 {
6002 use serde::ser::SerializeStruct;
6003 let mut len = 0;
6004 if !self.mappings.is_empty() {
6005 len += 1;
6006 }
6007 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
6008 if !self.mappings.is_empty() {
6009 struct_ser.serialize_field("mappings", &self.mappings)?;
6010 }
6011 struct_ser.end()
6012 }
6013}
6014impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
6015 #[allow(deprecated)]
6016 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6017 where
6018 D: serde::Deserializer<'de>,
6019 {
6020 const FIELDS: &[&str] = &[
6021 "mappings",
6022 ];
6023
6024 #[allow(clippy::enum_variant_names)]
6025 enum GeneratedField {
6026 Mappings,
6027 }
6028 impl<'de> serde::Deserialize<'de> for GeneratedField {
6029 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6030 where
6031 D: serde::Deserializer<'de>,
6032 {
6033 struct GeneratedVisitor;
6034
6035 impl serde::de::Visitor<'_> for GeneratedVisitor {
6036 type Value = GeneratedField;
6037
6038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6039 write!(formatter, "expected one of: {:?}", &FIELDS)
6040 }
6041
6042 #[allow(unused_variables)]
6043 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6044 where
6045 E: serde::de::Error,
6046 {
6047 match value {
6048 "mappings" => Ok(GeneratedField::Mappings),
6049 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6050 }
6051 }
6052 }
6053 deserializer.deserialize_identifier(GeneratedVisitor)
6054 }
6055 }
6056 struct GeneratedVisitor;
6057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6058 type Value = FragmentWorkerSlotMappings;
6059
6060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6061 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
6062 }
6063
6064 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
6065 where
6066 V: serde::de::MapAccess<'de>,
6067 {
6068 let mut mappings__ = None;
6069 while let Some(k) = map_.next_key()? {
6070 match k {
6071 GeneratedField::Mappings => {
6072 if mappings__.is_some() {
6073 return Err(serde::de::Error::duplicate_field("mappings"));
6074 }
6075 mappings__ = Some(map_.next_value()?);
6076 }
6077 }
6078 }
6079 Ok(FragmentWorkerSlotMappings {
6080 mappings: mappings__.unwrap_or_default(),
6081 })
6082 }
6083 }
6084 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
6085 }
6086}
6087impl serde::Serialize for GetActorVnodesRequest {
6088 #[allow(deprecated)]
6089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6090 where
6091 S: serde::Serializer,
6092 {
6093 use serde::ser::SerializeStruct;
6094 let mut len = 0;
6095 if self.actor_id != 0 {
6096 len += 1;
6097 }
6098 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
6099 if self.actor_id != 0 {
6100 struct_ser.serialize_field("actorId", &self.actor_id)?;
6101 }
6102 struct_ser.end()
6103 }
6104}
6105impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
6106 #[allow(deprecated)]
6107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6108 where
6109 D: serde::Deserializer<'de>,
6110 {
6111 const FIELDS: &[&str] = &[
6112 "actor_id",
6113 "actorId",
6114 ];
6115
6116 #[allow(clippy::enum_variant_names)]
6117 enum GeneratedField {
6118 ActorId,
6119 }
6120 impl<'de> serde::Deserialize<'de> for GeneratedField {
6121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6122 where
6123 D: serde::Deserializer<'de>,
6124 {
6125 struct GeneratedVisitor;
6126
6127 impl serde::de::Visitor<'_> for GeneratedVisitor {
6128 type Value = GeneratedField;
6129
6130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6131 write!(formatter, "expected one of: {:?}", &FIELDS)
6132 }
6133
6134 #[allow(unused_variables)]
6135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6136 where
6137 E: serde::de::Error,
6138 {
6139 match value {
6140 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
6141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6142 }
6143 }
6144 }
6145 deserializer.deserialize_identifier(GeneratedVisitor)
6146 }
6147 }
6148 struct GeneratedVisitor;
6149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6150 type Value = GetActorVnodesRequest;
6151
6152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6153 formatter.write_str("struct meta.GetActorVnodesRequest")
6154 }
6155
6156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
6157 where
6158 V: serde::de::MapAccess<'de>,
6159 {
6160 let mut actor_id__ = None;
6161 while let Some(k) = map_.next_key()? {
6162 match k {
6163 GeneratedField::ActorId => {
6164 if actor_id__.is_some() {
6165 return Err(serde::de::Error::duplicate_field("actorId"));
6166 }
6167 actor_id__ =
6168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6169 ;
6170 }
6171 }
6172 }
6173 Ok(GetActorVnodesRequest {
6174 actor_id: actor_id__.unwrap_or_default(),
6175 })
6176 }
6177 }
6178 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
6179 }
6180}
6181impl serde::Serialize for GetActorVnodesResponse {
6182 #[allow(deprecated)]
6183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6184 where
6185 S: serde::Serializer,
6186 {
6187 use serde::ser::SerializeStruct;
6188 let mut len = 0;
6189 if !self.vnode_indices.is_empty() {
6190 len += 1;
6191 }
6192 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
6193 if !self.vnode_indices.is_empty() {
6194 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6195 }
6196 struct_ser.end()
6197 }
6198}
6199impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
6200 #[allow(deprecated)]
6201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6202 where
6203 D: serde::Deserializer<'de>,
6204 {
6205 const FIELDS: &[&str] = &[
6206 "vnode_indices",
6207 "vnodeIndices",
6208 ];
6209
6210 #[allow(clippy::enum_variant_names)]
6211 enum GeneratedField {
6212 VnodeIndices,
6213 }
6214 impl<'de> serde::Deserialize<'de> for GeneratedField {
6215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6216 where
6217 D: serde::Deserializer<'de>,
6218 {
6219 struct GeneratedVisitor;
6220
6221 impl serde::de::Visitor<'_> for GeneratedVisitor {
6222 type Value = GeneratedField;
6223
6224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6225 write!(formatter, "expected one of: {:?}", &FIELDS)
6226 }
6227
6228 #[allow(unused_variables)]
6229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6230 where
6231 E: serde::de::Error,
6232 {
6233 match value {
6234 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
6235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6236 }
6237 }
6238 }
6239 deserializer.deserialize_identifier(GeneratedVisitor)
6240 }
6241 }
6242 struct GeneratedVisitor;
6243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6244 type Value = GetActorVnodesResponse;
6245
6246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6247 formatter.write_str("struct meta.GetActorVnodesResponse")
6248 }
6249
6250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
6251 where
6252 V: serde::de::MapAccess<'de>,
6253 {
6254 let mut vnode_indices__ = None;
6255 while let Some(k) = map_.next_key()? {
6256 match k {
6257 GeneratedField::VnodeIndices => {
6258 if vnode_indices__.is_some() {
6259 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
6260 }
6261 vnode_indices__ =
6262 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6263 .into_iter().map(|x| x.0).collect())
6264 ;
6265 }
6266 }
6267 }
6268 Ok(GetActorVnodesResponse {
6269 vnode_indices: vnode_indices__.unwrap_or_default(),
6270 })
6271 }
6272 }
6273 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6274 }
6275}
6276impl serde::Serialize for GetClusterInfoRequest {
6277 #[allow(deprecated)]
6278 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6279 where
6280 S: serde::Serializer,
6281 {
6282 use serde::ser::SerializeStruct;
6283 let len = 0;
6284 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6285 struct_ser.end()
6286 }
6287}
6288impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6289 #[allow(deprecated)]
6290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6291 where
6292 D: serde::Deserializer<'de>,
6293 {
6294 const FIELDS: &[&str] = &[
6295 ];
6296
6297 #[allow(clippy::enum_variant_names)]
6298 enum GeneratedField {
6299 }
6300 impl<'de> serde::Deserialize<'de> for GeneratedField {
6301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6302 where
6303 D: serde::Deserializer<'de>,
6304 {
6305 struct GeneratedVisitor;
6306
6307 impl serde::de::Visitor<'_> for GeneratedVisitor {
6308 type Value = GeneratedField;
6309
6310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6311 write!(formatter, "expected one of: {:?}", &FIELDS)
6312 }
6313
6314 #[allow(unused_variables)]
6315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6316 where
6317 E: serde::de::Error,
6318 {
6319 Err(serde::de::Error::unknown_field(value, FIELDS))
6320 }
6321 }
6322 deserializer.deserialize_identifier(GeneratedVisitor)
6323 }
6324 }
6325 struct GeneratedVisitor;
6326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6327 type Value = GetClusterInfoRequest;
6328
6329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6330 formatter.write_str("struct meta.GetClusterInfoRequest")
6331 }
6332
6333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6334 where
6335 V: serde::de::MapAccess<'de>,
6336 {
6337 while map_.next_key::<GeneratedField>()?.is_some() {
6338 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6339 }
6340 Ok(GetClusterInfoRequest {
6341 })
6342 }
6343 }
6344 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6345 }
6346}
6347impl serde::Serialize for GetClusterInfoResponse {
6348 #[allow(deprecated)]
6349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6350 where
6351 S: serde::Serializer,
6352 {
6353 use serde::ser::SerializeStruct;
6354 let mut len = 0;
6355 if !self.worker_nodes.is_empty() {
6356 len += 1;
6357 }
6358 if !self.table_fragments.is_empty() {
6359 len += 1;
6360 }
6361 if !self.actor_splits.is_empty() {
6362 len += 1;
6363 }
6364 if !self.source_infos.is_empty() {
6365 len += 1;
6366 }
6367 if self.revision != 0 {
6368 len += 1;
6369 }
6370 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6371 if !self.worker_nodes.is_empty() {
6372 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6373 }
6374 if !self.table_fragments.is_empty() {
6375 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6376 }
6377 if !self.actor_splits.is_empty() {
6378 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6379 }
6380 if !self.source_infos.is_empty() {
6381 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6382 }
6383 if self.revision != 0 {
6384 #[allow(clippy::needless_borrow)]
6385 #[allow(clippy::needless_borrows_for_generic_args)]
6386 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6387 }
6388 struct_ser.end()
6389 }
6390}
6391impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6392 #[allow(deprecated)]
6393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6394 where
6395 D: serde::Deserializer<'de>,
6396 {
6397 const FIELDS: &[&str] = &[
6398 "worker_nodes",
6399 "workerNodes",
6400 "table_fragments",
6401 "tableFragments",
6402 "actor_splits",
6403 "actorSplits",
6404 "source_infos",
6405 "sourceInfos",
6406 "revision",
6407 ];
6408
6409 #[allow(clippy::enum_variant_names)]
6410 enum GeneratedField {
6411 WorkerNodes,
6412 TableFragments,
6413 ActorSplits,
6414 SourceInfos,
6415 Revision,
6416 }
6417 impl<'de> serde::Deserialize<'de> for GeneratedField {
6418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6419 where
6420 D: serde::Deserializer<'de>,
6421 {
6422 struct GeneratedVisitor;
6423
6424 impl serde::de::Visitor<'_> for GeneratedVisitor {
6425 type Value = GeneratedField;
6426
6427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6428 write!(formatter, "expected one of: {:?}", &FIELDS)
6429 }
6430
6431 #[allow(unused_variables)]
6432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6433 where
6434 E: serde::de::Error,
6435 {
6436 match value {
6437 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6438 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6439 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6440 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6441 "revision" => Ok(GeneratedField::Revision),
6442 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6443 }
6444 }
6445 }
6446 deserializer.deserialize_identifier(GeneratedVisitor)
6447 }
6448 }
6449 struct GeneratedVisitor;
6450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6451 type Value = GetClusterInfoResponse;
6452
6453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6454 formatter.write_str("struct meta.GetClusterInfoResponse")
6455 }
6456
6457 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6458 where
6459 V: serde::de::MapAccess<'de>,
6460 {
6461 let mut worker_nodes__ = None;
6462 let mut table_fragments__ = None;
6463 let mut actor_splits__ = None;
6464 let mut source_infos__ = None;
6465 let mut revision__ = None;
6466 while let Some(k) = map_.next_key()? {
6467 match k {
6468 GeneratedField::WorkerNodes => {
6469 if worker_nodes__.is_some() {
6470 return Err(serde::de::Error::duplicate_field("workerNodes"));
6471 }
6472 worker_nodes__ = Some(map_.next_value()?);
6473 }
6474 GeneratedField::TableFragments => {
6475 if table_fragments__.is_some() {
6476 return Err(serde::de::Error::duplicate_field("tableFragments"));
6477 }
6478 table_fragments__ = Some(map_.next_value()?);
6479 }
6480 GeneratedField::ActorSplits => {
6481 if actor_splits__.is_some() {
6482 return Err(serde::de::Error::duplicate_field("actorSplits"));
6483 }
6484 actor_splits__ = Some(
6485 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6486 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6487 );
6488 }
6489 GeneratedField::SourceInfos => {
6490 if source_infos__.is_some() {
6491 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6492 }
6493 source_infos__ = Some(
6494 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6495 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6496 );
6497 }
6498 GeneratedField::Revision => {
6499 if revision__.is_some() {
6500 return Err(serde::de::Error::duplicate_field("revision"));
6501 }
6502 revision__ =
6503 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6504 ;
6505 }
6506 }
6507 }
6508 Ok(GetClusterInfoResponse {
6509 worker_nodes: worker_nodes__.unwrap_or_default(),
6510 table_fragments: table_fragments__.unwrap_or_default(),
6511 actor_splits: actor_splits__.unwrap_or_default(),
6512 source_infos: source_infos__.unwrap_or_default(),
6513 revision: revision__.unwrap_or_default(),
6514 })
6515 }
6516 }
6517 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6518 }
6519}
6520impl serde::Serialize for GetClusterLimitsRequest {
6521 #[allow(deprecated)]
6522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6523 where
6524 S: serde::Serializer,
6525 {
6526 use serde::ser::SerializeStruct;
6527 let len = 0;
6528 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6529 struct_ser.end()
6530 }
6531}
6532impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6533 #[allow(deprecated)]
6534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6535 where
6536 D: serde::Deserializer<'de>,
6537 {
6538 const FIELDS: &[&str] = &[
6539 ];
6540
6541 #[allow(clippy::enum_variant_names)]
6542 enum GeneratedField {
6543 }
6544 impl<'de> serde::Deserialize<'de> for GeneratedField {
6545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6546 where
6547 D: serde::Deserializer<'de>,
6548 {
6549 struct GeneratedVisitor;
6550
6551 impl serde::de::Visitor<'_> for GeneratedVisitor {
6552 type Value = GeneratedField;
6553
6554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6555 write!(formatter, "expected one of: {:?}", &FIELDS)
6556 }
6557
6558 #[allow(unused_variables)]
6559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6560 where
6561 E: serde::de::Error,
6562 {
6563 Err(serde::de::Error::unknown_field(value, FIELDS))
6564 }
6565 }
6566 deserializer.deserialize_identifier(GeneratedVisitor)
6567 }
6568 }
6569 struct GeneratedVisitor;
6570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6571 type Value = GetClusterLimitsRequest;
6572
6573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6574 formatter.write_str("struct meta.GetClusterLimitsRequest")
6575 }
6576
6577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6578 where
6579 V: serde::de::MapAccess<'de>,
6580 {
6581 while map_.next_key::<GeneratedField>()?.is_some() {
6582 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6583 }
6584 Ok(GetClusterLimitsRequest {
6585 })
6586 }
6587 }
6588 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6589 }
6590}
6591impl serde::Serialize for GetClusterLimitsResponse {
6592 #[allow(deprecated)]
6593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6594 where
6595 S: serde::Serializer,
6596 {
6597 use serde::ser::SerializeStruct;
6598 let mut len = 0;
6599 if !self.active_limits.is_empty() {
6600 len += 1;
6601 }
6602 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6603 if !self.active_limits.is_empty() {
6604 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6605 }
6606 struct_ser.end()
6607 }
6608}
6609impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6610 #[allow(deprecated)]
6611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6612 where
6613 D: serde::Deserializer<'de>,
6614 {
6615 const FIELDS: &[&str] = &[
6616 "active_limits",
6617 "activeLimits",
6618 ];
6619
6620 #[allow(clippy::enum_variant_names)]
6621 enum GeneratedField {
6622 ActiveLimits,
6623 }
6624 impl<'de> serde::Deserialize<'de> for GeneratedField {
6625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6626 where
6627 D: serde::Deserializer<'de>,
6628 {
6629 struct GeneratedVisitor;
6630
6631 impl serde::de::Visitor<'_> for GeneratedVisitor {
6632 type Value = GeneratedField;
6633
6634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6635 write!(formatter, "expected one of: {:?}", &FIELDS)
6636 }
6637
6638 #[allow(unused_variables)]
6639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6640 where
6641 E: serde::de::Error,
6642 {
6643 match value {
6644 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6646 }
6647 }
6648 }
6649 deserializer.deserialize_identifier(GeneratedVisitor)
6650 }
6651 }
6652 struct GeneratedVisitor;
6653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6654 type Value = GetClusterLimitsResponse;
6655
6656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6657 formatter.write_str("struct meta.GetClusterLimitsResponse")
6658 }
6659
6660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6661 where
6662 V: serde::de::MapAccess<'de>,
6663 {
6664 let mut active_limits__ = None;
6665 while let Some(k) = map_.next_key()? {
6666 match k {
6667 GeneratedField::ActiveLimits => {
6668 if active_limits__.is_some() {
6669 return Err(serde::de::Error::duplicate_field("activeLimits"));
6670 }
6671 active_limits__ = Some(map_.next_value()?);
6672 }
6673 }
6674 }
6675 Ok(GetClusterLimitsResponse {
6676 active_limits: active_limits__.unwrap_or_default(),
6677 })
6678 }
6679 }
6680 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6681 }
6682}
6683impl serde::Serialize for GetClusterRecoveryStatusRequest {
6684 #[allow(deprecated)]
6685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6686 where
6687 S: serde::Serializer,
6688 {
6689 use serde::ser::SerializeStruct;
6690 let len = 0;
6691 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6692 struct_ser.end()
6693 }
6694}
6695impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6696 #[allow(deprecated)]
6697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6698 where
6699 D: serde::Deserializer<'de>,
6700 {
6701 const FIELDS: &[&str] = &[
6702 ];
6703
6704 #[allow(clippy::enum_variant_names)]
6705 enum GeneratedField {
6706 }
6707 impl<'de> serde::Deserialize<'de> for GeneratedField {
6708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6709 where
6710 D: serde::Deserializer<'de>,
6711 {
6712 struct GeneratedVisitor;
6713
6714 impl serde::de::Visitor<'_> for GeneratedVisitor {
6715 type Value = GeneratedField;
6716
6717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6718 write!(formatter, "expected one of: {:?}", &FIELDS)
6719 }
6720
6721 #[allow(unused_variables)]
6722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6723 where
6724 E: serde::de::Error,
6725 {
6726 Err(serde::de::Error::unknown_field(value, FIELDS))
6727 }
6728 }
6729 deserializer.deserialize_identifier(GeneratedVisitor)
6730 }
6731 }
6732 struct GeneratedVisitor;
6733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6734 type Value = GetClusterRecoveryStatusRequest;
6735
6736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6737 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6738 }
6739
6740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6741 where
6742 V: serde::de::MapAccess<'de>,
6743 {
6744 while map_.next_key::<GeneratedField>()?.is_some() {
6745 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6746 }
6747 Ok(GetClusterRecoveryStatusRequest {
6748 })
6749 }
6750 }
6751 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6752 }
6753}
6754impl serde::Serialize for GetClusterRecoveryStatusResponse {
6755 #[allow(deprecated)]
6756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6757 where
6758 S: serde::Serializer,
6759 {
6760 use serde::ser::SerializeStruct;
6761 let mut len = 0;
6762 if self.status != 0 {
6763 len += 1;
6764 }
6765 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6766 if self.status != 0 {
6767 let v = RecoveryStatus::try_from(self.status)
6768 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6769 struct_ser.serialize_field("status", &v)?;
6770 }
6771 struct_ser.end()
6772 }
6773}
6774impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6775 #[allow(deprecated)]
6776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6777 where
6778 D: serde::Deserializer<'de>,
6779 {
6780 const FIELDS: &[&str] = &[
6781 "status",
6782 ];
6783
6784 #[allow(clippy::enum_variant_names)]
6785 enum GeneratedField {
6786 Status,
6787 }
6788 impl<'de> serde::Deserialize<'de> for GeneratedField {
6789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6790 where
6791 D: serde::Deserializer<'de>,
6792 {
6793 struct GeneratedVisitor;
6794
6795 impl serde::de::Visitor<'_> for GeneratedVisitor {
6796 type Value = GeneratedField;
6797
6798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6799 write!(formatter, "expected one of: {:?}", &FIELDS)
6800 }
6801
6802 #[allow(unused_variables)]
6803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6804 where
6805 E: serde::de::Error,
6806 {
6807 match value {
6808 "status" => Ok(GeneratedField::Status),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = GetClusterRecoveryStatusResponse;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut status__ = None;
6829 while let Some(k) = map_.next_key()? {
6830 match k {
6831 GeneratedField::Status => {
6832 if status__.is_some() {
6833 return Err(serde::de::Error::duplicate_field("status"));
6834 }
6835 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6836 }
6837 }
6838 }
6839 Ok(GetClusterRecoveryStatusResponse {
6840 status: status__.unwrap_or_default(),
6841 })
6842 }
6843 }
6844 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6845 }
6846}
6847impl serde::Serialize for GetFragmentByIdRequest {
6848 #[allow(deprecated)]
6849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6850 where
6851 S: serde::Serializer,
6852 {
6853 use serde::ser::SerializeStruct;
6854 let mut len = 0;
6855 if self.fragment_id != 0 {
6856 len += 1;
6857 }
6858 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6859 if self.fragment_id != 0 {
6860 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6861 }
6862 struct_ser.end()
6863 }
6864}
6865impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6866 #[allow(deprecated)]
6867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6868 where
6869 D: serde::Deserializer<'de>,
6870 {
6871 const FIELDS: &[&str] = &[
6872 "fragment_id",
6873 "fragmentId",
6874 ];
6875
6876 #[allow(clippy::enum_variant_names)]
6877 enum GeneratedField {
6878 FragmentId,
6879 }
6880 impl<'de> serde::Deserialize<'de> for GeneratedField {
6881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6882 where
6883 D: serde::Deserializer<'de>,
6884 {
6885 struct GeneratedVisitor;
6886
6887 impl serde::de::Visitor<'_> for GeneratedVisitor {
6888 type Value = GeneratedField;
6889
6890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6891 write!(formatter, "expected one of: {:?}", &FIELDS)
6892 }
6893
6894 #[allow(unused_variables)]
6895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6896 where
6897 E: serde::de::Error,
6898 {
6899 match value {
6900 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6902 }
6903 }
6904 }
6905 deserializer.deserialize_identifier(GeneratedVisitor)
6906 }
6907 }
6908 struct GeneratedVisitor;
6909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6910 type Value = GetFragmentByIdRequest;
6911
6912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6913 formatter.write_str("struct meta.GetFragmentByIdRequest")
6914 }
6915
6916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6917 where
6918 V: serde::de::MapAccess<'de>,
6919 {
6920 let mut fragment_id__ = None;
6921 while let Some(k) = map_.next_key()? {
6922 match k {
6923 GeneratedField::FragmentId => {
6924 if fragment_id__.is_some() {
6925 return Err(serde::de::Error::duplicate_field("fragmentId"));
6926 }
6927 fragment_id__ =
6928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6929 ;
6930 }
6931 }
6932 }
6933 Ok(GetFragmentByIdRequest {
6934 fragment_id: fragment_id__.unwrap_or_default(),
6935 })
6936 }
6937 }
6938 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6939 }
6940}
6941impl serde::Serialize for GetFragmentByIdResponse {
6942 #[allow(deprecated)]
6943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6944 where
6945 S: serde::Serializer,
6946 {
6947 use serde::ser::SerializeStruct;
6948 let mut len = 0;
6949 if self.distribution.is_some() {
6950 len += 1;
6951 }
6952 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6953 if let Some(v) = self.distribution.as_ref() {
6954 struct_ser.serialize_field("distribution", v)?;
6955 }
6956 struct_ser.end()
6957 }
6958}
6959impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6960 #[allow(deprecated)]
6961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6962 where
6963 D: serde::Deserializer<'de>,
6964 {
6965 const FIELDS: &[&str] = &[
6966 "distribution",
6967 ];
6968
6969 #[allow(clippy::enum_variant_names)]
6970 enum GeneratedField {
6971 Distribution,
6972 }
6973 impl<'de> serde::Deserialize<'de> for GeneratedField {
6974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6975 where
6976 D: serde::Deserializer<'de>,
6977 {
6978 struct GeneratedVisitor;
6979
6980 impl serde::de::Visitor<'_> for GeneratedVisitor {
6981 type Value = GeneratedField;
6982
6983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6984 write!(formatter, "expected one of: {:?}", &FIELDS)
6985 }
6986
6987 #[allow(unused_variables)]
6988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6989 where
6990 E: serde::de::Error,
6991 {
6992 match value {
6993 "distribution" => Ok(GeneratedField::Distribution),
6994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6995 }
6996 }
6997 }
6998 deserializer.deserialize_identifier(GeneratedVisitor)
6999 }
7000 }
7001 struct GeneratedVisitor;
7002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7003 type Value = GetFragmentByIdResponse;
7004
7005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7006 formatter.write_str("struct meta.GetFragmentByIdResponse")
7007 }
7008
7009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
7010 where
7011 V: serde::de::MapAccess<'de>,
7012 {
7013 let mut distribution__ = None;
7014 while let Some(k) = map_.next_key()? {
7015 match k {
7016 GeneratedField::Distribution => {
7017 if distribution__.is_some() {
7018 return Err(serde::de::Error::duplicate_field("distribution"));
7019 }
7020 distribution__ = map_.next_value()?;
7021 }
7022 }
7023 }
7024 Ok(GetFragmentByIdResponse {
7025 distribution: distribution__,
7026 })
7027 }
7028 }
7029 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
7030 }
7031}
7032impl serde::Serialize for GetFragmentVnodesRequest {
7033 #[allow(deprecated)]
7034 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7035 where
7036 S: serde::Serializer,
7037 {
7038 use serde::ser::SerializeStruct;
7039 let mut len = 0;
7040 if self.fragment_id != 0 {
7041 len += 1;
7042 }
7043 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
7044 if self.fragment_id != 0 {
7045 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7046 }
7047 struct_ser.end()
7048 }
7049}
7050impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
7051 #[allow(deprecated)]
7052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7053 where
7054 D: serde::Deserializer<'de>,
7055 {
7056 const FIELDS: &[&str] = &[
7057 "fragment_id",
7058 "fragmentId",
7059 ];
7060
7061 #[allow(clippy::enum_variant_names)]
7062 enum GeneratedField {
7063 FragmentId,
7064 }
7065 impl<'de> serde::Deserialize<'de> for GeneratedField {
7066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7067 where
7068 D: serde::Deserializer<'de>,
7069 {
7070 struct GeneratedVisitor;
7071
7072 impl serde::de::Visitor<'_> for GeneratedVisitor {
7073 type Value = GeneratedField;
7074
7075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7076 write!(formatter, "expected one of: {:?}", &FIELDS)
7077 }
7078
7079 #[allow(unused_variables)]
7080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7081 where
7082 E: serde::de::Error,
7083 {
7084 match value {
7085 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7086 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7087 }
7088 }
7089 }
7090 deserializer.deserialize_identifier(GeneratedVisitor)
7091 }
7092 }
7093 struct GeneratedVisitor;
7094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7095 type Value = GetFragmentVnodesRequest;
7096
7097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7098 formatter.write_str("struct meta.GetFragmentVnodesRequest")
7099 }
7100
7101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
7102 where
7103 V: serde::de::MapAccess<'de>,
7104 {
7105 let mut fragment_id__ = None;
7106 while let Some(k) = map_.next_key()? {
7107 match k {
7108 GeneratedField::FragmentId => {
7109 if fragment_id__.is_some() {
7110 return Err(serde::de::Error::duplicate_field("fragmentId"));
7111 }
7112 fragment_id__ =
7113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7114 ;
7115 }
7116 }
7117 }
7118 Ok(GetFragmentVnodesRequest {
7119 fragment_id: fragment_id__.unwrap_or_default(),
7120 })
7121 }
7122 }
7123 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
7124 }
7125}
7126impl serde::Serialize for GetFragmentVnodesResponse {
7127 #[allow(deprecated)]
7128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7129 where
7130 S: serde::Serializer,
7131 {
7132 use serde::ser::SerializeStruct;
7133 let mut len = 0;
7134 if !self.actor_vnodes.is_empty() {
7135 len += 1;
7136 }
7137 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
7138 if !self.actor_vnodes.is_empty() {
7139 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
7140 }
7141 struct_ser.end()
7142 }
7143}
7144impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
7145 #[allow(deprecated)]
7146 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7147 where
7148 D: serde::Deserializer<'de>,
7149 {
7150 const FIELDS: &[&str] = &[
7151 "actor_vnodes",
7152 "actorVnodes",
7153 ];
7154
7155 #[allow(clippy::enum_variant_names)]
7156 enum GeneratedField {
7157 ActorVnodes,
7158 }
7159 impl<'de> serde::Deserialize<'de> for GeneratedField {
7160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7161 where
7162 D: serde::Deserializer<'de>,
7163 {
7164 struct GeneratedVisitor;
7165
7166 impl serde::de::Visitor<'_> for GeneratedVisitor {
7167 type Value = GeneratedField;
7168
7169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7170 write!(formatter, "expected one of: {:?}", &FIELDS)
7171 }
7172
7173 #[allow(unused_variables)]
7174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7175 where
7176 E: serde::de::Error,
7177 {
7178 match value {
7179 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
7180 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7181 }
7182 }
7183 }
7184 deserializer.deserialize_identifier(GeneratedVisitor)
7185 }
7186 }
7187 struct GeneratedVisitor;
7188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7189 type Value = GetFragmentVnodesResponse;
7190
7191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7192 formatter.write_str("struct meta.GetFragmentVnodesResponse")
7193 }
7194
7195 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
7196 where
7197 V: serde::de::MapAccess<'de>,
7198 {
7199 let mut actor_vnodes__ = None;
7200 while let Some(k) = map_.next_key()? {
7201 match k {
7202 GeneratedField::ActorVnodes => {
7203 if actor_vnodes__.is_some() {
7204 return Err(serde::de::Error::duplicate_field("actorVnodes"));
7205 }
7206 actor_vnodes__ = Some(map_.next_value()?);
7207 }
7208 }
7209 }
7210 Ok(GetFragmentVnodesResponse {
7211 actor_vnodes: actor_vnodes__.unwrap_or_default(),
7212 })
7213 }
7214 }
7215 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
7216 }
7217}
7218impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
7219 #[allow(deprecated)]
7220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7221 where
7222 S: serde::Serializer,
7223 {
7224 use serde::ser::SerializeStruct;
7225 let mut len = 0;
7226 if self.actor_id != 0 {
7227 len += 1;
7228 }
7229 if !self.vnode_indices.is_empty() {
7230 len += 1;
7231 }
7232 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
7233 if self.actor_id != 0 {
7234 struct_ser.serialize_field("actorId", &self.actor_id)?;
7235 }
7236 if !self.vnode_indices.is_empty() {
7237 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
7238 }
7239 struct_ser.end()
7240 }
7241}
7242impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
7243 #[allow(deprecated)]
7244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7245 where
7246 D: serde::Deserializer<'de>,
7247 {
7248 const FIELDS: &[&str] = &[
7249 "actor_id",
7250 "actorId",
7251 "vnode_indices",
7252 "vnodeIndices",
7253 ];
7254
7255 #[allow(clippy::enum_variant_names)]
7256 enum GeneratedField {
7257 ActorId,
7258 VnodeIndices,
7259 }
7260 impl<'de> serde::Deserialize<'de> for GeneratedField {
7261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7262 where
7263 D: serde::Deserializer<'de>,
7264 {
7265 struct GeneratedVisitor;
7266
7267 impl serde::de::Visitor<'_> for GeneratedVisitor {
7268 type Value = GeneratedField;
7269
7270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7271 write!(formatter, "expected one of: {:?}", &FIELDS)
7272 }
7273
7274 #[allow(unused_variables)]
7275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7276 where
7277 E: serde::de::Error,
7278 {
7279 match value {
7280 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7281 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7283 }
7284 }
7285 }
7286 deserializer.deserialize_identifier(GeneratedVisitor)
7287 }
7288 }
7289 struct GeneratedVisitor;
7290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7291 type Value = get_fragment_vnodes_response::ActorVnodes;
7292
7293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7294 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7295 }
7296
7297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7298 where
7299 V: serde::de::MapAccess<'de>,
7300 {
7301 let mut actor_id__ = None;
7302 let mut vnode_indices__ = None;
7303 while let Some(k) = map_.next_key()? {
7304 match k {
7305 GeneratedField::ActorId => {
7306 if actor_id__.is_some() {
7307 return Err(serde::de::Error::duplicate_field("actorId"));
7308 }
7309 actor_id__ =
7310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7311 ;
7312 }
7313 GeneratedField::VnodeIndices => {
7314 if vnode_indices__.is_some() {
7315 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7316 }
7317 vnode_indices__ =
7318 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7319 .into_iter().map(|x| x.0).collect())
7320 ;
7321 }
7322 }
7323 }
7324 Ok(get_fragment_vnodes_response::ActorVnodes {
7325 actor_id: actor_id__.unwrap_or_default(),
7326 vnode_indices: vnode_indices__.unwrap_or_default(),
7327 })
7328 }
7329 }
7330 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7331 }
7332}
7333impl serde::Serialize for GetMetaStoreInfoRequest {
7334 #[allow(deprecated)]
7335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7336 where
7337 S: serde::Serializer,
7338 {
7339 use serde::ser::SerializeStruct;
7340 let len = 0;
7341 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7342 struct_ser.end()
7343 }
7344}
7345impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7346 #[allow(deprecated)]
7347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7348 where
7349 D: serde::Deserializer<'de>,
7350 {
7351 const FIELDS: &[&str] = &[
7352 ];
7353
7354 #[allow(clippy::enum_variant_names)]
7355 enum GeneratedField {
7356 }
7357 impl<'de> serde::Deserialize<'de> for GeneratedField {
7358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7359 where
7360 D: serde::Deserializer<'de>,
7361 {
7362 struct GeneratedVisitor;
7363
7364 impl serde::de::Visitor<'_> for GeneratedVisitor {
7365 type Value = GeneratedField;
7366
7367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7368 write!(formatter, "expected one of: {:?}", &FIELDS)
7369 }
7370
7371 #[allow(unused_variables)]
7372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7373 where
7374 E: serde::de::Error,
7375 {
7376 Err(serde::de::Error::unknown_field(value, FIELDS))
7377 }
7378 }
7379 deserializer.deserialize_identifier(GeneratedVisitor)
7380 }
7381 }
7382 struct GeneratedVisitor;
7383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7384 type Value = GetMetaStoreInfoRequest;
7385
7386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7387 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7388 }
7389
7390 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7391 where
7392 V: serde::de::MapAccess<'de>,
7393 {
7394 while map_.next_key::<GeneratedField>()?.is_some() {
7395 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7396 }
7397 Ok(GetMetaStoreInfoRequest {
7398 })
7399 }
7400 }
7401 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7402 }
7403}
7404impl serde::Serialize for GetMetaStoreInfoResponse {
7405 #[allow(deprecated)]
7406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7407 where
7408 S: serde::Serializer,
7409 {
7410 use serde::ser::SerializeStruct;
7411 let mut len = 0;
7412 if !self.meta_store_endpoint.is_empty() {
7413 len += 1;
7414 }
7415 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7416 if !self.meta_store_endpoint.is_empty() {
7417 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7418 }
7419 struct_ser.end()
7420 }
7421}
7422impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7423 #[allow(deprecated)]
7424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7425 where
7426 D: serde::Deserializer<'de>,
7427 {
7428 const FIELDS: &[&str] = &[
7429 "meta_store_endpoint",
7430 "metaStoreEndpoint",
7431 ];
7432
7433 #[allow(clippy::enum_variant_names)]
7434 enum GeneratedField {
7435 MetaStoreEndpoint,
7436 }
7437 impl<'de> serde::Deserialize<'de> for GeneratedField {
7438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7439 where
7440 D: serde::Deserializer<'de>,
7441 {
7442 struct GeneratedVisitor;
7443
7444 impl serde::de::Visitor<'_> for GeneratedVisitor {
7445 type Value = GeneratedField;
7446
7447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7448 write!(formatter, "expected one of: {:?}", &FIELDS)
7449 }
7450
7451 #[allow(unused_variables)]
7452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7453 where
7454 E: serde::de::Error,
7455 {
7456 match value {
7457 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7459 }
7460 }
7461 }
7462 deserializer.deserialize_identifier(GeneratedVisitor)
7463 }
7464 }
7465 struct GeneratedVisitor;
7466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7467 type Value = GetMetaStoreInfoResponse;
7468
7469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7470 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7471 }
7472
7473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7474 where
7475 V: serde::de::MapAccess<'de>,
7476 {
7477 let mut meta_store_endpoint__ = None;
7478 while let Some(k) = map_.next_key()? {
7479 match k {
7480 GeneratedField::MetaStoreEndpoint => {
7481 if meta_store_endpoint__.is_some() {
7482 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7483 }
7484 meta_store_endpoint__ = Some(map_.next_value()?);
7485 }
7486 }
7487 }
7488 Ok(GetMetaStoreInfoResponse {
7489 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7490 })
7491 }
7492 }
7493 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7494 }
7495}
7496impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7497 #[allow(deprecated)]
7498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7499 where
7500 S: serde::Serializer,
7501 {
7502 use serde::ser::SerializeStruct;
7503 let len = 0;
7504 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7505 struct_ser.end()
7506 }
7507}
7508impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
7509 #[allow(deprecated)]
7510 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7511 where
7512 D: serde::Deserializer<'de>,
7513 {
7514 const FIELDS: &[&str] = &[
7515 ];
7516
7517 #[allow(clippy::enum_variant_names)]
7518 enum GeneratedField {
7519 }
7520 impl<'de> serde::Deserialize<'de> for GeneratedField {
7521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7522 where
7523 D: serde::Deserializer<'de>,
7524 {
7525 struct GeneratedVisitor;
7526
7527 impl serde::de::Visitor<'_> for GeneratedVisitor {
7528 type Value = GeneratedField;
7529
7530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7531 write!(formatter, "expected one of: {:?}", &FIELDS)
7532 }
7533
7534 #[allow(unused_variables)]
7535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7536 where
7537 E: serde::de::Error,
7538 {
7539 Err(serde::de::Error::unknown_field(value, FIELDS))
7540 }
7541 }
7542 deserializer.deserialize_identifier(GeneratedVisitor)
7543 }
7544 }
7545 struct GeneratedVisitor;
7546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7547 type Value = GetServerlessStreamingJobsStatusRequest;
7548
7549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7550 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7551 }
7552
7553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7554 where
7555 V: serde::de::MapAccess<'de>,
7556 {
7557 while map_.next_key::<GeneratedField>()?.is_some() {
7558 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7559 }
7560 Ok(GetServerlessStreamingJobsStatusRequest {
7561 })
7562 }
7563 }
7564 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7565 }
7566}
7567impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
7568 #[allow(deprecated)]
7569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7570 where
7571 S: serde::Serializer,
7572 {
7573 use serde::ser::SerializeStruct;
7574 let mut len = 0;
7575 if !self.streaming_job_statuses.is_empty() {
7576 len += 1;
7577 }
7578 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7579 if !self.streaming_job_statuses.is_empty() {
7580 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7581 }
7582 struct_ser.end()
7583 }
7584}
7585impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7586 #[allow(deprecated)]
7587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7588 where
7589 D: serde::Deserializer<'de>,
7590 {
7591 const FIELDS: &[&str] = &[
7592 "streaming_job_statuses",
7593 "streamingJobStatuses",
7594 ];
7595
7596 #[allow(clippy::enum_variant_names)]
7597 enum GeneratedField {
7598 StreamingJobStatuses,
7599 }
7600 impl<'de> serde::Deserialize<'de> for GeneratedField {
7601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7602 where
7603 D: serde::Deserializer<'de>,
7604 {
7605 struct GeneratedVisitor;
7606
7607 impl serde::de::Visitor<'_> for GeneratedVisitor {
7608 type Value = GeneratedField;
7609
7610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7611 write!(formatter, "expected one of: {:?}", &FIELDS)
7612 }
7613
7614 #[allow(unused_variables)]
7615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7616 where
7617 E: serde::de::Error,
7618 {
7619 match value {
7620 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7622 }
7623 }
7624 }
7625 deserializer.deserialize_identifier(GeneratedVisitor)
7626 }
7627 }
7628 struct GeneratedVisitor;
7629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7630 type Value = GetServerlessStreamingJobsStatusResponse;
7631
7632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7633 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7634 }
7635
7636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7637 where
7638 V: serde::de::MapAccess<'de>,
7639 {
7640 let mut streaming_job_statuses__ = None;
7641 while let Some(k) = map_.next_key()? {
7642 match k {
7643 GeneratedField::StreamingJobStatuses => {
7644 if streaming_job_statuses__.is_some() {
7645 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7646 }
7647 streaming_job_statuses__ = Some(map_.next_value()?);
7648 }
7649 }
7650 }
7651 Ok(GetServerlessStreamingJobsStatusResponse {
7652 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7653 })
7654 }
7655 }
7656 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7657 }
7658}
7659impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7660 #[allow(deprecated)]
7661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7662 where
7663 S: serde::Serializer,
7664 {
7665 use serde::ser::SerializeStruct;
7666 let mut len = 0;
7667 if self.table_id != 0 {
7668 len += 1;
7669 }
7670 if !self.node_label.is_empty() {
7671 len += 1;
7672 }
7673 if self.backfill_done {
7674 len += 1;
7675 }
7676 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7677 if self.table_id != 0 {
7678 struct_ser.serialize_field("tableId", &self.table_id)?;
7679 }
7680 if !self.node_label.is_empty() {
7681 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7682 }
7683 if self.backfill_done {
7684 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7685 }
7686 struct_ser.end()
7687 }
7688}
7689impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7690 #[allow(deprecated)]
7691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7692 where
7693 D: serde::Deserializer<'de>,
7694 {
7695 const FIELDS: &[&str] = &[
7696 "table_id",
7697 "tableId",
7698 "node_label",
7699 "nodeLabel",
7700 "backfill_done",
7701 "backfillDone",
7702 ];
7703
7704 #[allow(clippy::enum_variant_names)]
7705 enum GeneratedField {
7706 TableId,
7707 NodeLabel,
7708 BackfillDone,
7709 }
7710 impl<'de> serde::Deserialize<'de> for GeneratedField {
7711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7712 where
7713 D: serde::Deserializer<'de>,
7714 {
7715 struct GeneratedVisitor;
7716
7717 impl serde::de::Visitor<'_> for GeneratedVisitor {
7718 type Value = GeneratedField;
7719
7720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7721 write!(formatter, "expected one of: {:?}", &FIELDS)
7722 }
7723
7724 #[allow(unused_variables)]
7725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7726 where
7727 E: serde::de::Error,
7728 {
7729 match value {
7730 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7731 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7732 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7734 }
7735 }
7736 }
7737 deserializer.deserialize_identifier(GeneratedVisitor)
7738 }
7739 }
7740 struct GeneratedVisitor;
7741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7742 type Value = get_serverless_streaming_jobs_status_response::Status;
7743
7744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7745 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7746 }
7747
7748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7749 where
7750 V: serde::de::MapAccess<'de>,
7751 {
7752 let mut table_id__ = None;
7753 let mut node_label__ = None;
7754 let mut backfill_done__ = None;
7755 while let Some(k) = map_.next_key()? {
7756 match k {
7757 GeneratedField::TableId => {
7758 if table_id__.is_some() {
7759 return Err(serde::de::Error::duplicate_field("tableId"));
7760 }
7761 table_id__ =
7762 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7763 ;
7764 }
7765 GeneratedField::NodeLabel => {
7766 if node_label__.is_some() {
7767 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7768 }
7769 node_label__ = Some(map_.next_value()?);
7770 }
7771 GeneratedField::BackfillDone => {
7772 if backfill_done__.is_some() {
7773 return Err(serde::de::Error::duplicate_field("backfillDone"));
7774 }
7775 backfill_done__ = Some(map_.next_value()?);
7776 }
7777 }
7778 }
7779 Ok(get_serverless_streaming_jobs_status_response::Status {
7780 table_id: table_id__.unwrap_or_default(),
7781 node_label: node_label__.unwrap_or_default(),
7782 backfill_done: backfill_done__.unwrap_or_default(),
7783 })
7784 }
7785 }
7786 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7787 }
7788}
7789impl serde::Serialize for GetServingVnodeMappingsRequest {
7790 #[allow(deprecated)]
7791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7792 where
7793 S: serde::Serializer,
7794 {
7795 use serde::ser::SerializeStruct;
7796 let len = 0;
7797 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7798 struct_ser.end()
7799 }
7800}
7801impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7802 #[allow(deprecated)]
7803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7804 where
7805 D: serde::Deserializer<'de>,
7806 {
7807 const FIELDS: &[&str] = &[
7808 ];
7809
7810 #[allow(clippy::enum_variant_names)]
7811 enum GeneratedField {
7812 }
7813 impl<'de> serde::Deserialize<'de> for GeneratedField {
7814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7815 where
7816 D: serde::Deserializer<'de>,
7817 {
7818 struct GeneratedVisitor;
7819
7820 impl serde::de::Visitor<'_> for GeneratedVisitor {
7821 type Value = GeneratedField;
7822
7823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7824 write!(formatter, "expected one of: {:?}", &FIELDS)
7825 }
7826
7827 #[allow(unused_variables)]
7828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7829 where
7830 E: serde::de::Error,
7831 {
7832 Err(serde::de::Error::unknown_field(value, FIELDS))
7833 }
7834 }
7835 deserializer.deserialize_identifier(GeneratedVisitor)
7836 }
7837 }
7838 struct GeneratedVisitor;
7839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7840 type Value = GetServingVnodeMappingsRequest;
7841
7842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7843 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7844 }
7845
7846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7847 where
7848 V: serde::de::MapAccess<'de>,
7849 {
7850 while map_.next_key::<GeneratedField>()?.is_some() {
7851 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7852 }
7853 Ok(GetServingVnodeMappingsRequest {
7854 })
7855 }
7856 }
7857 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7858 }
7859}
7860impl serde::Serialize for GetServingVnodeMappingsResponse {
7861 #[allow(deprecated)]
7862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7863 where
7864 S: serde::Serializer,
7865 {
7866 use serde::ser::SerializeStruct;
7867 let mut len = 0;
7868 if !self.fragment_to_table.is_empty() {
7869 len += 1;
7870 }
7871 if !self.worker_slot_mappings.is_empty() {
7872 len += 1;
7873 }
7874 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7875 if !self.fragment_to_table.is_empty() {
7876 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7877 }
7878 if !self.worker_slot_mappings.is_empty() {
7879 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7880 }
7881 struct_ser.end()
7882 }
7883}
7884impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7885 #[allow(deprecated)]
7886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7887 where
7888 D: serde::Deserializer<'de>,
7889 {
7890 const FIELDS: &[&str] = &[
7891 "fragment_to_table",
7892 "fragmentToTable",
7893 "worker_slot_mappings",
7894 "workerSlotMappings",
7895 ];
7896
7897 #[allow(clippy::enum_variant_names)]
7898 enum GeneratedField {
7899 FragmentToTable,
7900 WorkerSlotMappings,
7901 }
7902 impl<'de> serde::Deserialize<'de> for GeneratedField {
7903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7904 where
7905 D: serde::Deserializer<'de>,
7906 {
7907 struct GeneratedVisitor;
7908
7909 impl serde::de::Visitor<'_> for GeneratedVisitor {
7910 type Value = GeneratedField;
7911
7912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7913 write!(formatter, "expected one of: {:?}", &FIELDS)
7914 }
7915
7916 #[allow(unused_variables)]
7917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7918 where
7919 E: serde::de::Error,
7920 {
7921 match value {
7922 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7923 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7924 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7925 }
7926 }
7927 }
7928 deserializer.deserialize_identifier(GeneratedVisitor)
7929 }
7930 }
7931 struct GeneratedVisitor;
7932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7933 type Value = GetServingVnodeMappingsResponse;
7934
7935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7936 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7937 }
7938
7939 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7940 where
7941 V: serde::de::MapAccess<'de>,
7942 {
7943 let mut fragment_to_table__ = None;
7944 let mut worker_slot_mappings__ = None;
7945 while let Some(k) = map_.next_key()? {
7946 match k {
7947 GeneratedField::FragmentToTable => {
7948 if fragment_to_table__.is_some() {
7949 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7950 }
7951 fragment_to_table__ = Some(
7952 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7953 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
7954 );
7955 }
7956 GeneratedField::WorkerSlotMappings => {
7957 if worker_slot_mappings__.is_some() {
7958 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7959 }
7960 worker_slot_mappings__ = Some(map_.next_value()?);
7961 }
7962 }
7963 }
7964 Ok(GetServingVnodeMappingsResponse {
7965 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7966 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7967 })
7968 }
7969 }
7970 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7971 }
7972}
7973impl serde::Serialize for GetSessionParamsRequest {
7974 #[allow(deprecated)]
7975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7976 where
7977 S: serde::Serializer,
7978 {
7979 use serde::ser::SerializeStruct;
7980 let len = 0;
7981 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7982 struct_ser.end()
7983 }
7984}
7985impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7986 #[allow(deprecated)]
7987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7988 where
7989 D: serde::Deserializer<'de>,
7990 {
7991 const FIELDS: &[&str] = &[
7992 ];
7993
7994 #[allow(clippy::enum_variant_names)]
7995 enum GeneratedField {
7996 }
7997 impl<'de> serde::Deserialize<'de> for GeneratedField {
7998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7999 where
8000 D: serde::Deserializer<'de>,
8001 {
8002 struct GeneratedVisitor;
8003
8004 impl serde::de::Visitor<'_> for GeneratedVisitor {
8005 type Value = GeneratedField;
8006
8007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8008 write!(formatter, "expected one of: {:?}", &FIELDS)
8009 }
8010
8011 #[allow(unused_variables)]
8012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8013 where
8014 E: serde::de::Error,
8015 {
8016 Err(serde::de::Error::unknown_field(value, FIELDS))
8017 }
8018 }
8019 deserializer.deserialize_identifier(GeneratedVisitor)
8020 }
8021 }
8022 struct GeneratedVisitor;
8023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8024 type Value = GetSessionParamsRequest;
8025
8026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8027 formatter.write_str("struct meta.GetSessionParamsRequest")
8028 }
8029
8030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
8031 where
8032 V: serde::de::MapAccess<'de>,
8033 {
8034 while map_.next_key::<GeneratedField>()?.is_some() {
8035 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8036 }
8037 Ok(GetSessionParamsRequest {
8038 })
8039 }
8040 }
8041 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
8042 }
8043}
8044impl serde::Serialize for GetSessionParamsResponse {
8045 #[allow(deprecated)]
8046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8047 where
8048 S: serde::Serializer,
8049 {
8050 use serde::ser::SerializeStruct;
8051 let mut len = 0;
8052 if !self.params.is_empty() {
8053 len += 1;
8054 }
8055 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
8056 if !self.params.is_empty() {
8057 struct_ser.serialize_field("params", &self.params)?;
8058 }
8059 struct_ser.end()
8060 }
8061}
8062impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
8063 #[allow(deprecated)]
8064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8065 where
8066 D: serde::Deserializer<'de>,
8067 {
8068 const FIELDS: &[&str] = &[
8069 "params",
8070 ];
8071
8072 #[allow(clippy::enum_variant_names)]
8073 enum GeneratedField {
8074 Params,
8075 }
8076 impl<'de> serde::Deserialize<'de> for GeneratedField {
8077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8078 where
8079 D: serde::Deserializer<'de>,
8080 {
8081 struct GeneratedVisitor;
8082
8083 impl serde::de::Visitor<'_> for GeneratedVisitor {
8084 type Value = GeneratedField;
8085
8086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087 write!(formatter, "expected one of: {:?}", &FIELDS)
8088 }
8089
8090 #[allow(unused_variables)]
8091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8092 where
8093 E: serde::de::Error,
8094 {
8095 match value {
8096 "params" => Ok(GeneratedField::Params),
8097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8098 }
8099 }
8100 }
8101 deserializer.deserialize_identifier(GeneratedVisitor)
8102 }
8103 }
8104 struct GeneratedVisitor;
8105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8106 type Value = GetSessionParamsResponse;
8107
8108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8109 formatter.write_str("struct meta.GetSessionParamsResponse")
8110 }
8111
8112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
8113 where
8114 V: serde::de::MapAccess<'de>,
8115 {
8116 let mut params__ = None;
8117 while let Some(k) = map_.next_key()? {
8118 match k {
8119 GeneratedField::Params => {
8120 if params__.is_some() {
8121 return Err(serde::de::Error::duplicate_field("params"));
8122 }
8123 params__ = Some(map_.next_value()?);
8124 }
8125 }
8126 }
8127 Ok(GetSessionParamsResponse {
8128 params: params__.unwrap_or_default(),
8129 })
8130 }
8131 }
8132 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
8133 }
8134}
8135impl serde::Serialize for GetSystemParamsRequest {
8136 #[allow(deprecated)]
8137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8138 where
8139 S: serde::Serializer,
8140 {
8141 use serde::ser::SerializeStruct;
8142 let len = 0;
8143 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
8144 struct_ser.end()
8145 }
8146}
8147impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
8148 #[allow(deprecated)]
8149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8150 where
8151 D: serde::Deserializer<'de>,
8152 {
8153 const FIELDS: &[&str] = &[
8154 ];
8155
8156 #[allow(clippy::enum_variant_names)]
8157 enum GeneratedField {
8158 }
8159 impl<'de> serde::Deserialize<'de> for GeneratedField {
8160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8161 where
8162 D: serde::Deserializer<'de>,
8163 {
8164 struct GeneratedVisitor;
8165
8166 impl serde::de::Visitor<'_> for GeneratedVisitor {
8167 type Value = GeneratedField;
8168
8169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8170 write!(formatter, "expected one of: {:?}", &FIELDS)
8171 }
8172
8173 #[allow(unused_variables)]
8174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8175 where
8176 E: serde::de::Error,
8177 {
8178 Err(serde::de::Error::unknown_field(value, FIELDS))
8179 }
8180 }
8181 deserializer.deserialize_identifier(GeneratedVisitor)
8182 }
8183 }
8184 struct GeneratedVisitor;
8185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8186 type Value = GetSystemParamsRequest;
8187
8188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8189 formatter.write_str("struct meta.GetSystemParamsRequest")
8190 }
8191
8192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
8193 where
8194 V: serde::de::MapAccess<'de>,
8195 {
8196 while map_.next_key::<GeneratedField>()?.is_some() {
8197 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8198 }
8199 Ok(GetSystemParamsRequest {
8200 })
8201 }
8202 }
8203 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
8204 }
8205}
8206impl serde::Serialize for GetSystemParamsResponse {
8207 #[allow(deprecated)]
8208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8209 where
8210 S: serde::Serializer,
8211 {
8212 use serde::ser::SerializeStruct;
8213 let mut len = 0;
8214 if self.params.is_some() {
8215 len += 1;
8216 }
8217 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
8218 if let Some(v) = self.params.as_ref() {
8219 struct_ser.serialize_field("params", v)?;
8220 }
8221 struct_ser.end()
8222 }
8223}
8224impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
8225 #[allow(deprecated)]
8226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8227 where
8228 D: serde::Deserializer<'de>,
8229 {
8230 const FIELDS: &[&str] = &[
8231 "params",
8232 ];
8233
8234 #[allow(clippy::enum_variant_names)]
8235 enum GeneratedField {
8236 Params,
8237 }
8238 impl<'de> serde::Deserialize<'de> for GeneratedField {
8239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8240 where
8241 D: serde::Deserializer<'de>,
8242 {
8243 struct GeneratedVisitor;
8244
8245 impl serde::de::Visitor<'_> for GeneratedVisitor {
8246 type Value = GeneratedField;
8247
8248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8249 write!(formatter, "expected one of: {:?}", &FIELDS)
8250 }
8251
8252 #[allow(unused_variables)]
8253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8254 where
8255 E: serde::de::Error,
8256 {
8257 match value {
8258 "params" => Ok(GeneratedField::Params),
8259 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8260 }
8261 }
8262 }
8263 deserializer.deserialize_identifier(GeneratedVisitor)
8264 }
8265 }
8266 struct GeneratedVisitor;
8267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8268 type Value = GetSystemParamsResponse;
8269
8270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8271 formatter.write_str("struct meta.GetSystemParamsResponse")
8272 }
8273
8274 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8275 where
8276 V: serde::de::MapAccess<'de>,
8277 {
8278 let mut params__ = None;
8279 while let Some(k) = map_.next_key()? {
8280 match k {
8281 GeneratedField::Params => {
8282 if params__.is_some() {
8283 return Err(serde::de::Error::duplicate_field("params"));
8284 }
8285 params__ = map_.next_value()?;
8286 }
8287 }
8288 }
8289 Ok(GetSystemParamsResponse {
8290 params: params__,
8291 })
8292 }
8293 }
8294 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8295 }
8296}
8297impl serde::Serialize for GetTelemetryInfoRequest {
8298 #[allow(deprecated)]
8299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8300 where
8301 S: serde::Serializer,
8302 {
8303 use serde::ser::SerializeStruct;
8304 let len = 0;
8305 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8306 struct_ser.end()
8307 }
8308}
8309impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8310 #[allow(deprecated)]
8311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8312 where
8313 D: serde::Deserializer<'de>,
8314 {
8315 const FIELDS: &[&str] = &[
8316 ];
8317
8318 #[allow(clippy::enum_variant_names)]
8319 enum GeneratedField {
8320 }
8321 impl<'de> serde::Deserialize<'de> for GeneratedField {
8322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8323 where
8324 D: serde::Deserializer<'de>,
8325 {
8326 struct GeneratedVisitor;
8327
8328 impl serde::de::Visitor<'_> for GeneratedVisitor {
8329 type Value = GeneratedField;
8330
8331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8332 write!(formatter, "expected one of: {:?}", &FIELDS)
8333 }
8334
8335 #[allow(unused_variables)]
8336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8337 where
8338 E: serde::de::Error,
8339 {
8340 Err(serde::de::Error::unknown_field(value, FIELDS))
8341 }
8342 }
8343 deserializer.deserialize_identifier(GeneratedVisitor)
8344 }
8345 }
8346 struct GeneratedVisitor;
8347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8348 type Value = GetTelemetryInfoRequest;
8349
8350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8351 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8352 }
8353
8354 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8355 where
8356 V: serde::de::MapAccess<'de>,
8357 {
8358 while map_.next_key::<GeneratedField>()?.is_some() {
8359 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8360 }
8361 Ok(GetTelemetryInfoRequest {
8362 })
8363 }
8364 }
8365 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8366 }
8367}
8368impl serde::Serialize for HeartbeatRequest {
8369 #[allow(deprecated)]
8370 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8371 where
8372 S: serde::Serializer,
8373 {
8374 use serde::ser::SerializeStruct;
8375 let mut len = 0;
8376 if self.node_id != 0 {
8377 len += 1;
8378 }
8379 if self.resource.is_some() {
8380 len += 1;
8381 }
8382 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8383 if self.node_id != 0 {
8384 struct_ser.serialize_field("nodeId", &self.node_id)?;
8385 }
8386 if let Some(v) = self.resource.as_ref() {
8387 struct_ser.serialize_field("resource", v)?;
8388 }
8389 struct_ser.end()
8390 }
8391}
8392impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8393 #[allow(deprecated)]
8394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8395 where
8396 D: serde::Deserializer<'de>,
8397 {
8398 const FIELDS: &[&str] = &[
8399 "node_id",
8400 "nodeId",
8401 "resource",
8402 ];
8403
8404 #[allow(clippy::enum_variant_names)]
8405 enum GeneratedField {
8406 NodeId,
8407 Resource,
8408 }
8409 impl<'de> serde::Deserialize<'de> for GeneratedField {
8410 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8411 where
8412 D: serde::Deserializer<'de>,
8413 {
8414 struct GeneratedVisitor;
8415
8416 impl serde::de::Visitor<'_> for GeneratedVisitor {
8417 type Value = GeneratedField;
8418
8419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8420 write!(formatter, "expected one of: {:?}", &FIELDS)
8421 }
8422
8423 #[allow(unused_variables)]
8424 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8425 where
8426 E: serde::de::Error,
8427 {
8428 match value {
8429 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8430 "resource" => Ok(GeneratedField::Resource),
8431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8432 }
8433 }
8434 }
8435 deserializer.deserialize_identifier(GeneratedVisitor)
8436 }
8437 }
8438 struct GeneratedVisitor;
8439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8440 type Value = HeartbeatRequest;
8441
8442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8443 formatter.write_str("struct meta.HeartbeatRequest")
8444 }
8445
8446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8447 where
8448 V: serde::de::MapAccess<'de>,
8449 {
8450 let mut node_id__ = None;
8451 let mut resource__ = None;
8452 while let Some(k) = map_.next_key()? {
8453 match k {
8454 GeneratedField::NodeId => {
8455 if node_id__.is_some() {
8456 return Err(serde::de::Error::duplicate_field("nodeId"));
8457 }
8458 node_id__ =
8459 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8460 ;
8461 }
8462 GeneratedField::Resource => {
8463 if resource__.is_some() {
8464 return Err(serde::de::Error::duplicate_field("resource"));
8465 }
8466 resource__ = map_.next_value()?;
8467 }
8468 }
8469 }
8470 Ok(HeartbeatRequest {
8471 node_id: node_id__.unwrap_or_default(),
8472 resource: resource__,
8473 })
8474 }
8475 }
8476 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8477 }
8478}
8479impl serde::Serialize for HeartbeatResponse {
8480 #[allow(deprecated)]
8481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8482 where
8483 S: serde::Serializer,
8484 {
8485 use serde::ser::SerializeStruct;
8486 let mut len = 0;
8487 if self.status.is_some() {
8488 len += 1;
8489 }
8490 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8491 if let Some(v) = self.status.as_ref() {
8492 struct_ser.serialize_field("status", v)?;
8493 }
8494 struct_ser.end()
8495 }
8496}
8497impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8498 #[allow(deprecated)]
8499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8500 where
8501 D: serde::Deserializer<'de>,
8502 {
8503 const FIELDS: &[&str] = &[
8504 "status",
8505 ];
8506
8507 #[allow(clippy::enum_variant_names)]
8508 enum GeneratedField {
8509 Status,
8510 }
8511 impl<'de> serde::Deserialize<'de> for GeneratedField {
8512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8513 where
8514 D: serde::Deserializer<'de>,
8515 {
8516 struct GeneratedVisitor;
8517
8518 impl serde::de::Visitor<'_> for GeneratedVisitor {
8519 type Value = GeneratedField;
8520
8521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8522 write!(formatter, "expected one of: {:?}", &FIELDS)
8523 }
8524
8525 #[allow(unused_variables)]
8526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8527 where
8528 E: serde::de::Error,
8529 {
8530 match value {
8531 "status" => Ok(GeneratedField::Status),
8532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8533 }
8534 }
8535 }
8536 deserializer.deserialize_identifier(GeneratedVisitor)
8537 }
8538 }
8539 struct GeneratedVisitor;
8540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8541 type Value = HeartbeatResponse;
8542
8543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8544 formatter.write_str("struct meta.HeartbeatResponse")
8545 }
8546
8547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8548 where
8549 V: serde::de::MapAccess<'de>,
8550 {
8551 let mut status__ = None;
8552 while let Some(k) = map_.next_key()? {
8553 match k {
8554 GeneratedField::Status => {
8555 if status__.is_some() {
8556 return Err(serde::de::Error::duplicate_field("status"));
8557 }
8558 status__ = map_.next_value()?;
8559 }
8560 }
8561 }
8562 Ok(HeartbeatResponse {
8563 status: status__,
8564 })
8565 }
8566 }
8567 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8568 }
8569}
8570impl serde::Serialize for InjectSourceOffsetsRequest {
8571 #[allow(deprecated)]
8572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8573 where
8574 S: serde::Serializer,
8575 {
8576 use serde::ser::SerializeStruct;
8577 let mut len = 0;
8578 if self.source_id != 0 {
8579 len += 1;
8580 }
8581 if !self.split_offsets.is_empty() {
8582 len += 1;
8583 }
8584 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsRequest", len)?;
8585 if self.source_id != 0 {
8586 struct_ser.serialize_field("sourceId", &self.source_id)?;
8587 }
8588 if !self.split_offsets.is_empty() {
8589 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
8590 }
8591 struct_ser.end()
8592 }
8593}
8594impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsRequest {
8595 #[allow(deprecated)]
8596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8597 where
8598 D: serde::Deserializer<'de>,
8599 {
8600 const FIELDS: &[&str] = &[
8601 "source_id",
8602 "sourceId",
8603 "split_offsets",
8604 "splitOffsets",
8605 ];
8606
8607 #[allow(clippy::enum_variant_names)]
8608 enum GeneratedField {
8609 SourceId,
8610 SplitOffsets,
8611 }
8612 impl<'de> serde::Deserialize<'de> for GeneratedField {
8613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8614 where
8615 D: serde::Deserializer<'de>,
8616 {
8617 struct GeneratedVisitor;
8618
8619 impl serde::de::Visitor<'_> for GeneratedVisitor {
8620 type Value = GeneratedField;
8621
8622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8623 write!(formatter, "expected one of: {:?}", &FIELDS)
8624 }
8625
8626 #[allow(unused_variables)]
8627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8628 where
8629 E: serde::de::Error,
8630 {
8631 match value {
8632 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8633 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
8634 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8635 }
8636 }
8637 }
8638 deserializer.deserialize_identifier(GeneratedVisitor)
8639 }
8640 }
8641 struct GeneratedVisitor;
8642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8643 type Value = InjectSourceOffsetsRequest;
8644
8645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8646 formatter.write_str("struct meta.InjectSourceOffsetsRequest")
8647 }
8648
8649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsRequest, V::Error>
8650 where
8651 V: serde::de::MapAccess<'de>,
8652 {
8653 let mut source_id__ = None;
8654 let mut split_offsets__ = None;
8655 while let Some(k) = map_.next_key()? {
8656 match k {
8657 GeneratedField::SourceId => {
8658 if source_id__.is_some() {
8659 return Err(serde::de::Error::duplicate_field("sourceId"));
8660 }
8661 source_id__ =
8662 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8663 ;
8664 }
8665 GeneratedField::SplitOffsets => {
8666 if split_offsets__.is_some() {
8667 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8668 }
8669 split_offsets__ = Some(
8670 map_.next_value::<std::collections::HashMap<_, _>>()?
8671 );
8672 }
8673 }
8674 }
8675 Ok(InjectSourceOffsetsRequest {
8676 source_id: source_id__.unwrap_or_default(),
8677 split_offsets: split_offsets__.unwrap_or_default(),
8678 })
8679 }
8680 }
8681 deserializer.deserialize_struct("meta.InjectSourceOffsetsRequest", FIELDS, GeneratedVisitor)
8682 }
8683}
8684impl serde::Serialize for InjectSourceOffsetsResponse {
8685 #[allow(deprecated)]
8686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8687 where
8688 S: serde::Serializer,
8689 {
8690 use serde::ser::SerializeStruct;
8691 let mut len = 0;
8692 if !self.applied_split_ids.is_empty() {
8693 len += 1;
8694 }
8695 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsResponse", len)?;
8696 if !self.applied_split_ids.is_empty() {
8697 struct_ser.serialize_field("appliedSplitIds", &self.applied_split_ids)?;
8698 }
8699 struct_ser.end()
8700 }
8701}
8702impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsResponse {
8703 #[allow(deprecated)]
8704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8705 where
8706 D: serde::Deserializer<'de>,
8707 {
8708 const FIELDS: &[&str] = &[
8709 "applied_split_ids",
8710 "appliedSplitIds",
8711 ];
8712
8713 #[allow(clippy::enum_variant_names)]
8714 enum GeneratedField {
8715 AppliedSplitIds,
8716 }
8717 impl<'de> serde::Deserialize<'de> for GeneratedField {
8718 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8719 where
8720 D: serde::Deserializer<'de>,
8721 {
8722 struct GeneratedVisitor;
8723
8724 impl serde::de::Visitor<'_> for GeneratedVisitor {
8725 type Value = GeneratedField;
8726
8727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8728 write!(formatter, "expected one of: {:?}", &FIELDS)
8729 }
8730
8731 #[allow(unused_variables)]
8732 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8733 where
8734 E: serde::de::Error,
8735 {
8736 match value {
8737 "appliedSplitIds" | "applied_split_ids" => Ok(GeneratedField::AppliedSplitIds),
8738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8739 }
8740 }
8741 }
8742 deserializer.deserialize_identifier(GeneratedVisitor)
8743 }
8744 }
8745 struct GeneratedVisitor;
8746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8747 type Value = InjectSourceOffsetsResponse;
8748
8749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8750 formatter.write_str("struct meta.InjectSourceOffsetsResponse")
8751 }
8752
8753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsResponse, V::Error>
8754 where
8755 V: serde::de::MapAccess<'de>,
8756 {
8757 let mut applied_split_ids__ = None;
8758 while let Some(k) = map_.next_key()? {
8759 match k {
8760 GeneratedField::AppliedSplitIds => {
8761 if applied_split_ids__.is_some() {
8762 return Err(serde::de::Error::duplicate_field("appliedSplitIds"));
8763 }
8764 applied_split_ids__ = Some(map_.next_value()?);
8765 }
8766 }
8767 }
8768 Ok(InjectSourceOffsetsResponse {
8769 applied_split_ids: applied_split_ids__.unwrap_or_default(),
8770 })
8771 }
8772 }
8773 deserializer.deserialize_struct("meta.InjectSourceOffsetsResponse", FIELDS, GeneratedVisitor)
8774 }
8775}
8776impl serde::Serialize for ListActorSplitsRequest {
8777 #[allow(deprecated)]
8778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8779 where
8780 S: serde::Serializer,
8781 {
8782 use serde::ser::SerializeStruct;
8783 let len = 0;
8784 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8785 struct_ser.end()
8786 }
8787}
8788impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8789 #[allow(deprecated)]
8790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8791 where
8792 D: serde::Deserializer<'de>,
8793 {
8794 const FIELDS: &[&str] = &[
8795 ];
8796
8797 #[allow(clippy::enum_variant_names)]
8798 enum GeneratedField {
8799 }
8800 impl<'de> serde::Deserialize<'de> for GeneratedField {
8801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8802 where
8803 D: serde::Deserializer<'de>,
8804 {
8805 struct GeneratedVisitor;
8806
8807 impl serde::de::Visitor<'_> for GeneratedVisitor {
8808 type Value = GeneratedField;
8809
8810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8811 write!(formatter, "expected one of: {:?}", &FIELDS)
8812 }
8813
8814 #[allow(unused_variables)]
8815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8816 where
8817 E: serde::de::Error,
8818 {
8819 Err(serde::de::Error::unknown_field(value, FIELDS))
8820 }
8821 }
8822 deserializer.deserialize_identifier(GeneratedVisitor)
8823 }
8824 }
8825 struct GeneratedVisitor;
8826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8827 type Value = ListActorSplitsRequest;
8828
8829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8830 formatter.write_str("struct meta.ListActorSplitsRequest")
8831 }
8832
8833 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8834 where
8835 V: serde::de::MapAccess<'de>,
8836 {
8837 while map_.next_key::<GeneratedField>()?.is_some() {
8838 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8839 }
8840 Ok(ListActorSplitsRequest {
8841 })
8842 }
8843 }
8844 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
8845 }
8846}
8847impl serde::Serialize for ListActorSplitsResponse {
8848 #[allow(deprecated)]
8849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8850 where
8851 S: serde::Serializer,
8852 {
8853 use serde::ser::SerializeStruct;
8854 let mut len = 0;
8855 if !self.actor_splits.is_empty() {
8856 len += 1;
8857 }
8858 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
8859 if !self.actor_splits.is_empty() {
8860 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
8861 }
8862 struct_ser.end()
8863 }
8864}
8865impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
8866 #[allow(deprecated)]
8867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8868 where
8869 D: serde::Deserializer<'de>,
8870 {
8871 const FIELDS: &[&str] = &[
8872 "actor_splits",
8873 "actorSplits",
8874 ];
8875
8876 #[allow(clippy::enum_variant_names)]
8877 enum GeneratedField {
8878 ActorSplits,
8879 }
8880 impl<'de> serde::Deserialize<'de> for GeneratedField {
8881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8882 where
8883 D: serde::Deserializer<'de>,
8884 {
8885 struct GeneratedVisitor;
8886
8887 impl serde::de::Visitor<'_> for GeneratedVisitor {
8888 type Value = GeneratedField;
8889
8890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8891 write!(formatter, "expected one of: {:?}", &FIELDS)
8892 }
8893
8894 #[allow(unused_variables)]
8895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8896 where
8897 E: serde::de::Error,
8898 {
8899 match value {
8900 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
8901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8902 }
8903 }
8904 }
8905 deserializer.deserialize_identifier(GeneratedVisitor)
8906 }
8907 }
8908 struct GeneratedVisitor;
8909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8910 type Value = ListActorSplitsResponse;
8911
8912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8913 formatter.write_str("struct meta.ListActorSplitsResponse")
8914 }
8915
8916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
8917 where
8918 V: serde::de::MapAccess<'de>,
8919 {
8920 let mut actor_splits__ = None;
8921 while let Some(k) = map_.next_key()? {
8922 match k {
8923 GeneratedField::ActorSplits => {
8924 if actor_splits__.is_some() {
8925 return Err(serde::de::Error::duplicate_field("actorSplits"));
8926 }
8927 actor_splits__ = Some(map_.next_value()?);
8928 }
8929 }
8930 }
8931 Ok(ListActorSplitsResponse {
8932 actor_splits: actor_splits__.unwrap_or_default(),
8933 })
8934 }
8935 }
8936 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
8937 }
8938}
8939impl serde::Serialize for list_actor_splits_response::ActorSplit {
8940 #[allow(deprecated)]
8941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8942 where
8943 S: serde::Serializer,
8944 {
8945 use serde::ser::SerializeStruct;
8946 let mut len = 0;
8947 if self.actor_id != 0 {
8948 len += 1;
8949 }
8950 if self.fragment_id != 0 {
8951 len += 1;
8952 }
8953 if self.source_id != 0 {
8954 len += 1;
8955 }
8956 if !self.split_id.is_empty() {
8957 len += 1;
8958 }
8959 if self.fragment_type != 0 {
8960 len += 1;
8961 }
8962 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
8963 if self.actor_id != 0 {
8964 struct_ser.serialize_field("actorId", &self.actor_id)?;
8965 }
8966 if self.fragment_id != 0 {
8967 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8968 }
8969 if self.source_id != 0 {
8970 struct_ser.serialize_field("sourceId", &self.source_id)?;
8971 }
8972 if !self.split_id.is_empty() {
8973 struct_ser.serialize_field("splitId", &self.split_id)?;
8974 }
8975 if self.fragment_type != 0 {
8976 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
8977 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8978 struct_ser.serialize_field("fragmentType", &v)?;
8979 }
8980 struct_ser.end()
8981 }
8982}
8983impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8984 #[allow(deprecated)]
8985 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8986 where
8987 D: serde::Deserializer<'de>,
8988 {
8989 const FIELDS: &[&str] = &[
8990 "actor_id",
8991 "actorId",
8992 "fragment_id",
8993 "fragmentId",
8994 "source_id",
8995 "sourceId",
8996 "split_id",
8997 "splitId",
8998 "fragment_type",
8999 "fragmentType",
9000 ];
9001
9002 #[allow(clippy::enum_variant_names)]
9003 enum GeneratedField {
9004 ActorId,
9005 FragmentId,
9006 SourceId,
9007 SplitId,
9008 FragmentType,
9009 }
9010 impl<'de> serde::Deserialize<'de> for GeneratedField {
9011 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9012 where
9013 D: serde::Deserializer<'de>,
9014 {
9015 struct GeneratedVisitor;
9016
9017 impl serde::de::Visitor<'_> for GeneratedVisitor {
9018 type Value = GeneratedField;
9019
9020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9021 write!(formatter, "expected one of: {:?}", &FIELDS)
9022 }
9023
9024 #[allow(unused_variables)]
9025 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9026 where
9027 E: serde::de::Error,
9028 {
9029 match value {
9030 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9031 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9032 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9033 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
9034 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
9035 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9036 }
9037 }
9038 }
9039 deserializer.deserialize_identifier(GeneratedVisitor)
9040 }
9041 }
9042 struct GeneratedVisitor;
9043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9044 type Value = list_actor_splits_response::ActorSplit;
9045
9046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9047 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
9048 }
9049
9050 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
9051 where
9052 V: serde::de::MapAccess<'de>,
9053 {
9054 let mut actor_id__ = None;
9055 let mut fragment_id__ = None;
9056 let mut source_id__ = None;
9057 let mut split_id__ = None;
9058 let mut fragment_type__ = None;
9059 while let Some(k) = map_.next_key()? {
9060 match k {
9061 GeneratedField::ActorId => {
9062 if actor_id__.is_some() {
9063 return Err(serde::de::Error::duplicate_field("actorId"));
9064 }
9065 actor_id__ =
9066 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9067 ;
9068 }
9069 GeneratedField::FragmentId => {
9070 if fragment_id__.is_some() {
9071 return Err(serde::de::Error::duplicate_field("fragmentId"));
9072 }
9073 fragment_id__ =
9074 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9075 ;
9076 }
9077 GeneratedField::SourceId => {
9078 if source_id__.is_some() {
9079 return Err(serde::de::Error::duplicate_field("sourceId"));
9080 }
9081 source_id__ =
9082 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9083 ;
9084 }
9085 GeneratedField::SplitId => {
9086 if split_id__.is_some() {
9087 return Err(serde::de::Error::duplicate_field("splitId"));
9088 }
9089 split_id__ = Some(map_.next_value()?);
9090 }
9091 GeneratedField::FragmentType => {
9092 if fragment_type__.is_some() {
9093 return Err(serde::de::Error::duplicate_field("fragmentType"));
9094 }
9095 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
9096 }
9097 }
9098 }
9099 Ok(list_actor_splits_response::ActorSplit {
9100 actor_id: actor_id__.unwrap_or_default(),
9101 fragment_id: fragment_id__.unwrap_or_default(),
9102 source_id: source_id__.unwrap_or_default(),
9103 split_id: split_id__.unwrap_or_default(),
9104 fragment_type: fragment_type__.unwrap_or_default(),
9105 })
9106 }
9107 }
9108 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
9109 }
9110}
9111impl serde::Serialize for list_actor_splits_response::FragmentType {
9112 #[allow(deprecated)]
9113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9114 where
9115 S: serde::Serializer,
9116 {
9117 let variant = match self {
9118 Self::Unspecified => "UNSPECIFIED",
9119 Self::NonSharedSource => "NON_SHARED_SOURCE",
9120 Self::SharedSource => "SHARED_SOURCE",
9121 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
9122 };
9123 serializer.serialize_str(variant)
9124 }
9125}
9126impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
9127 #[allow(deprecated)]
9128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9129 where
9130 D: serde::Deserializer<'de>,
9131 {
9132 const FIELDS: &[&str] = &[
9133 "UNSPECIFIED",
9134 "NON_SHARED_SOURCE",
9135 "SHARED_SOURCE",
9136 "SHARED_SOURCE_BACKFILL",
9137 ];
9138
9139 struct GeneratedVisitor;
9140
9141 impl serde::de::Visitor<'_> for GeneratedVisitor {
9142 type Value = list_actor_splits_response::FragmentType;
9143
9144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9145 write!(formatter, "expected one of: {:?}", &FIELDS)
9146 }
9147
9148 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9149 where
9150 E: serde::de::Error,
9151 {
9152 i32::try_from(v)
9153 .ok()
9154 .and_then(|x| x.try_into().ok())
9155 .ok_or_else(|| {
9156 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9157 })
9158 }
9159
9160 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9161 where
9162 E: serde::de::Error,
9163 {
9164 i32::try_from(v)
9165 .ok()
9166 .and_then(|x| x.try_into().ok())
9167 .ok_or_else(|| {
9168 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9169 })
9170 }
9171
9172 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9173 where
9174 E: serde::de::Error,
9175 {
9176 match value {
9177 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
9178 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
9179 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
9180 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
9181 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9182 }
9183 }
9184 }
9185 deserializer.deserialize_any(GeneratedVisitor)
9186 }
9187}
9188impl serde::Serialize for ListActorStatesRequest {
9189 #[allow(deprecated)]
9190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9191 where
9192 S: serde::Serializer,
9193 {
9194 use serde::ser::SerializeStruct;
9195 let len = 0;
9196 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
9197 struct_ser.end()
9198 }
9199}
9200impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
9201 #[allow(deprecated)]
9202 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9203 where
9204 D: serde::Deserializer<'de>,
9205 {
9206 const FIELDS: &[&str] = &[
9207 ];
9208
9209 #[allow(clippy::enum_variant_names)]
9210 enum GeneratedField {
9211 }
9212 impl<'de> serde::Deserialize<'de> for GeneratedField {
9213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9214 where
9215 D: serde::Deserializer<'de>,
9216 {
9217 struct GeneratedVisitor;
9218
9219 impl serde::de::Visitor<'_> for GeneratedVisitor {
9220 type Value = GeneratedField;
9221
9222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9223 write!(formatter, "expected one of: {:?}", &FIELDS)
9224 }
9225
9226 #[allow(unused_variables)]
9227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9228 where
9229 E: serde::de::Error,
9230 {
9231 Err(serde::de::Error::unknown_field(value, FIELDS))
9232 }
9233 }
9234 deserializer.deserialize_identifier(GeneratedVisitor)
9235 }
9236 }
9237 struct GeneratedVisitor;
9238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9239 type Value = ListActorStatesRequest;
9240
9241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9242 formatter.write_str("struct meta.ListActorStatesRequest")
9243 }
9244
9245 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
9246 where
9247 V: serde::de::MapAccess<'de>,
9248 {
9249 while map_.next_key::<GeneratedField>()?.is_some() {
9250 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9251 }
9252 Ok(ListActorStatesRequest {
9253 })
9254 }
9255 }
9256 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
9257 }
9258}
9259impl serde::Serialize for ListActorStatesResponse {
9260 #[allow(deprecated)]
9261 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9262 where
9263 S: serde::Serializer,
9264 {
9265 use serde::ser::SerializeStruct;
9266 let mut len = 0;
9267 if !self.states.is_empty() {
9268 len += 1;
9269 }
9270 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
9271 if !self.states.is_empty() {
9272 struct_ser.serialize_field("states", &self.states)?;
9273 }
9274 struct_ser.end()
9275 }
9276}
9277impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
9278 #[allow(deprecated)]
9279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9280 where
9281 D: serde::Deserializer<'de>,
9282 {
9283 const FIELDS: &[&str] = &[
9284 "states",
9285 ];
9286
9287 #[allow(clippy::enum_variant_names)]
9288 enum GeneratedField {
9289 States,
9290 }
9291 impl<'de> serde::Deserialize<'de> for GeneratedField {
9292 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9293 where
9294 D: serde::Deserializer<'de>,
9295 {
9296 struct GeneratedVisitor;
9297
9298 impl serde::de::Visitor<'_> for GeneratedVisitor {
9299 type Value = GeneratedField;
9300
9301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9302 write!(formatter, "expected one of: {:?}", &FIELDS)
9303 }
9304
9305 #[allow(unused_variables)]
9306 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9307 where
9308 E: serde::de::Error,
9309 {
9310 match value {
9311 "states" => Ok(GeneratedField::States),
9312 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9313 }
9314 }
9315 }
9316 deserializer.deserialize_identifier(GeneratedVisitor)
9317 }
9318 }
9319 struct GeneratedVisitor;
9320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9321 type Value = ListActorStatesResponse;
9322
9323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9324 formatter.write_str("struct meta.ListActorStatesResponse")
9325 }
9326
9327 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
9328 where
9329 V: serde::de::MapAccess<'de>,
9330 {
9331 let mut states__ = None;
9332 while let Some(k) = map_.next_key()? {
9333 match k {
9334 GeneratedField::States => {
9335 if states__.is_some() {
9336 return Err(serde::de::Error::duplicate_field("states"));
9337 }
9338 states__ = Some(map_.next_value()?);
9339 }
9340 }
9341 }
9342 Ok(ListActorStatesResponse {
9343 states: states__.unwrap_or_default(),
9344 })
9345 }
9346 }
9347 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
9348 }
9349}
9350impl serde::Serialize for list_actor_states_response::ActorState {
9351 #[allow(deprecated)]
9352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9353 where
9354 S: serde::Serializer,
9355 {
9356 use serde::ser::SerializeStruct;
9357 let mut len = 0;
9358 if self.actor_id != 0 {
9359 len += 1;
9360 }
9361 if self.fragment_id != 0 {
9362 len += 1;
9363 }
9364 if self.worker_id != 0 {
9365 len += 1;
9366 }
9367 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
9368 if self.actor_id != 0 {
9369 struct_ser.serialize_field("actorId", &self.actor_id)?;
9370 }
9371 if self.fragment_id != 0 {
9372 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9373 }
9374 if self.worker_id != 0 {
9375 struct_ser.serialize_field("workerId", &self.worker_id)?;
9376 }
9377 struct_ser.end()
9378 }
9379}
9380impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
9381 #[allow(deprecated)]
9382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9383 where
9384 D: serde::Deserializer<'de>,
9385 {
9386 const FIELDS: &[&str] = &[
9387 "actor_id",
9388 "actorId",
9389 "fragment_id",
9390 "fragmentId",
9391 "worker_id",
9392 "workerId",
9393 ];
9394
9395 #[allow(clippy::enum_variant_names)]
9396 enum GeneratedField {
9397 ActorId,
9398 FragmentId,
9399 WorkerId,
9400 }
9401 impl<'de> serde::Deserialize<'de> for GeneratedField {
9402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9403 where
9404 D: serde::Deserializer<'de>,
9405 {
9406 struct GeneratedVisitor;
9407
9408 impl serde::de::Visitor<'_> for GeneratedVisitor {
9409 type Value = GeneratedField;
9410
9411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9412 write!(formatter, "expected one of: {:?}", &FIELDS)
9413 }
9414
9415 #[allow(unused_variables)]
9416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9417 where
9418 E: serde::de::Error,
9419 {
9420 match value {
9421 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9422 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9423 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
9424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9425 }
9426 }
9427 }
9428 deserializer.deserialize_identifier(GeneratedVisitor)
9429 }
9430 }
9431 struct GeneratedVisitor;
9432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9433 type Value = list_actor_states_response::ActorState;
9434
9435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9436 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
9437 }
9438
9439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
9440 where
9441 V: serde::de::MapAccess<'de>,
9442 {
9443 let mut actor_id__ = None;
9444 let mut fragment_id__ = None;
9445 let mut worker_id__ = None;
9446 while let Some(k) = map_.next_key()? {
9447 match k {
9448 GeneratedField::ActorId => {
9449 if actor_id__.is_some() {
9450 return Err(serde::de::Error::duplicate_field("actorId"));
9451 }
9452 actor_id__ =
9453 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9454 ;
9455 }
9456 GeneratedField::FragmentId => {
9457 if fragment_id__.is_some() {
9458 return Err(serde::de::Error::duplicate_field("fragmentId"));
9459 }
9460 fragment_id__ =
9461 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9462 ;
9463 }
9464 GeneratedField::WorkerId => {
9465 if worker_id__.is_some() {
9466 return Err(serde::de::Error::duplicate_field("workerId"));
9467 }
9468 worker_id__ =
9469 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9470 ;
9471 }
9472 }
9473 }
9474 Ok(list_actor_states_response::ActorState {
9475 actor_id: actor_id__.unwrap_or_default(),
9476 fragment_id: fragment_id__.unwrap_or_default(),
9477 worker_id: worker_id__.unwrap_or_default(),
9478 })
9479 }
9480 }
9481 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
9482 }
9483}
9484impl serde::Serialize for ListAllNodesRequest {
9485 #[allow(deprecated)]
9486 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9487 where
9488 S: serde::Serializer,
9489 {
9490 use serde::ser::SerializeStruct;
9491 let mut len = 0;
9492 if self.worker_type.is_some() {
9493 len += 1;
9494 }
9495 if self.include_starting_nodes {
9496 len += 1;
9497 }
9498 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9499 if let Some(v) = self.worker_type.as_ref() {
9500 let v = super::common::WorkerType::try_from(*v)
9501 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9502 struct_ser.serialize_field("workerType", &v)?;
9503 }
9504 if self.include_starting_nodes {
9505 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9506 }
9507 struct_ser.end()
9508 }
9509}
9510impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9511 #[allow(deprecated)]
9512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9513 where
9514 D: serde::Deserializer<'de>,
9515 {
9516 const FIELDS: &[&str] = &[
9517 "worker_type",
9518 "workerType",
9519 "include_starting_nodes",
9520 "includeStartingNodes",
9521 ];
9522
9523 #[allow(clippy::enum_variant_names)]
9524 enum GeneratedField {
9525 WorkerType,
9526 IncludeStartingNodes,
9527 }
9528 impl<'de> serde::Deserialize<'de> for GeneratedField {
9529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9530 where
9531 D: serde::Deserializer<'de>,
9532 {
9533 struct GeneratedVisitor;
9534
9535 impl serde::de::Visitor<'_> for GeneratedVisitor {
9536 type Value = GeneratedField;
9537
9538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9539 write!(formatter, "expected one of: {:?}", &FIELDS)
9540 }
9541
9542 #[allow(unused_variables)]
9543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9544 where
9545 E: serde::de::Error,
9546 {
9547 match value {
9548 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9549 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9551 }
9552 }
9553 }
9554 deserializer.deserialize_identifier(GeneratedVisitor)
9555 }
9556 }
9557 struct GeneratedVisitor;
9558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9559 type Value = ListAllNodesRequest;
9560
9561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9562 formatter.write_str("struct meta.ListAllNodesRequest")
9563 }
9564
9565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9566 where
9567 V: serde::de::MapAccess<'de>,
9568 {
9569 let mut worker_type__ = None;
9570 let mut include_starting_nodes__ = None;
9571 while let Some(k) = map_.next_key()? {
9572 match k {
9573 GeneratedField::WorkerType => {
9574 if worker_type__.is_some() {
9575 return Err(serde::de::Error::duplicate_field("workerType"));
9576 }
9577 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9578 }
9579 GeneratedField::IncludeStartingNodes => {
9580 if include_starting_nodes__.is_some() {
9581 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9582 }
9583 include_starting_nodes__ = Some(map_.next_value()?);
9584 }
9585 }
9586 }
9587 Ok(ListAllNodesRequest {
9588 worker_type: worker_type__,
9589 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9590 })
9591 }
9592 }
9593 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9594 }
9595}
9596impl serde::Serialize for ListAllNodesResponse {
9597 #[allow(deprecated)]
9598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9599 where
9600 S: serde::Serializer,
9601 {
9602 use serde::ser::SerializeStruct;
9603 let mut len = 0;
9604 if self.status.is_some() {
9605 len += 1;
9606 }
9607 if !self.nodes.is_empty() {
9608 len += 1;
9609 }
9610 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9611 if let Some(v) = self.status.as_ref() {
9612 struct_ser.serialize_field("status", v)?;
9613 }
9614 if !self.nodes.is_empty() {
9615 struct_ser.serialize_field("nodes", &self.nodes)?;
9616 }
9617 struct_ser.end()
9618 }
9619}
9620impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9621 #[allow(deprecated)]
9622 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9623 where
9624 D: serde::Deserializer<'de>,
9625 {
9626 const FIELDS: &[&str] = &[
9627 "status",
9628 "nodes",
9629 ];
9630
9631 #[allow(clippy::enum_variant_names)]
9632 enum GeneratedField {
9633 Status,
9634 Nodes,
9635 }
9636 impl<'de> serde::Deserialize<'de> for GeneratedField {
9637 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9638 where
9639 D: serde::Deserializer<'de>,
9640 {
9641 struct GeneratedVisitor;
9642
9643 impl serde::de::Visitor<'_> for GeneratedVisitor {
9644 type Value = GeneratedField;
9645
9646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9647 write!(formatter, "expected one of: {:?}", &FIELDS)
9648 }
9649
9650 #[allow(unused_variables)]
9651 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9652 where
9653 E: serde::de::Error,
9654 {
9655 match value {
9656 "status" => Ok(GeneratedField::Status),
9657 "nodes" => Ok(GeneratedField::Nodes),
9658 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9659 }
9660 }
9661 }
9662 deserializer.deserialize_identifier(GeneratedVisitor)
9663 }
9664 }
9665 struct GeneratedVisitor;
9666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9667 type Value = ListAllNodesResponse;
9668
9669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9670 formatter.write_str("struct meta.ListAllNodesResponse")
9671 }
9672
9673 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9674 where
9675 V: serde::de::MapAccess<'de>,
9676 {
9677 let mut status__ = None;
9678 let mut nodes__ = None;
9679 while let Some(k) = map_.next_key()? {
9680 match k {
9681 GeneratedField::Status => {
9682 if status__.is_some() {
9683 return Err(serde::de::Error::duplicate_field("status"));
9684 }
9685 status__ = map_.next_value()?;
9686 }
9687 GeneratedField::Nodes => {
9688 if nodes__.is_some() {
9689 return Err(serde::de::Error::duplicate_field("nodes"));
9690 }
9691 nodes__ = Some(map_.next_value()?);
9692 }
9693 }
9694 }
9695 Ok(ListAllNodesResponse {
9696 status: status__,
9697 nodes: nodes__.unwrap_or_default(),
9698 })
9699 }
9700 }
9701 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9702 }
9703}
9704impl serde::Serialize for ListCdcProgressRequest {
9705 #[allow(deprecated)]
9706 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9707 where
9708 S: serde::Serializer,
9709 {
9710 use serde::ser::SerializeStruct;
9711 let len = 0;
9712 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9713 struct_ser.end()
9714 }
9715}
9716impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9717 #[allow(deprecated)]
9718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9719 where
9720 D: serde::Deserializer<'de>,
9721 {
9722 const FIELDS: &[&str] = &[
9723 ];
9724
9725 #[allow(clippy::enum_variant_names)]
9726 enum GeneratedField {
9727 }
9728 impl<'de> serde::Deserialize<'de> for GeneratedField {
9729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9730 where
9731 D: serde::Deserializer<'de>,
9732 {
9733 struct GeneratedVisitor;
9734
9735 impl serde::de::Visitor<'_> for GeneratedVisitor {
9736 type Value = GeneratedField;
9737
9738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9739 write!(formatter, "expected one of: {:?}", &FIELDS)
9740 }
9741
9742 #[allow(unused_variables)]
9743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9744 where
9745 E: serde::de::Error,
9746 {
9747 Err(serde::de::Error::unknown_field(value, FIELDS))
9748 }
9749 }
9750 deserializer.deserialize_identifier(GeneratedVisitor)
9751 }
9752 }
9753 struct GeneratedVisitor;
9754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9755 type Value = ListCdcProgressRequest;
9756
9757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9758 formatter.write_str("struct meta.ListCdcProgressRequest")
9759 }
9760
9761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9762 where
9763 V: serde::de::MapAccess<'de>,
9764 {
9765 while map_.next_key::<GeneratedField>()?.is_some() {
9766 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9767 }
9768 Ok(ListCdcProgressRequest {
9769 })
9770 }
9771 }
9772 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9773 }
9774}
9775impl serde::Serialize for ListCdcProgressResponse {
9776 #[allow(deprecated)]
9777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9778 where
9779 S: serde::Serializer,
9780 {
9781 use serde::ser::SerializeStruct;
9782 let mut len = 0;
9783 if !self.cdc_progress.is_empty() {
9784 len += 1;
9785 }
9786 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9787 if !self.cdc_progress.is_empty() {
9788 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9789 }
9790 struct_ser.end()
9791 }
9792}
9793impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9794 #[allow(deprecated)]
9795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9796 where
9797 D: serde::Deserializer<'de>,
9798 {
9799 const FIELDS: &[&str] = &[
9800 "cdc_progress",
9801 "cdcProgress",
9802 ];
9803
9804 #[allow(clippy::enum_variant_names)]
9805 enum GeneratedField {
9806 CdcProgress,
9807 }
9808 impl<'de> serde::Deserialize<'de> for GeneratedField {
9809 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9810 where
9811 D: serde::Deserializer<'de>,
9812 {
9813 struct GeneratedVisitor;
9814
9815 impl serde::de::Visitor<'_> for GeneratedVisitor {
9816 type Value = GeneratedField;
9817
9818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9819 write!(formatter, "expected one of: {:?}", &FIELDS)
9820 }
9821
9822 #[allow(unused_variables)]
9823 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9824 where
9825 E: serde::de::Error,
9826 {
9827 match value {
9828 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9829 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9830 }
9831 }
9832 }
9833 deserializer.deserialize_identifier(GeneratedVisitor)
9834 }
9835 }
9836 struct GeneratedVisitor;
9837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9838 type Value = ListCdcProgressResponse;
9839
9840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9841 formatter.write_str("struct meta.ListCdcProgressResponse")
9842 }
9843
9844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
9845 where
9846 V: serde::de::MapAccess<'de>,
9847 {
9848 let mut cdc_progress__ = None;
9849 while let Some(k) = map_.next_key()? {
9850 match k {
9851 GeneratedField::CdcProgress => {
9852 if cdc_progress__.is_some() {
9853 return Err(serde::de::Error::duplicate_field("cdcProgress"));
9854 }
9855 cdc_progress__ = Some(
9856 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9857 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9858 );
9859 }
9860 }
9861 }
9862 Ok(ListCdcProgressResponse {
9863 cdc_progress: cdc_progress__.unwrap_or_default(),
9864 })
9865 }
9866 }
9867 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
9868 }
9869}
9870impl serde::Serialize for list_cdc_progress_response::CdcProgress {
9871 #[allow(deprecated)]
9872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9873 where
9874 S: serde::Serializer,
9875 {
9876 use serde::ser::SerializeStruct;
9877 let mut len = 0;
9878 if self.split_total_count != 0 {
9879 len += 1;
9880 }
9881 if self.split_backfilled_count != 0 {
9882 len += 1;
9883 }
9884 if self.split_completed_count != 0 {
9885 len += 1;
9886 }
9887 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
9888 if self.split_total_count != 0 {
9889 #[allow(clippy::needless_borrow)]
9890 #[allow(clippy::needless_borrows_for_generic_args)]
9891 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
9892 }
9893 if self.split_backfilled_count != 0 {
9894 #[allow(clippy::needless_borrow)]
9895 #[allow(clippy::needless_borrows_for_generic_args)]
9896 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
9897 }
9898 if self.split_completed_count != 0 {
9899 #[allow(clippy::needless_borrow)]
9900 #[allow(clippy::needless_borrows_for_generic_args)]
9901 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
9902 }
9903 struct_ser.end()
9904 }
9905}
9906impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
9907 #[allow(deprecated)]
9908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9909 where
9910 D: serde::Deserializer<'de>,
9911 {
9912 const FIELDS: &[&str] = &[
9913 "split_total_count",
9914 "splitTotalCount",
9915 "split_backfilled_count",
9916 "splitBackfilledCount",
9917 "split_completed_count",
9918 "splitCompletedCount",
9919 ];
9920
9921 #[allow(clippy::enum_variant_names)]
9922 enum GeneratedField {
9923 SplitTotalCount,
9924 SplitBackfilledCount,
9925 SplitCompletedCount,
9926 }
9927 impl<'de> serde::Deserialize<'de> for GeneratedField {
9928 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9929 where
9930 D: serde::Deserializer<'de>,
9931 {
9932 struct GeneratedVisitor;
9933
9934 impl serde::de::Visitor<'_> for GeneratedVisitor {
9935 type Value = GeneratedField;
9936
9937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9938 write!(formatter, "expected one of: {:?}", &FIELDS)
9939 }
9940
9941 #[allow(unused_variables)]
9942 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9943 where
9944 E: serde::de::Error,
9945 {
9946 match value {
9947 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
9948 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
9949 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
9950 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9951 }
9952 }
9953 }
9954 deserializer.deserialize_identifier(GeneratedVisitor)
9955 }
9956 }
9957 struct GeneratedVisitor;
9958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9959 type Value = list_cdc_progress_response::CdcProgress;
9960
9961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9962 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
9963 }
9964
9965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
9966 where
9967 V: serde::de::MapAccess<'de>,
9968 {
9969 let mut split_total_count__ = None;
9970 let mut split_backfilled_count__ = None;
9971 let mut split_completed_count__ = None;
9972 while let Some(k) = map_.next_key()? {
9973 match k {
9974 GeneratedField::SplitTotalCount => {
9975 if split_total_count__.is_some() {
9976 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9977 }
9978 split_total_count__ =
9979 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9980 ;
9981 }
9982 GeneratedField::SplitBackfilledCount => {
9983 if split_backfilled_count__.is_some() {
9984 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9985 }
9986 split_backfilled_count__ =
9987 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9988 ;
9989 }
9990 GeneratedField::SplitCompletedCount => {
9991 if split_completed_count__.is_some() {
9992 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9993 }
9994 split_completed_count__ =
9995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9996 ;
9997 }
9998 }
9999 }
10000 Ok(list_cdc_progress_response::CdcProgress {
10001 split_total_count: split_total_count__.unwrap_or_default(),
10002 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
10003 split_completed_count: split_completed_count__.unwrap_or_default(),
10004 })
10005 }
10006 }
10007 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
10008 }
10009}
10010impl serde::Serialize for ListCreatingFragmentDistributionRequest {
10011 #[allow(deprecated)]
10012 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10013 where
10014 S: serde::Serializer,
10015 {
10016 use serde::ser::SerializeStruct;
10017 let mut len = 0;
10018 if self.include_node.is_some() {
10019 len += 1;
10020 }
10021 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
10022 if let Some(v) = self.include_node.as_ref() {
10023 struct_ser.serialize_field("includeNode", v)?;
10024 }
10025 struct_ser.end()
10026 }
10027}
10028impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
10029 #[allow(deprecated)]
10030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10031 where
10032 D: serde::Deserializer<'de>,
10033 {
10034 const FIELDS: &[&str] = &[
10035 "include_node",
10036 "includeNode",
10037 ];
10038
10039 #[allow(clippy::enum_variant_names)]
10040 enum GeneratedField {
10041 IncludeNode,
10042 }
10043 impl<'de> serde::Deserialize<'de> for GeneratedField {
10044 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10045 where
10046 D: serde::Deserializer<'de>,
10047 {
10048 struct GeneratedVisitor;
10049
10050 impl serde::de::Visitor<'_> for GeneratedVisitor {
10051 type Value = GeneratedField;
10052
10053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10054 write!(formatter, "expected one of: {:?}", &FIELDS)
10055 }
10056
10057 #[allow(unused_variables)]
10058 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10059 where
10060 E: serde::de::Error,
10061 {
10062 match value {
10063 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10064 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10065 }
10066 }
10067 }
10068 deserializer.deserialize_identifier(GeneratedVisitor)
10069 }
10070 }
10071 struct GeneratedVisitor;
10072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10073 type Value = ListCreatingFragmentDistributionRequest;
10074
10075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10076 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
10077 }
10078
10079 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
10080 where
10081 V: serde::de::MapAccess<'de>,
10082 {
10083 let mut include_node__ = None;
10084 while let Some(k) = map_.next_key()? {
10085 match k {
10086 GeneratedField::IncludeNode => {
10087 if include_node__.is_some() {
10088 return Err(serde::de::Error::duplicate_field("includeNode"));
10089 }
10090 include_node__ = map_.next_value()?;
10091 }
10092 }
10093 }
10094 Ok(ListCreatingFragmentDistributionRequest {
10095 include_node: include_node__,
10096 })
10097 }
10098 }
10099 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10100 }
10101}
10102impl serde::Serialize for ListCreatingFragmentDistributionResponse {
10103 #[allow(deprecated)]
10104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10105 where
10106 S: serde::Serializer,
10107 {
10108 use serde::ser::SerializeStruct;
10109 let mut len = 0;
10110 if !self.distributions.is_empty() {
10111 len += 1;
10112 }
10113 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
10114 if !self.distributions.is_empty() {
10115 struct_ser.serialize_field("distributions", &self.distributions)?;
10116 }
10117 struct_ser.end()
10118 }
10119}
10120impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
10121 #[allow(deprecated)]
10122 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10123 where
10124 D: serde::Deserializer<'de>,
10125 {
10126 const FIELDS: &[&str] = &[
10127 "distributions",
10128 ];
10129
10130 #[allow(clippy::enum_variant_names)]
10131 enum GeneratedField {
10132 Distributions,
10133 }
10134 impl<'de> serde::Deserialize<'de> for GeneratedField {
10135 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10136 where
10137 D: serde::Deserializer<'de>,
10138 {
10139 struct GeneratedVisitor;
10140
10141 impl serde::de::Visitor<'_> for GeneratedVisitor {
10142 type Value = GeneratedField;
10143
10144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10145 write!(formatter, "expected one of: {:?}", &FIELDS)
10146 }
10147
10148 #[allow(unused_variables)]
10149 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10150 where
10151 E: serde::de::Error,
10152 {
10153 match value {
10154 "distributions" => Ok(GeneratedField::Distributions),
10155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10156 }
10157 }
10158 }
10159 deserializer.deserialize_identifier(GeneratedVisitor)
10160 }
10161 }
10162 struct GeneratedVisitor;
10163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10164 type Value = ListCreatingFragmentDistributionResponse;
10165
10166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10167 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
10168 }
10169
10170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
10171 where
10172 V: serde::de::MapAccess<'de>,
10173 {
10174 let mut distributions__ = None;
10175 while let Some(k) = map_.next_key()? {
10176 match k {
10177 GeneratedField::Distributions => {
10178 if distributions__.is_some() {
10179 return Err(serde::de::Error::duplicate_field("distributions"));
10180 }
10181 distributions__ = Some(map_.next_value()?);
10182 }
10183 }
10184 }
10185 Ok(ListCreatingFragmentDistributionResponse {
10186 distributions: distributions__.unwrap_or_default(),
10187 })
10188 }
10189 }
10190 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10191 }
10192}
10193impl serde::Serialize for ListEventLogRequest {
10194 #[allow(deprecated)]
10195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10196 where
10197 S: serde::Serializer,
10198 {
10199 use serde::ser::SerializeStruct;
10200 let len = 0;
10201 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
10202 struct_ser.end()
10203 }
10204}
10205impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
10206 #[allow(deprecated)]
10207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10208 where
10209 D: serde::Deserializer<'de>,
10210 {
10211 const FIELDS: &[&str] = &[
10212 ];
10213
10214 #[allow(clippy::enum_variant_names)]
10215 enum GeneratedField {
10216 }
10217 impl<'de> serde::Deserialize<'de> for GeneratedField {
10218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10219 where
10220 D: serde::Deserializer<'de>,
10221 {
10222 struct GeneratedVisitor;
10223
10224 impl serde::de::Visitor<'_> for GeneratedVisitor {
10225 type Value = GeneratedField;
10226
10227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10228 write!(formatter, "expected one of: {:?}", &FIELDS)
10229 }
10230
10231 #[allow(unused_variables)]
10232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10233 where
10234 E: serde::de::Error,
10235 {
10236 Err(serde::de::Error::unknown_field(value, FIELDS))
10237 }
10238 }
10239 deserializer.deserialize_identifier(GeneratedVisitor)
10240 }
10241 }
10242 struct GeneratedVisitor;
10243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10244 type Value = ListEventLogRequest;
10245
10246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10247 formatter.write_str("struct meta.ListEventLogRequest")
10248 }
10249
10250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
10251 where
10252 V: serde::de::MapAccess<'de>,
10253 {
10254 while map_.next_key::<GeneratedField>()?.is_some() {
10255 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10256 }
10257 Ok(ListEventLogRequest {
10258 })
10259 }
10260 }
10261 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
10262 }
10263}
10264impl serde::Serialize for ListEventLogResponse {
10265 #[allow(deprecated)]
10266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10267 where
10268 S: serde::Serializer,
10269 {
10270 use serde::ser::SerializeStruct;
10271 let mut len = 0;
10272 if !self.event_logs.is_empty() {
10273 len += 1;
10274 }
10275 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
10276 if !self.event_logs.is_empty() {
10277 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
10278 }
10279 struct_ser.end()
10280 }
10281}
10282impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
10283 #[allow(deprecated)]
10284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10285 where
10286 D: serde::Deserializer<'de>,
10287 {
10288 const FIELDS: &[&str] = &[
10289 "event_logs",
10290 "eventLogs",
10291 ];
10292
10293 #[allow(clippy::enum_variant_names)]
10294 enum GeneratedField {
10295 EventLogs,
10296 }
10297 impl<'de> serde::Deserialize<'de> for GeneratedField {
10298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10299 where
10300 D: serde::Deserializer<'de>,
10301 {
10302 struct GeneratedVisitor;
10303
10304 impl serde::de::Visitor<'_> for GeneratedVisitor {
10305 type Value = GeneratedField;
10306
10307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10308 write!(formatter, "expected one of: {:?}", &FIELDS)
10309 }
10310
10311 #[allow(unused_variables)]
10312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10313 where
10314 E: serde::de::Error,
10315 {
10316 match value {
10317 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
10318 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10319 }
10320 }
10321 }
10322 deserializer.deserialize_identifier(GeneratedVisitor)
10323 }
10324 }
10325 struct GeneratedVisitor;
10326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10327 type Value = ListEventLogResponse;
10328
10329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10330 formatter.write_str("struct meta.ListEventLogResponse")
10331 }
10332
10333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
10334 where
10335 V: serde::de::MapAccess<'de>,
10336 {
10337 let mut event_logs__ = None;
10338 while let Some(k) = map_.next_key()? {
10339 match k {
10340 GeneratedField::EventLogs => {
10341 if event_logs__.is_some() {
10342 return Err(serde::de::Error::duplicate_field("eventLogs"));
10343 }
10344 event_logs__ = Some(map_.next_value()?);
10345 }
10346 }
10347 }
10348 Ok(ListEventLogResponse {
10349 event_logs: event_logs__.unwrap_or_default(),
10350 })
10351 }
10352 }
10353 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
10354 }
10355}
10356impl serde::Serialize for ListFragmentDistributionRequest {
10357 #[allow(deprecated)]
10358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10359 where
10360 S: serde::Serializer,
10361 {
10362 use serde::ser::SerializeStruct;
10363 let mut len = 0;
10364 if self.include_node.is_some() {
10365 len += 1;
10366 }
10367 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
10368 if let Some(v) = self.include_node.as_ref() {
10369 struct_ser.serialize_field("includeNode", v)?;
10370 }
10371 struct_ser.end()
10372 }
10373}
10374impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
10375 #[allow(deprecated)]
10376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10377 where
10378 D: serde::Deserializer<'de>,
10379 {
10380 const FIELDS: &[&str] = &[
10381 "include_node",
10382 "includeNode",
10383 ];
10384
10385 #[allow(clippy::enum_variant_names)]
10386 enum GeneratedField {
10387 IncludeNode,
10388 }
10389 impl<'de> serde::Deserialize<'de> for GeneratedField {
10390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10391 where
10392 D: serde::Deserializer<'de>,
10393 {
10394 struct GeneratedVisitor;
10395
10396 impl serde::de::Visitor<'_> for GeneratedVisitor {
10397 type Value = GeneratedField;
10398
10399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10400 write!(formatter, "expected one of: {:?}", &FIELDS)
10401 }
10402
10403 #[allow(unused_variables)]
10404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10405 where
10406 E: serde::de::Error,
10407 {
10408 match value {
10409 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10411 }
10412 }
10413 }
10414 deserializer.deserialize_identifier(GeneratedVisitor)
10415 }
10416 }
10417 struct GeneratedVisitor;
10418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10419 type Value = ListFragmentDistributionRequest;
10420
10421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10422 formatter.write_str("struct meta.ListFragmentDistributionRequest")
10423 }
10424
10425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
10426 where
10427 V: serde::de::MapAccess<'de>,
10428 {
10429 let mut include_node__ = None;
10430 while let Some(k) = map_.next_key()? {
10431 match k {
10432 GeneratedField::IncludeNode => {
10433 if include_node__.is_some() {
10434 return Err(serde::de::Error::duplicate_field("includeNode"));
10435 }
10436 include_node__ = map_.next_value()?;
10437 }
10438 }
10439 }
10440 Ok(ListFragmentDistributionRequest {
10441 include_node: include_node__,
10442 })
10443 }
10444 }
10445 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10446 }
10447}
10448impl serde::Serialize for ListFragmentDistributionResponse {
10449 #[allow(deprecated)]
10450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10451 where
10452 S: serde::Serializer,
10453 {
10454 use serde::ser::SerializeStruct;
10455 let mut len = 0;
10456 if !self.distributions.is_empty() {
10457 len += 1;
10458 }
10459 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
10460 if !self.distributions.is_empty() {
10461 struct_ser.serialize_field("distributions", &self.distributions)?;
10462 }
10463 struct_ser.end()
10464 }
10465}
10466impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
10467 #[allow(deprecated)]
10468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10469 where
10470 D: serde::Deserializer<'de>,
10471 {
10472 const FIELDS: &[&str] = &[
10473 "distributions",
10474 ];
10475
10476 #[allow(clippy::enum_variant_names)]
10477 enum GeneratedField {
10478 Distributions,
10479 }
10480 impl<'de> serde::Deserialize<'de> for GeneratedField {
10481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10482 where
10483 D: serde::Deserializer<'de>,
10484 {
10485 struct GeneratedVisitor;
10486
10487 impl serde::de::Visitor<'_> for GeneratedVisitor {
10488 type Value = GeneratedField;
10489
10490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10491 write!(formatter, "expected one of: {:?}", &FIELDS)
10492 }
10493
10494 #[allow(unused_variables)]
10495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10496 where
10497 E: serde::de::Error,
10498 {
10499 match value {
10500 "distributions" => Ok(GeneratedField::Distributions),
10501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10502 }
10503 }
10504 }
10505 deserializer.deserialize_identifier(GeneratedVisitor)
10506 }
10507 }
10508 struct GeneratedVisitor;
10509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10510 type Value = ListFragmentDistributionResponse;
10511
10512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10513 formatter.write_str("struct meta.ListFragmentDistributionResponse")
10514 }
10515
10516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
10517 where
10518 V: serde::de::MapAccess<'de>,
10519 {
10520 let mut distributions__ = None;
10521 while let Some(k) = map_.next_key()? {
10522 match k {
10523 GeneratedField::Distributions => {
10524 if distributions__.is_some() {
10525 return Err(serde::de::Error::duplicate_field("distributions"));
10526 }
10527 distributions__ = Some(map_.next_value()?);
10528 }
10529 }
10530 }
10531 Ok(ListFragmentDistributionResponse {
10532 distributions: distributions__.unwrap_or_default(),
10533 })
10534 }
10535 }
10536 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10537 }
10538}
10539impl serde::Serialize for ListIcebergCompactionStatusRequest {
10540 #[allow(deprecated)]
10541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10542 where
10543 S: serde::Serializer,
10544 {
10545 use serde::ser::SerializeStruct;
10546 let len = 0;
10547 let struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusRequest", len)?;
10548 struct_ser.end()
10549 }
10550}
10551impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusRequest {
10552 #[allow(deprecated)]
10553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10554 where
10555 D: serde::Deserializer<'de>,
10556 {
10557 const FIELDS: &[&str] = &[
10558 ];
10559
10560 #[allow(clippy::enum_variant_names)]
10561 enum GeneratedField {
10562 }
10563 impl<'de> serde::Deserialize<'de> for GeneratedField {
10564 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10565 where
10566 D: serde::Deserializer<'de>,
10567 {
10568 struct GeneratedVisitor;
10569
10570 impl serde::de::Visitor<'_> for GeneratedVisitor {
10571 type Value = GeneratedField;
10572
10573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10574 write!(formatter, "expected one of: {:?}", &FIELDS)
10575 }
10576
10577 #[allow(unused_variables)]
10578 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10579 where
10580 E: serde::de::Error,
10581 {
10582 Err(serde::de::Error::unknown_field(value, FIELDS))
10583 }
10584 }
10585 deserializer.deserialize_identifier(GeneratedVisitor)
10586 }
10587 }
10588 struct GeneratedVisitor;
10589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10590 type Value = ListIcebergCompactionStatusRequest;
10591
10592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10593 formatter.write_str("struct meta.ListIcebergCompactionStatusRequest")
10594 }
10595
10596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusRequest, V::Error>
10597 where
10598 V: serde::de::MapAccess<'de>,
10599 {
10600 while map_.next_key::<GeneratedField>()?.is_some() {
10601 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10602 }
10603 Ok(ListIcebergCompactionStatusRequest {
10604 })
10605 }
10606 }
10607 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusRequest", FIELDS, GeneratedVisitor)
10608 }
10609}
10610impl serde::Serialize for ListIcebergCompactionStatusResponse {
10611 #[allow(deprecated)]
10612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10613 where
10614 S: serde::Serializer,
10615 {
10616 use serde::ser::SerializeStruct;
10617 let mut len = 0;
10618 if !self.statuses.is_empty() {
10619 len += 1;
10620 }
10621 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse", len)?;
10622 if !self.statuses.is_empty() {
10623 struct_ser.serialize_field("statuses", &self.statuses)?;
10624 }
10625 struct_ser.end()
10626 }
10627}
10628impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusResponse {
10629 #[allow(deprecated)]
10630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10631 where
10632 D: serde::Deserializer<'de>,
10633 {
10634 const FIELDS: &[&str] = &[
10635 "statuses",
10636 ];
10637
10638 #[allow(clippy::enum_variant_names)]
10639 enum GeneratedField {
10640 Statuses,
10641 }
10642 impl<'de> serde::Deserialize<'de> for GeneratedField {
10643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10644 where
10645 D: serde::Deserializer<'de>,
10646 {
10647 struct GeneratedVisitor;
10648
10649 impl serde::de::Visitor<'_> for GeneratedVisitor {
10650 type Value = GeneratedField;
10651
10652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10653 write!(formatter, "expected one of: {:?}", &FIELDS)
10654 }
10655
10656 #[allow(unused_variables)]
10657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10658 where
10659 E: serde::de::Error,
10660 {
10661 match value {
10662 "statuses" => Ok(GeneratedField::Statuses),
10663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10664 }
10665 }
10666 }
10667 deserializer.deserialize_identifier(GeneratedVisitor)
10668 }
10669 }
10670 struct GeneratedVisitor;
10671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10672 type Value = ListIcebergCompactionStatusResponse;
10673
10674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10675 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse")
10676 }
10677
10678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusResponse, V::Error>
10679 where
10680 V: serde::de::MapAccess<'de>,
10681 {
10682 let mut statuses__ = None;
10683 while let Some(k) = map_.next_key()? {
10684 match k {
10685 GeneratedField::Statuses => {
10686 if statuses__.is_some() {
10687 return Err(serde::de::Error::duplicate_field("statuses"));
10688 }
10689 statuses__ = Some(map_.next_value()?);
10690 }
10691 }
10692 }
10693 Ok(ListIcebergCompactionStatusResponse {
10694 statuses: statuses__.unwrap_or_default(),
10695 })
10696 }
10697 }
10698 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse", FIELDS, GeneratedVisitor)
10699 }
10700}
10701impl serde::Serialize for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10702 #[allow(deprecated)]
10703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10704 where
10705 S: serde::Serializer,
10706 {
10707 use serde::ser::SerializeStruct;
10708 let mut len = 0;
10709 if self.sink_id != 0 {
10710 len += 1;
10711 }
10712 if !self.task_type.is_empty() {
10713 len += 1;
10714 }
10715 if self.trigger_interval_sec != 0 {
10716 len += 1;
10717 }
10718 if self.trigger_snapshot_count != 0 {
10719 len += 1;
10720 }
10721 if !self.schedule_state.is_empty() {
10722 len += 1;
10723 }
10724 if self.next_compaction_after_sec.is_some() {
10725 len += 1;
10726 }
10727 if self.pending_snapshot_count.is_some() {
10728 len += 1;
10729 }
10730 if self.is_triggerable {
10731 len += 1;
10732 }
10733 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", len)?;
10734 if self.sink_id != 0 {
10735 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10736 }
10737 if !self.task_type.is_empty() {
10738 struct_ser.serialize_field("taskType", &self.task_type)?;
10739 }
10740 if self.trigger_interval_sec != 0 {
10741 #[allow(clippy::needless_borrow)]
10742 #[allow(clippy::needless_borrows_for_generic_args)]
10743 struct_ser.serialize_field("triggerIntervalSec", ToString::to_string(&self.trigger_interval_sec).as_str())?;
10744 }
10745 if self.trigger_snapshot_count != 0 {
10746 #[allow(clippy::needless_borrow)]
10747 #[allow(clippy::needless_borrows_for_generic_args)]
10748 struct_ser.serialize_field("triggerSnapshotCount", ToString::to_string(&self.trigger_snapshot_count).as_str())?;
10749 }
10750 if !self.schedule_state.is_empty() {
10751 struct_ser.serialize_field("scheduleState", &self.schedule_state)?;
10752 }
10753 if let Some(v) = self.next_compaction_after_sec.as_ref() {
10754 #[allow(clippy::needless_borrow)]
10755 #[allow(clippy::needless_borrows_for_generic_args)]
10756 struct_ser.serialize_field("nextCompactionAfterSec", ToString::to_string(&v).as_str())?;
10757 }
10758 if let Some(v) = self.pending_snapshot_count.as_ref() {
10759 #[allow(clippy::needless_borrow)]
10760 #[allow(clippy::needless_borrows_for_generic_args)]
10761 struct_ser.serialize_field("pendingSnapshotCount", ToString::to_string(&v).as_str())?;
10762 }
10763 if self.is_triggerable {
10764 struct_ser.serialize_field("isTriggerable", &self.is_triggerable)?;
10765 }
10766 struct_ser.end()
10767 }
10768}
10769impl<'de> serde::Deserialize<'de> for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10770 #[allow(deprecated)]
10771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10772 where
10773 D: serde::Deserializer<'de>,
10774 {
10775 const FIELDS: &[&str] = &[
10776 "sink_id",
10777 "sinkId",
10778 "task_type",
10779 "taskType",
10780 "trigger_interval_sec",
10781 "triggerIntervalSec",
10782 "trigger_snapshot_count",
10783 "triggerSnapshotCount",
10784 "schedule_state",
10785 "scheduleState",
10786 "next_compaction_after_sec",
10787 "nextCompactionAfterSec",
10788 "pending_snapshot_count",
10789 "pendingSnapshotCount",
10790 "is_triggerable",
10791 "isTriggerable",
10792 ];
10793
10794 #[allow(clippy::enum_variant_names)]
10795 enum GeneratedField {
10796 SinkId,
10797 TaskType,
10798 TriggerIntervalSec,
10799 TriggerSnapshotCount,
10800 ScheduleState,
10801 NextCompactionAfterSec,
10802 PendingSnapshotCount,
10803 IsTriggerable,
10804 }
10805 impl<'de> serde::Deserialize<'de> for GeneratedField {
10806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10807 where
10808 D: serde::Deserializer<'de>,
10809 {
10810 struct GeneratedVisitor;
10811
10812 impl serde::de::Visitor<'_> for GeneratedVisitor {
10813 type Value = GeneratedField;
10814
10815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10816 write!(formatter, "expected one of: {:?}", &FIELDS)
10817 }
10818
10819 #[allow(unused_variables)]
10820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10821 where
10822 E: serde::de::Error,
10823 {
10824 match value {
10825 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10826 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
10827 "triggerIntervalSec" | "trigger_interval_sec" => Ok(GeneratedField::TriggerIntervalSec),
10828 "triggerSnapshotCount" | "trigger_snapshot_count" => Ok(GeneratedField::TriggerSnapshotCount),
10829 "scheduleState" | "schedule_state" => Ok(GeneratedField::ScheduleState),
10830 "nextCompactionAfterSec" | "next_compaction_after_sec" => Ok(GeneratedField::NextCompactionAfterSec),
10831 "pendingSnapshotCount" | "pending_snapshot_count" => Ok(GeneratedField::PendingSnapshotCount),
10832 "isTriggerable" | "is_triggerable" => Ok(GeneratedField::IsTriggerable),
10833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10834 }
10835 }
10836 }
10837 deserializer.deserialize_identifier(GeneratedVisitor)
10838 }
10839 }
10840 struct GeneratedVisitor;
10841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10842 type Value = list_iceberg_compaction_status_response::IcebergCompactionStatus;
10843
10844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10845 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus")
10846 }
10847
10848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_compaction_status_response::IcebergCompactionStatus, V::Error>
10849 where
10850 V: serde::de::MapAccess<'de>,
10851 {
10852 let mut sink_id__ = None;
10853 let mut task_type__ = None;
10854 let mut trigger_interval_sec__ = None;
10855 let mut trigger_snapshot_count__ = None;
10856 let mut schedule_state__ = None;
10857 let mut next_compaction_after_sec__ = None;
10858 let mut pending_snapshot_count__ = None;
10859 let mut is_triggerable__ = None;
10860 while let Some(k) = map_.next_key()? {
10861 match k {
10862 GeneratedField::SinkId => {
10863 if sink_id__.is_some() {
10864 return Err(serde::de::Error::duplicate_field("sinkId"));
10865 }
10866 sink_id__ =
10867 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10868 ;
10869 }
10870 GeneratedField::TaskType => {
10871 if task_type__.is_some() {
10872 return Err(serde::de::Error::duplicate_field("taskType"));
10873 }
10874 task_type__ = Some(map_.next_value()?);
10875 }
10876 GeneratedField::TriggerIntervalSec => {
10877 if trigger_interval_sec__.is_some() {
10878 return Err(serde::de::Error::duplicate_field("triggerIntervalSec"));
10879 }
10880 trigger_interval_sec__ =
10881 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10882 ;
10883 }
10884 GeneratedField::TriggerSnapshotCount => {
10885 if trigger_snapshot_count__.is_some() {
10886 return Err(serde::de::Error::duplicate_field("triggerSnapshotCount"));
10887 }
10888 trigger_snapshot_count__ =
10889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10890 ;
10891 }
10892 GeneratedField::ScheduleState => {
10893 if schedule_state__.is_some() {
10894 return Err(serde::de::Error::duplicate_field("scheduleState"));
10895 }
10896 schedule_state__ = Some(map_.next_value()?);
10897 }
10898 GeneratedField::NextCompactionAfterSec => {
10899 if next_compaction_after_sec__.is_some() {
10900 return Err(serde::de::Error::duplicate_field("nextCompactionAfterSec"));
10901 }
10902 next_compaction_after_sec__ =
10903 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10904 ;
10905 }
10906 GeneratedField::PendingSnapshotCount => {
10907 if pending_snapshot_count__.is_some() {
10908 return Err(serde::de::Error::duplicate_field("pendingSnapshotCount"));
10909 }
10910 pending_snapshot_count__ =
10911 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10912 ;
10913 }
10914 GeneratedField::IsTriggerable => {
10915 if is_triggerable__.is_some() {
10916 return Err(serde::de::Error::duplicate_field("isTriggerable"));
10917 }
10918 is_triggerable__ = Some(map_.next_value()?);
10919 }
10920 }
10921 }
10922 Ok(list_iceberg_compaction_status_response::IcebergCompactionStatus {
10923 sink_id: sink_id__.unwrap_or_default(),
10924 task_type: task_type__.unwrap_or_default(),
10925 trigger_interval_sec: trigger_interval_sec__.unwrap_or_default(),
10926 trigger_snapshot_count: trigger_snapshot_count__.unwrap_or_default(),
10927 schedule_state: schedule_state__.unwrap_or_default(),
10928 next_compaction_after_sec: next_compaction_after_sec__,
10929 pending_snapshot_count: pending_snapshot_count__,
10930 is_triggerable: is_triggerable__.unwrap_or_default(),
10931 })
10932 }
10933 }
10934 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", FIELDS, GeneratedVisitor)
10935 }
10936}
10937impl serde::Serialize for ListIcebergTablesRequest {
10938 #[allow(deprecated)]
10939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10940 where
10941 S: serde::Serializer,
10942 {
10943 use serde::ser::SerializeStruct;
10944 let len = 0;
10945 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
10946 struct_ser.end()
10947 }
10948}
10949impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
10950 #[allow(deprecated)]
10951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10952 where
10953 D: serde::Deserializer<'de>,
10954 {
10955 const FIELDS: &[&str] = &[
10956 ];
10957
10958 #[allow(clippy::enum_variant_names)]
10959 enum GeneratedField {
10960 }
10961 impl<'de> serde::Deserialize<'de> for GeneratedField {
10962 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10963 where
10964 D: serde::Deserializer<'de>,
10965 {
10966 struct GeneratedVisitor;
10967
10968 impl serde::de::Visitor<'_> for GeneratedVisitor {
10969 type Value = GeneratedField;
10970
10971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10972 write!(formatter, "expected one of: {:?}", &FIELDS)
10973 }
10974
10975 #[allow(unused_variables)]
10976 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10977 where
10978 E: serde::de::Error,
10979 {
10980 Err(serde::de::Error::unknown_field(value, FIELDS))
10981 }
10982 }
10983 deserializer.deserialize_identifier(GeneratedVisitor)
10984 }
10985 }
10986 struct GeneratedVisitor;
10987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10988 type Value = ListIcebergTablesRequest;
10989
10990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10991 formatter.write_str("struct meta.ListIcebergTablesRequest")
10992 }
10993
10994 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
10995 where
10996 V: serde::de::MapAccess<'de>,
10997 {
10998 while map_.next_key::<GeneratedField>()?.is_some() {
10999 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11000 }
11001 Ok(ListIcebergTablesRequest {
11002 })
11003 }
11004 }
11005 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
11006 }
11007}
11008impl serde::Serialize for ListIcebergTablesResponse {
11009 #[allow(deprecated)]
11010 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11011 where
11012 S: serde::Serializer,
11013 {
11014 use serde::ser::SerializeStruct;
11015 let mut len = 0;
11016 if !self.iceberg_tables.is_empty() {
11017 len += 1;
11018 }
11019 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
11020 if !self.iceberg_tables.is_empty() {
11021 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
11022 }
11023 struct_ser.end()
11024 }
11025}
11026impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
11027 #[allow(deprecated)]
11028 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11029 where
11030 D: serde::Deserializer<'de>,
11031 {
11032 const FIELDS: &[&str] = &[
11033 "iceberg_tables",
11034 "icebergTables",
11035 ];
11036
11037 #[allow(clippy::enum_variant_names)]
11038 enum GeneratedField {
11039 IcebergTables,
11040 }
11041 impl<'de> serde::Deserialize<'de> for GeneratedField {
11042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11043 where
11044 D: serde::Deserializer<'de>,
11045 {
11046 struct GeneratedVisitor;
11047
11048 impl serde::de::Visitor<'_> for GeneratedVisitor {
11049 type Value = GeneratedField;
11050
11051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11052 write!(formatter, "expected one of: {:?}", &FIELDS)
11053 }
11054
11055 #[allow(unused_variables)]
11056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11057 where
11058 E: serde::de::Error,
11059 {
11060 match value {
11061 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
11062 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11063 }
11064 }
11065 }
11066 deserializer.deserialize_identifier(GeneratedVisitor)
11067 }
11068 }
11069 struct GeneratedVisitor;
11070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11071 type Value = ListIcebergTablesResponse;
11072
11073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11074 formatter.write_str("struct meta.ListIcebergTablesResponse")
11075 }
11076
11077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
11078 where
11079 V: serde::de::MapAccess<'de>,
11080 {
11081 let mut iceberg_tables__ = None;
11082 while let Some(k) = map_.next_key()? {
11083 match k {
11084 GeneratedField::IcebergTables => {
11085 if iceberg_tables__.is_some() {
11086 return Err(serde::de::Error::duplicate_field("icebergTables"));
11087 }
11088 iceberg_tables__ = Some(map_.next_value()?);
11089 }
11090 }
11091 }
11092 Ok(ListIcebergTablesResponse {
11093 iceberg_tables: iceberg_tables__.unwrap_or_default(),
11094 })
11095 }
11096 }
11097 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
11098 }
11099}
11100impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
11101 #[allow(deprecated)]
11102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11103 where
11104 S: serde::Serializer,
11105 {
11106 use serde::ser::SerializeStruct;
11107 let mut len = 0;
11108 if !self.catalog_name.is_empty() {
11109 len += 1;
11110 }
11111 if !self.table_namespace.is_empty() {
11112 len += 1;
11113 }
11114 if !self.table_name.is_empty() {
11115 len += 1;
11116 }
11117 if self.metadata_location.is_some() {
11118 len += 1;
11119 }
11120 if self.previous_metadata_location.is_some() {
11121 len += 1;
11122 }
11123 if self.iceberg_type.is_some() {
11124 len += 1;
11125 }
11126 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
11127 if !self.catalog_name.is_empty() {
11128 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
11129 }
11130 if !self.table_namespace.is_empty() {
11131 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
11132 }
11133 if !self.table_name.is_empty() {
11134 struct_ser.serialize_field("tableName", &self.table_name)?;
11135 }
11136 if let Some(v) = self.metadata_location.as_ref() {
11137 struct_ser.serialize_field("metadataLocation", v)?;
11138 }
11139 if let Some(v) = self.previous_metadata_location.as_ref() {
11140 struct_ser.serialize_field("previousMetadataLocation", v)?;
11141 }
11142 if let Some(v) = self.iceberg_type.as_ref() {
11143 struct_ser.serialize_field("icebergType", v)?;
11144 }
11145 struct_ser.end()
11146 }
11147}
11148impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
11149 #[allow(deprecated)]
11150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11151 where
11152 D: serde::Deserializer<'de>,
11153 {
11154 const FIELDS: &[&str] = &[
11155 "catalog_name",
11156 "catalogName",
11157 "table_namespace",
11158 "tableNamespace",
11159 "table_name",
11160 "tableName",
11161 "metadata_location",
11162 "metadataLocation",
11163 "previous_metadata_location",
11164 "previousMetadataLocation",
11165 "iceberg_type",
11166 "icebergType",
11167 ];
11168
11169 #[allow(clippy::enum_variant_names)]
11170 enum GeneratedField {
11171 CatalogName,
11172 TableNamespace,
11173 TableName,
11174 MetadataLocation,
11175 PreviousMetadataLocation,
11176 IcebergType,
11177 }
11178 impl<'de> serde::Deserialize<'de> for GeneratedField {
11179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11180 where
11181 D: serde::Deserializer<'de>,
11182 {
11183 struct GeneratedVisitor;
11184
11185 impl serde::de::Visitor<'_> for GeneratedVisitor {
11186 type Value = GeneratedField;
11187
11188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11189 write!(formatter, "expected one of: {:?}", &FIELDS)
11190 }
11191
11192 #[allow(unused_variables)]
11193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11194 where
11195 E: serde::de::Error,
11196 {
11197 match value {
11198 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
11199 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
11200 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11201 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
11202 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
11203 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
11204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11205 }
11206 }
11207 }
11208 deserializer.deserialize_identifier(GeneratedVisitor)
11209 }
11210 }
11211 struct GeneratedVisitor;
11212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11213 type Value = list_iceberg_tables_response::IcebergTable;
11214
11215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11216 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
11217 }
11218
11219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
11220 where
11221 V: serde::de::MapAccess<'de>,
11222 {
11223 let mut catalog_name__ = None;
11224 let mut table_namespace__ = None;
11225 let mut table_name__ = None;
11226 let mut metadata_location__ = None;
11227 let mut previous_metadata_location__ = None;
11228 let mut iceberg_type__ = None;
11229 while let Some(k) = map_.next_key()? {
11230 match k {
11231 GeneratedField::CatalogName => {
11232 if catalog_name__.is_some() {
11233 return Err(serde::de::Error::duplicate_field("catalogName"));
11234 }
11235 catalog_name__ = Some(map_.next_value()?);
11236 }
11237 GeneratedField::TableNamespace => {
11238 if table_namespace__.is_some() {
11239 return Err(serde::de::Error::duplicate_field("tableNamespace"));
11240 }
11241 table_namespace__ = Some(map_.next_value()?);
11242 }
11243 GeneratedField::TableName => {
11244 if table_name__.is_some() {
11245 return Err(serde::de::Error::duplicate_field("tableName"));
11246 }
11247 table_name__ = Some(map_.next_value()?);
11248 }
11249 GeneratedField::MetadataLocation => {
11250 if metadata_location__.is_some() {
11251 return Err(serde::de::Error::duplicate_field("metadataLocation"));
11252 }
11253 metadata_location__ = map_.next_value()?;
11254 }
11255 GeneratedField::PreviousMetadataLocation => {
11256 if previous_metadata_location__.is_some() {
11257 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
11258 }
11259 previous_metadata_location__ = map_.next_value()?;
11260 }
11261 GeneratedField::IcebergType => {
11262 if iceberg_type__.is_some() {
11263 return Err(serde::de::Error::duplicate_field("icebergType"));
11264 }
11265 iceberg_type__ = map_.next_value()?;
11266 }
11267 }
11268 }
11269 Ok(list_iceberg_tables_response::IcebergTable {
11270 catalog_name: catalog_name__.unwrap_or_default(),
11271 table_namespace: table_namespace__.unwrap_or_default(),
11272 table_name: table_name__.unwrap_or_default(),
11273 metadata_location: metadata_location__,
11274 previous_metadata_location: previous_metadata_location__,
11275 iceberg_type: iceberg_type__,
11276 })
11277 }
11278 }
11279 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
11280 }
11281}
11282impl serde::Serialize for ListRateLimitsRequest {
11283 #[allow(deprecated)]
11284 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11285 where
11286 S: serde::Serializer,
11287 {
11288 use serde::ser::SerializeStruct;
11289 let len = 0;
11290 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
11291 struct_ser.end()
11292 }
11293}
11294impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
11295 #[allow(deprecated)]
11296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11297 where
11298 D: serde::Deserializer<'de>,
11299 {
11300 const FIELDS: &[&str] = &[
11301 ];
11302
11303 #[allow(clippy::enum_variant_names)]
11304 enum GeneratedField {
11305 }
11306 impl<'de> serde::Deserialize<'de> for GeneratedField {
11307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11308 where
11309 D: serde::Deserializer<'de>,
11310 {
11311 struct GeneratedVisitor;
11312
11313 impl serde::de::Visitor<'_> for GeneratedVisitor {
11314 type Value = GeneratedField;
11315
11316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11317 write!(formatter, "expected one of: {:?}", &FIELDS)
11318 }
11319
11320 #[allow(unused_variables)]
11321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11322 where
11323 E: serde::de::Error,
11324 {
11325 Err(serde::de::Error::unknown_field(value, FIELDS))
11326 }
11327 }
11328 deserializer.deserialize_identifier(GeneratedVisitor)
11329 }
11330 }
11331 struct GeneratedVisitor;
11332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11333 type Value = ListRateLimitsRequest;
11334
11335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11336 formatter.write_str("struct meta.ListRateLimitsRequest")
11337 }
11338
11339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
11340 where
11341 V: serde::de::MapAccess<'de>,
11342 {
11343 while map_.next_key::<GeneratedField>()?.is_some() {
11344 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11345 }
11346 Ok(ListRateLimitsRequest {
11347 })
11348 }
11349 }
11350 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
11351 }
11352}
11353impl serde::Serialize for ListRateLimitsResponse {
11354 #[allow(deprecated)]
11355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11356 where
11357 S: serde::Serializer,
11358 {
11359 use serde::ser::SerializeStruct;
11360 let mut len = 0;
11361 if !self.rate_limits.is_empty() {
11362 len += 1;
11363 }
11364 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
11365 if !self.rate_limits.is_empty() {
11366 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
11367 }
11368 struct_ser.end()
11369 }
11370}
11371impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
11372 #[allow(deprecated)]
11373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11374 where
11375 D: serde::Deserializer<'de>,
11376 {
11377 const FIELDS: &[&str] = &[
11378 "rate_limits",
11379 "rateLimits",
11380 ];
11381
11382 #[allow(clippy::enum_variant_names)]
11383 enum GeneratedField {
11384 RateLimits,
11385 }
11386 impl<'de> serde::Deserialize<'de> for GeneratedField {
11387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11388 where
11389 D: serde::Deserializer<'de>,
11390 {
11391 struct GeneratedVisitor;
11392
11393 impl serde::de::Visitor<'_> for GeneratedVisitor {
11394 type Value = GeneratedField;
11395
11396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11397 write!(formatter, "expected one of: {:?}", &FIELDS)
11398 }
11399
11400 #[allow(unused_variables)]
11401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11402 where
11403 E: serde::de::Error,
11404 {
11405 match value {
11406 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
11407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11408 }
11409 }
11410 }
11411 deserializer.deserialize_identifier(GeneratedVisitor)
11412 }
11413 }
11414 struct GeneratedVisitor;
11415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11416 type Value = ListRateLimitsResponse;
11417
11418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11419 formatter.write_str("struct meta.ListRateLimitsResponse")
11420 }
11421
11422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
11423 where
11424 V: serde::de::MapAccess<'de>,
11425 {
11426 let mut rate_limits__ = None;
11427 while let Some(k) = map_.next_key()? {
11428 match k {
11429 GeneratedField::RateLimits => {
11430 if rate_limits__.is_some() {
11431 return Err(serde::de::Error::duplicate_field("rateLimits"));
11432 }
11433 rate_limits__ = Some(map_.next_value()?);
11434 }
11435 }
11436 }
11437 Ok(ListRateLimitsResponse {
11438 rate_limits: rate_limits__.unwrap_or_default(),
11439 })
11440 }
11441 }
11442 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
11443 }
11444}
11445impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
11446 #[allow(deprecated)]
11447 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11448 where
11449 S: serde::Serializer,
11450 {
11451 use serde::ser::SerializeStruct;
11452 let mut len = 0;
11453 if self.fragment_id != 0 {
11454 len += 1;
11455 }
11456 if self.job_id != 0 {
11457 len += 1;
11458 }
11459 if self.fragment_type_mask != 0 {
11460 len += 1;
11461 }
11462 if self.rate_limit != 0 {
11463 len += 1;
11464 }
11465 if !self.node_name.is_empty() {
11466 len += 1;
11467 }
11468 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
11469 if self.fragment_id != 0 {
11470 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11471 }
11472 if self.job_id != 0 {
11473 struct_ser.serialize_field("jobId", &self.job_id)?;
11474 }
11475 if self.fragment_type_mask != 0 {
11476 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11477 }
11478 if self.rate_limit != 0 {
11479 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
11480 }
11481 if !self.node_name.is_empty() {
11482 struct_ser.serialize_field("nodeName", &self.node_name)?;
11483 }
11484 struct_ser.end()
11485 }
11486}
11487impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
11488 #[allow(deprecated)]
11489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11490 where
11491 D: serde::Deserializer<'de>,
11492 {
11493 const FIELDS: &[&str] = &[
11494 "fragment_id",
11495 "fragmentId",
11496 "job_id",
11497 "jobId",
11498 "fragment_type_mask",
11499 "fragmentTypeMask",
11500 "rate_limit",
11501 "rateLimit",
11502 "node_name",
11503 "nodeName",
11504 ];
11505
11506 #[allow(clippy::enum_variant_names)]
11507 enum GeneratedField {
11508 FragmentId,
11509 JobId,
11510 FragmentTypeMask,
11511 RateLimit,
11512 NodeName,
11513 }
11514 impl<'de> serde::Deserialize<'de> for GeneratedField {
11515 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11516 where
11517 D: serde::Deserializer<'de>,
11518 {
11519 struct GeneratedVisitor;
11520
11521 impl serde::de::Visitor<'_> for GeneratedVisitor {
11522 type Value = GeneratedField;
11523
11524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525 write!(formatter, "expected one of: {:?}", &FIELDS)
11526 }
11527
11528 #[allow(unused_variables)]
11529 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11530 where
11531 E: serde::de::Error,
11532 {
11533 match value {
11534 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11535 "jobId" | "job_id" => Ok(GeneratedField::JobId),
11536 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11537 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11538 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
11539 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11540 }
11541 }
11542 }
11543 deserializer.deserialize_identifier(GeneratedVisitor)
11544 }
11545 }
11546 struct GeneratedVisitor;
11547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11548 type Value = list_rate_limits_response::RateLimitInfo;
11549
11550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11551 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
11552 }
11553
11554 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
11555 where
11556 V: serde::de::MapAccess<'de>,
11557 {
11558 let mut fragment_id__ = None;
11559 let mut job_id__ = None;
11560 let mut fragment_type_mask__ = None;
11561 let mut rate_limit__ = None;
11562 let mut node_name__ = None;
11563 while let Some(k) = map_.next_key()? {
11564 match k {
11565 GeneratedField::FragmentId => {
11566 if fragment_id__.is_some() {
11567 return Err(serde::de::Error::duplicate_field("fragmentId"));
11568 }
11569 fragment_id__ =
11570 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11571 ;
11572 }
11573 GeneratedField::JobId => {
11574 if job_id__.is_some() {
11575 return Err(serde::de::Error::duplicate_field("jobId"));
11576 }
11577 job_id__ =
11578 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11579 ;
11580 }
11581 GeneratedField::FragmentTypeMask => {
11582 if fragment_type_mask__.is_some() {
11583 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11584 }
11585 fragment_type_mask__ =
11586 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11587 ;
11588 }
11589 GeneratedField::RateLimit => {
11590 if rate_limit__.is_some() {
11591 return Err(serde::de::Error::duplicate_field("rateLimit"));
11592 }
11593 rate_limit__ =
11594 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11595 ;
11596 }
11597 GeneratedField::NodeName => {
11598 if node_name__.is_some() {
11599 return Err(serde::de::Error::duplicate_field("nodeName"));
11600 }
11601 node_name__ = Some(map_.next_value()?);
11602 }
11603 }
11604 }
11605 Ok(list_rate_limits_response::RateLimitInfo {
11606 fragment_id: fragment_id__.unwrap_or_default(),
11607 job_id: job_id__.unwrap_or_default(),
11608 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11609 rate_limit: rate_limit__.unwrap_or_default(),
11610 node_name: node_name__.unwrap_or_default(),
11611 })
11612 }
11613 }
11614 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
11615 }
11616}
11617impl serde::Serialize for ListRefreshTableStatesRequest {
11618 #[allow(deprecated)]
11619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11620 where
11621 S: serde::Serializer,
11622 {
11623 use serde::ser::SerializeStruct;
11624 let len = 0;
11625 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
11626 struct_ser.end()
11627 }
11628}
11629impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11630 #[allow(deprecated)]
11631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11632 where
11633 D: serde::Deserializer<'de>,
11634 {
11635 const FIELDS: &[&str] = &[
11636 ];
11637
11638 #[allow(clippy::enum_variant_names)]
11639 enum GeneratedField {
11640 }
11641 impl<'de> serde::Deserialize<'de> for GeneratedField {
11642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11643 where
11644 D: serde::Deserializer<'de>,
11645 {
11646 struct GeneratedVisitor;
11647
11648 impl serde::de::Visitor<'_> for GeneratedVisitor {
11649 type Value = GeneratedField;
11650
11651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652 write!(formatter, "expected one of: {:?}", &FIELDS)
11653 }
11654
11655 #[allow(unused_variables)]
11656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11657 where
11658 E: serde::de::Error,
11659 {
11660 Err(serde::de::Error::unknown_field(value, FIELDS))
11661 }
11662 }
11663 deserializer.deserialize_identifier(GeneratedVisitor)
11664 }
11665 }
11666 struct GeneratedVisitor;
11667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11668 type Value = ListRefreshTableStatesRequest;
11669
11670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11671 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11672 }
11673
11674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11675 where
11676 V: serde::de::MapAccess<'de>,
11677 {
11678 while map_.next_key::<GeneratedField>()?.is_some() {
11679 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11680 }
11681 Ok(ListRefreshTableStatesRequest {
11682 })
11683 }
11684 }
11685 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11686 }
11687}
11688impl serde::Serialize for ListRefreshTableStatesResponse {
11689 #[allow(deprecated)]
11690 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11691 where
11692 S: serde::Serializer,
11693 {
11694 use serde::ser::SerializeStruct;
11695 let mut len = 0;
11696 if !self.states.is_empty() {
11697 len += 1;
11698 }
11699 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11700 if !self.states.is_empty() {
11701 struct_ser.serialize_field("states", &self.states)?;
11702 }
11703 struct_ser.end()
11704 }
11705}
11706impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11707 #[allow(deprecated)]
11708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11709 where
11710 D: serde::Deserializer<'de>,
11711 {
11712 const FIELDS: &[&str] = &[
11713 "states",
11714 ];
11715
11716 #[allow(clippy::enum_variant_names)]
11717 enum GeneratedField {
11718 States,
11719 }
11720 impl<'de> serde::Deserialize<'de> for GeneratedField {
11721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11722 where
11723 D: serde::Deserializer<'de>,
11724 {
11725 struct GeneratedVisitor;
11726
11727 impl serde::de::Visitor<'_> for GeneratedVisitor {
11728 type Value = GeneratedField;
11729
11730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11731 write!(formatter, "expected one of: {:?}", &FIELDS)
11732 }
11733
11734 #[allow(unused_variables)]
11735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11736 where
11737 E: serde::de::Error,
11738 {
11739 match value {
11740 "states" => Ok(GeneratedField::States),
11741 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11742 }
11743 }
11744 }
11745 deserializer.deserialize_identifier(GeneratedVisitor)
11746 }
11747 }
11748 struct GeneratedVisitor;
11749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11750 type Value = ListRefreshTableStatesResponse;
11751
11752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11753 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11754 }
11755
11756 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11757 where
11758 V: serde::de::MapAccess<'de>,
11759 {
11760 let mut states__ = None;
11761 while let Some(k) = map_.next_key()? {
11762 match k {
11763 GeneratedField::States => {
11764 if states__.is_some() {
11765 return Err(serde::de::Error::duplicate_field("states"));
11766 }
11767 states__ = Some(map_.next_value()?);
11768 }
11769 }
11770 }
11771 Ok(ListRefreshTableStatesResponse {
11772 states: states__.unwrap_or_default(),
11773 })
11774 }
11775 }
11776 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11777 }
11778}
11779impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11780 #[allow(deprecated)]
11781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11782 where
11783 S: serde::Serializer,
11784 {
11785 use serde::ser::SerializeStruct;
11786 let mut len = 0;
11787 if self.table_id != 0 {
11788 len += 1;
11789 }
11790 if !self.current_status.is_empty() {
11791 len += 1;
11792 }
11793 if self.last_trigger_time.is_some() {
11794 len += 1;
11795 }
11796 if self.trigger_interval_secs.is_some() {
11797 len += 1;
11798 }
11799 if self.last_success_time.is_some() {
11800 len += 1;
11801 }
11802 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11803 if self.table_id != 0 {
11804 struct_ser.serialize_field("tableId", &self.table_id)?;
11805 }
11806 if !self.current_status.is_empty() {
11807 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11808 }
11809 if let Some(v) = self.last_trigger_time.as_ref() {
11810 struct_ser.serialize_field("lastTriggerTime", v)?;
11811 }
11812 if let Some(v) = self.trigger_interval_secs.as_ref() {
11813 #[allow(clippy::needless_borrow)]
11814 #[allow(clippy::needless_borrows_for_generic_args)]
11815 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11816 }
11817 if let Some(v) = self.last_success_time.as_ref() {
11818 struct_ser.serialize_field("lastSuccessTime", v)?;
11819 }
11820 struct_ser.end()
11821 }
11822}
11823impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11824 #[allow(deprecated)]
11825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11826 where
11827 D: serde::Deserializer<'de>,
11828 {
11829 const FIELDS: &[&str] = &[
11830 "table_id",
11831 "tableId",
11832 "current_status",
11833 "currentStatus",
11834 "last_trigger_time",
11835 "lastTriggerTime",
11836 "trigger_interval_secs",
11837 "triggerIntervalSecs",
11838 "last_success_time",
11839 "lastSuccessTime",
11840 ];
11841
11842 #[allow(clippy::enum_variant_names)]
11843 enum GeneratedField {
11844 TableId,
11845 CurrentStatus,
11846 LastTriggerTime,
11847 TriggerIntervalSecs,
11848 LastSuccessTime,
11849 }
11850 impl<'de> serde::Deserialize<'de> for GeneratedField {
11851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11852 where
11853 D: serde::Deserializer<'de>,
11854 {
11855 struct GeneratedVisitor;
11856
11857 impl serde::de::Visitor<'_> for GeneratedVisitor {
11858 type Value = GeneratedField;
11859
11860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11861 write!(formatter, "expected one of: {:?}", &FIELDS)
11862 }
11863
11864 #[allow(unused_variables)]
11865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11866 where
11867 E: serde::de::Error,
11868 {
11869 match value {
11870 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11871 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11872 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11873 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11874 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11875 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11876 }
11877 }
11878 }
11879 deserializer.deserialize_identifier(GeneratedVisitor)
11880 }
11881 }
11882 struct GeneratedVisitor;
11883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11884 type Value = list_refresh_table_states_response::RefreshTableState;
11885
11886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11887 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11888 }
11889
11890 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11891 where
11892 V: serde::de::MapAccess<'de>,
11893 {
11894 let mut table_id__ = None;
11895 let mut current_status__ = None;
11896 let mut last_trigger_time__ = None;
11897 let mut trigger_interval_secs__ = None;
11898 let mut last_success_time__ = None;
11899 while let Some(k) = map_.next_key()? {
11900 match k {
11901 GeneratedField::TableId => {
11902 if table_id__.is_some() {
11903 return Err(serde::de::Error::duplicate_field("tableId"));
11904 }
11905 table_id__ =
11906 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11907 ;
11908 }
11909 GeneratedField::CurrentStatus => {
11910 if current_status__.is_some() {
11911 return Err(serde::de::Error::duplicate_field("currentStatus"));
11912 }
11913 current_status__ = Some(map_.next_value()?);
11914 }
11915 GeneratedField::LastTriggerTime => {
11916 if last_trigger_time__.is_some() {
11917 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11918 }
11919 last_trigger_time__ = map_.next_value()?;
11920 }
11921 GeneratedField::TriggerIntervalSecs => {
11922 if trigger_interval_secs__.is_some() {
11923 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11924 }
11925 trigger_interval_secs__ =
11926 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11927 ;
11928 }
11929 GeneratedField::LastSuccessTime => {
11930 if last_success_time__.is_some() {
11931 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11932 }
11933 last_success_time__ = map_.next_value()?;
11934 }
11935 }
11936 }
11937 Ok(list_refresh_table_states_response::RefreshTableState {
11938 table_id: table_id__.unwrap_or_default(),
11939 current_status: current_status__.unwrap_or_default(),
11940 last_trigger_time: last_trigger_time__,
11941 trigger_interval_secs: trigger_interval_secs__,
11942 last_success_time: last_success_time__,
11943 })
11944 }
11945 }
11946 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11947 }
11948}
11949impl serde::Serialize for ListSinkLogStoreTablesRequest {
11950 #[allow(deprecated)]
11951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11952 where
11953 S: serde::Serializer,
11954 {
11955 use serde::ser::SerializeStruct;
11956 let len = 0;
11957 let struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesRequest", len)?;
11958 struct_ser.end()
11959 }
11960}
11961impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesRequest {
11962 #[allow(deprecated)]
11963 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11964 where
11965 D: serde::Deserializer<'de>,
11966 {
11967 const FIELDS: &[&str] = &[
11968 ];
11969
11970 #[allow(clippy::enum_variant_names)]
11971 enum GeneratedField {
11972 }
11973 impl<'de> serde::Deserialize<'de> for GeneratedField {
11974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11975 where
11976 D: serde::Deserializer<'de>,
11977 {
11978 struct GeneratedVisitor;
11979
11980 impl serde::de::Visitor<'_> for GeneratedVisitor {
11981 type Value = GeneratedField;
11982
11983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11984 write!(formatter, "expected one of: {:?}", &FIELDS)
11985 }
11986
11987 #[allow(unused_variables)]
11988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11989 where
11990 E: serde::de::Error,
11991 {
11992 Err(serde::de::Error::unknown_field(value, FIELDS))
11993 }
11994 }
11995 deserializer.deserialize_identifier(GeneratedVisitor)
11996 }
11997 }
11998 struct GeneratedVisitor;
11999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12000 type Value = ListSinkLogStoreTablesRequest;
12001
12002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12003 formatter.write_str("struct meta.ListSinkLogStoreTablesRequest")
12004 }
12005
12006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesRequest, V::Error>
12007 where
12008 V: serde::de::MapAccess<'de>,
12009 {
12010 while map_.next_key::<GeneratedField>()?.is_some() {
12011 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12012 }
12013 Ok(ListSinkLogStoreTablesRequest {
12014 })
12015 }
12016 }
12017 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesRequest", FIELDS, GeneratedVisitor)
12018 }
12019}
12020impl serde::Serialize for ListSinkLogStoreTablesResponse {
12021 #[allow(deprecated)]
12022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12023 where
12024 S: serde::Serializer,
12025 {
12026 use serde::ser::SerializeStruct;
12027 let mut len = 0;
12028 if !self.tables.is_empty() {
12029 len += 1;
12030 }
12031 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse", len)?;
12032 if !self.tables.is_empty() {
12033 struct_ser.serialize_field("tables", &self.tables)?;
12034 }
12035 struct_ser.end()
12036 }
12037}
12038impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesResponse {
12039 #[allow(deprecated)]
12040 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12041 where
12042 D: serde::Deserializer<'de>,
12043 {
12044 const FIELDS: &[&str] = &[
12045 "tables",
12046 ];
12047
12048 #[allow(clippy::enum_variant_names)]
12049 enum GeneratedField {
12050 Tables,
12051 }
12052 impl<'de> serde::Deserialize<'de> for GeneratedField {
12053 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12054 where
12055 D: serde::Deserializer<'de>,
12056 {
12057 struct GeneratedVisitor;
12058
12059 impl serde::de::Visitor<'_> for GeneratedVisitor {
12060 type Value = GeneratedField;
12061
12062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12063 write!(formatter, "expected one of: {:?}", &FIELDS)
12064 }
12065
12066 #[allow(unused_variables)]
12067 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12068 where
12069 E: serde::de::Error,
12070 {
12071 match value {
12072 "tables" => Ok(GeneratedField::Tables),
12073 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12074 }
12075 }
12076 }
12077 deserializer.deserialize_identifier(GeneratedVisitor)
12078 }
12079 }
12080 struct GeneratedVisitor;
12081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12082 type Value = ListSinkLogStoreTablesResponse;
12083
12084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12085 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse")
12086 }
12087
12088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesResponse, V::Error>
12089 where
12090 V: serde::de::MapAccess<'de>,
12091 {
12092 let mut tables__ = None;
12093 while let Some(k) = map_.next_key()? {
12094 match k {
12095 GeneratedField::Tables => {
12096 if tables__.is_some() {
12097 return Err(serde::de::Error::duplicate_field("tables"));
12098 }
12099 tables__ = Some(map_.next_value()?);
12100 }
12101 }
12102 }
12103 Ok(ListSinkLogStoreTablesResponse {
12104 tables: tables__.unwrap_or_default(),
12105 })
12106 }
12107 }
12108 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse", FIELDS, GeneratedVisitor)
12109 }
12110}
12111impl serde::Serialize for list_sink_log_store_tables_response::SinkLogStoreTable {
12112 #[allow(deprecated)]
12113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12114 where
12115 S: serde::Serializer,
12116 {
12117 use serde::ser::SerializeStruct;
12118 let mut len = 0;
12119 if self.sink_id != 0 {
12120 len += 1;
12121 }
12122 if self.internal_table_id != 0 {
12123 len += 1;
12124 }
12125 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", len)?;
12126 if self.sink_id != 0 {
12127 struct_ser.serialize_field("sinkId", &self.sink_id)?;
12128 }
12129 if self.internal_table_id != 0 {
12130 struct_ser.serialize_field("internalTableId", &self.internal_table_id)?;
12131 }
12132 struct_ser.end()
12133 }
12134}
12135impl<'de> serde::Deserialize<'de> for list_sink_log_store_tables_response::SinkLogStoreTable {
12136 #[allow(deprecated)]
12137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12138 where
12139 D: serde::Deserializer<'de>,
12140 {
12141 const FIELDS: &[&str] = &[
12142 "sink_id",
12143 "sinkId",
12144 "internal_table_id",
12145 "internalTableId",
12146 ];
12147
12148 #[allow(clippy::enum_variant_names)]
12149 enum GeneratedField {
12150 SinkId,
12151 InternalTableId,
12152 }
12153 impl<'de> serde::Deserialize<'de> for GeneratedField {
12154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12155 where
12156 D: serde::Deserializer<'de>,
12157 {
12158 struct GeneratedVisitor;
12159
12160 impl serde::de::Visitor<'_> for GeneratedVisitor {
12161 type Value = GeneratedField;
12162
12163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12164 write!(formatter, "expected one of: {:?}", &FIELDS)
12165 }
12166
12167 #[allow(unused_variables)]
12168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12169 where
12170 E: serde::de::Error,
12171 {
12172 match value {
12173 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
12174 "internalTableId" | "internal_table_id" => Ok(GeneratedField::InternalTableId),
12175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12176 }
12177 }
12178 }
12179 deserializer.deserialize_identifier(GeneratedVisitor)
12180 }
12181 }
12182 struct GeneratedVisitor;
12183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12184 type Value = list_sink_log_store_tables_response::SinkLogStoreTable;
12185
12186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12187 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable")
12188 }
12189
12190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_sink_log_store_tables_response::SinkLogStoreTable, V::Error>
12191 where
12192 V: serde::de::MapAccess<'de>,
12193 {
12194 let mut sink_id__ = None;
12195 let mut internal_table_id__ = None;
12196 while let Some(k) = map_.next_key()? {
12197 match k {
12198 GeneratedField::SinkId => {
12199 if sink_id__.is_some() {
12200 return Err(serde::de::Error::duplicate_field("sinkId"));
12201 }
12202 sink_id__ =
12203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12204 ;
12205 }
12206 GeneratedField::InternalTableId => {
12207 if internal_table_id__.is_some() {
12208 return Err(serde::de::Error::duplicate_field("internalTableId"));
12209 }
12210 internal_table_id__ =
12211 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12212 ;
12213 }
12214 }
12215 }
12216 Ok(list_sink_log_store_tables_response::SinkLogStoreTable {
12217 sink_id: sink_id__.unwrap_or_default(),
12218 internal_table_id: internal_table_id__.unwrap_or_default(),
12219 })
12220 }
12221 }
12222 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", FIELDS, GeneratedVisitor)
12223 }
12224}
12225impl serde::Serialize for ListStreamingJobStatesRequest {
12226 #[allow(deprecated)]
12227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12228 where
12229 S: serde::Serializer,
12230 {
12231 use serde::ser::SerializeStruct;
12232 let len = 0;
12233 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
12234 struct_ser.end()
12235 }
12236}
12237impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
12238 #[allow(deprecated)]
12239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12240 where
12241 D: serde::Deserializer<'de>,
12242 {
12243 const FIELDS: &[&str] = &[
12244 ];
12245
12246 #[allow(clippy::enum_variant_names)]
12247 enum GeneratedField {
12248 }
12249 impl<'de> serde::Deserialize<'de> for GeneratedField {
12250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12251 where
12252 D: serde::Deserializer<'de>,
12253 {
12254 struct GeneratedVisitor;
12255
12256 impl serde::de::Visitor<'_> for GeneratedVisitor {
12257 type Value = GeneratedField;
12258
12259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12260 write!(formatter, "expected one of: {:?}", &FIELDS)
12261 }
12262
12263 #[allow(unused_variables)]
12264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12265 where
12266 E: serde::de::Error,
12267 {
12268 Err(serde::de::Error::unknown_field(value, FIELDS))
12269 }
12270 }
12271 deserializer.deserialize_identifier(GeneratedVisitor)
12272 }
12273 }
12274 struct GeneratedVisitor;
12275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12276 type Value = ListStreamingJobStatesRequest;
12277
12278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12279 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
12280 }
12281
12282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
12283 where
12284 V: serde::de::MapAccess<'de>,
12285 {
12286 while map_.next_key::<GeneratedField>()?.is_some() {
12287 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12288 }
12289 Ok(ListStreamingJobStatesRequest {
12290 })
12291 }
12292 }
12293 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
12294 }
12295}
12296impl serde::Serialize for ListStreamingJobStatesResponse {
12297 #[allow(deprecated)]
12298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12299 where
12300 S: serde::Serializer,
12301 {
12302 use serde::ser::SerializeStruct;
12303 let mut len = 0;
12304 if !self.states.is_empty() {
12305 len += 1;
12306 }
12307 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
12308 if !self.states.is_empty() {
12309 struct_ser.serialize_field("states", &self.states)?;
12310 }
12311 struct_ser.end()
12312 }
12313}
12314impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
12315 #[allow(deprecated)]
12316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12317 where
12318 D: serde::Deserializer<'de>,
12319 {
12320 const FIELDS: &[&str] = &[
12321 "states",
12322 ];
12323
12324 #[allow(clippy::enum_variant_names)]
12325 enum GeneratedField {
12326 States,
12327 }
12328 impl<'de> serde::Deserialize<'de> for GeneratedField {
12329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12330 where
12331 D: serde::Deserializer<'de>,
12332 {
12333 struct GeneratedVisitor;
12334
12335 impl serde::de::Visitor<'_> for GeneratedVisitor {
12336 type Value = GeneratedField;
12337
12338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12339 write!(formatter, "expected one of: {:?}", &FIELDS)
12340 }
12341
12342 #[allow(unused_variables)]
12343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12344 where
12345 E: serde::de::Error,
12346 {
12347 match value {
12348 "states" => Ok(GeneratedField::States),
12349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12350 }
12351 }
12352 }
12353 deserializer.deserialize_identifier(GeneratedVisitor)
12354 }
12355 }
12356 struct GeneratedVisitor;
12357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12358 type Value = ListStreamingJobStatesResponse;
12359
12360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12361 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
12362 }
12363
12364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
12365 where
12366 V: serde::de::MapAccess<'de>,
12367 {
12368 let mut states__ = None;
12369 while let Some(k) = map_.next_key()? {
12370 match k {
12371 GeneratedField::States => {
12372 if states__.is_some() {
12373 return Err(serde::de::Error::duplicate_field("states"));
12374 }
12375 states__ = Some(map_.next_value()?);
12376 }
12377 }
12378 }
12379 Ok(ListStreamingJobStatesResponse {
12380 states: states__.unwrap_or_default(),
12381 })
12382 }
12383 }
12384 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
12385 }
12386}
12387impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
12388 #[allow(deprecated)]
12389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12390 where
12391 S: serde::Serializer,
12392 {
12393 use serde::ser::SerializeStruct;
12394 let mut len = 0;
12395 if self.table_id != 0 {
12396 len += 1;
12397 }
12398 if self.state != 0 {
12399 len += 1;
12400 }
12401 if self.parallelism.is_some() {
12402 len += 1;
12403 }
12404 if self.max_parallelism != 0 {
12405 len += 1;
12406 }
12407 if !self.name.is_empty() {
12408 len += 1;
12409 }
12410 if !self.resource_group.is_empty() {
12411 len += 1;
12412 }
12413 if !self.config_override.is_empty() {
12414 len += 1;
12415 }
12416 if self.database_id != 0 {
12417 len += 1;
12418 }
12419 if self.schema_id != 0 {
12420 len += 1;
12421 }
12422 if self.adaptive_parallelism_strategy.is_some() {
12423 len += 1;
12424 }
12425 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12426 if self.table_id != 0 {
12427 struct_ser.serialize_field("tableId", &self.table_id)?;
12428 }
12429 if self.state != 0 {
12430 let v = table_fragments::State::try_from(self.state)
12431 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12432 struct_ser.serialize_field("state", &v)?;
12433 }
12434 if let Some(v) = self.parallelism.as_ref() {
12435 struct_ser.serialize_field("parallelism", v)?;
12436 }
12437 if self.max_parallelism != 0 {
12438 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12439 }
12440 if !self.name.is_empty() {
12441 struct_ser.serialize_field("name", &self.name)?;
12442 }
12443 if !self.resource_group.is_empty() {
12444 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12445 }
12446 if !self.config_override.is_empty() {
12447 struct_ser.serialize_field("configOverride", &self.config_override)?;
12448 }
12449 if self.database_id != 0 {
12450 struct_ser.serialize_field("databaseId", &self.database_id)?;
12451 }
12452 if self.schema_id != 0 {
12453 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12454 }
12455 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
12456 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
12457 }
12458 struct_ser.end()
12459 }
12460}
12461impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12462 #[allow(deprecated)]
12463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12464 where
12465 D: serde::Deserializer<'de>,
12466 {
12467 const FIELDS: &[&str] = &[
12468 "table_id",
12469 "tableId",
12470 "state",
12471 "parallelism",
12472 "max_parallelism",
12473 "maxParallelism",
12474 "name",
12475 "resource_group",
12476 "resourceGroup",
12477 "config_override",
12478 "configOverride",
12479 "database_id",
12480 "databaseId",
12481 "schema_id",
12482 "schemaId",
12483 "adaptive_parallelism_strategy",
12484 "adaptiveParallelismStrategy",
12485 ];
12486
12487 #[allow(clippy::enum_variant_names)]
12488 enum GeneratedField {
12489 TableId,
12490 State,
12491 Parallelism,
12492 MaxParallelism,
12493 Name,
12494 ResourceGroup,
12495 ConfigOverride,
12496 DatabaseId,
12497 SchemaId,
12498 AdaptiveParallelismStrategy,
12499 }
12500 impl<'de> serde::Deserialize<'de> for GeneratedField {
12501 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12502 where
12503 D: serde::Deserializer<'de>,
12504 {
12505 struct GeneratedVisitor;
12506
12507 impl serde::de::Visitor<'_> for GeneratedVisitor {
12508 type Value = GeneratedField;
12509
12510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12511 write!(formatter, "expected one of: {:?}", &FIELDS)
12512 }
12513
12514 #[allow(unused_variables)]
12515 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12516 where
12517 E: serde::de::Error,
12518 {
12519 match value {
12520 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12521 "state" => Ok(GeneratedField::State),
12522 "parallelism" => Ok(GeneratedField::Parallelism),
12523 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12524 "name" => Ok(GeneratedField::Name),
12525 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12526 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12527 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12528 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12529 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12531 }
12532 }
12533 }
12534 deserializer.deserialize_identifier(GeneratedVisitor)
12535 }
12536 }
12537 struct GeneratedVisitor;
12538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12539 type Value = list_streaming_job_states_response::StreamingJobState;
12540
12541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12542 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12543 }
12544
12545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12546 where
12547 V: serde::de::MapAccess<'de>,
12548 {
12549 let mut table_id__ = None;
12550 let mut state__ = None;
12551 let mut parallelism__ = None;
12552 let mut max_parallelism__ = None;
12553 let mut name__ = None;
12554 let mut resource_group__ = None;
12555 let mut config_override__ = None;
12556 let mut database_id__ = None;
12557 let mut schema_id__ = None;
12558 let mut adaptive_parallelism_strategy__ = None;
12559 while let Some(k) = map_.next_key()? {
12560 match k {
12561 GeneratedField::TableId => {
12562 if table_id__.is_some() {
12563 return Err(serde::de::Error::duplicate_field("tableId"));
12564 }
12565 table_id__ =
12566 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12567 ;
12568 }
12569 GeneratedField::State => {
12570 if state__.is_some() {
12571 return Err(serde::de::Error::duplicate_field("state"));
12572 }
12573 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12574 }
12575 GeneratedField::Parallelism => {
12576 if parallelism__.is_some() {
12577 return Err(serde::de::Error::duplicate_field("parallelism"));
12578 }
12579 parallelism__ = map_.next_value()?;
12580 }
12581 GeneratedField::MaxParallelism => {
12582 if max_parallelism__.is_some() {
12583 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12584 }
12585 max_parallelism__ =
12586 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12587 ;
12588 }
12589 GeneratedField::Name => {
12590 if name__.is_some() {
12591 return Err(serde::de::Error::duplicate_field("name"));
12592 }
12593 name__ = Some(map_.next_value()?);
12594 }
12595 GeneratedField::ResourceGroup => {
12596 if resource_group__.is_some() {
12597 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12598 }
12599 resource_group__ = Some(map_.next_value()?);
12600 }
12601 GeneratedField::ConfigOverride => {
12602 if config_override__.is_some() {
12603 return Err(serde::de::Error::duplicate_field("configOverride"));
12604 }
12605 config_override__ = Some(map_.next_value()?);
12606 }
12607 GeneratedField::DatabaseId => {
12608 if database_id__.is_some() {
12609 return Err(serde::de::Error::duplicate_field("databaseId"));
12610 }
12611 database_id__ =
12612 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12613 ;
12614 }
12615 GeneratedField::SchemaId => {
12616 if schema_id__.is_some() {
12617 return Err(serde::de::Error::duplicate_field("schemaId"));
12618 }
12619 schema_id__ =
12620 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12621 ;
12622 }
12623 GeneratedField::AdaptiveParallelismStrategy => {
12624 if adaptive_parallelism_strategy__.is_some() {
12625 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12626 }
12627 adaptive_parallelism_strategy__ = map_.next_value()?;
12628 }
12629 }
12630 }
12631 Ok(list_streaming_job_states_response::StreamingJobState {
12632 table_id: table_id__.unwrap_or_default(),
12633 state: state__.unwrap_or_default(),
12634 parallelism: parallelism__,
12635 max_parallelism: max_parallelism__.unwrap_or_default(),
12636 name: name__.unwrap_or_default(),
12637 resource_group: resource_group__.unwrap_or_default(),
12638 config_override: config_override__.unwrap_or_default(),
12639 database_id: database_id__.unwrap_or_default(),
12640 schema_id: schema_id__.unwrap_or_default(),
12641 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
12642 })
12643 }
12644 }
12645 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12646 }
12647}
12648impl serde::Serialize for ListTableFragmentsRequest {
12649 #[allow(deprecated)]
12650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12651 where
12652 S: serde::Serializer,
12653 {
12654 use serde::ser::SerializeStruct;
12655 let mut len = 0;
12656 if !self.table_ids.is_empty() {
12657 len += 1;
12658 }
12659 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12660 if !self.table_ids.is_empty() {
12661 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12662 }
12663 struct_ser.end()
12664 }
12665}
12666impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12667 #[allow(deprecated)]
12668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12669 where
12670 D: serde::Deserializer<'de>,
12671 {
12672 const FIELDS: &[&str] = &[
12673 "table_ids",
12674 "tableIds",
12675 ];
12676
12677 #[allow(clippy::enum_variant_names)]
12678 enum GeneratedField {
12679 TableIds,
12680 }
12681 impl<'de> serde::Deserialize<'de> for GeneratedField {
12682 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12683 where
12684 D: serde::Deserializer<'de>,
12685 {
12686 struct GeneratedVisitor;
12687
12688 impl serde::de::Visitor<'_> for GeneratedVisitor {
12689 type Value = GeneratedField;
12690
12691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12692 write!(formatter, "expected one of: {:?}", &FIELDS)
12693 }
12694
12695 #[allow(unused_variables)]
12696 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12697 where
12698 E: serde::de::Error,
12699 {
12700 match value {
12701 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12702 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12703 }
12704 }
12705 }
12706 deserializer.deserialize_identifier(GeneratedVisitor)
12707 }
12708 }
12709 struct GeneratedVisitor;
12710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12711 type Value = ListTableFragmentsRequest;
12712
12713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12714 formatter.write_str("struct meta.ListTableFragmentsRequest")
12715 }
12716
12717 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12718 where
12719 V: serde::de::MapAccess<'de>,
12720 {
12721 let mut table_ids__ = None;
12722 while let Some(k) = map_.next_key()? {
12723 match k {
12724 GeneratedField::TableIds => {
12725 if table_ids__.is_some() {
12726 return Err(serde::de::Error::duplicate_field("tableIds"));
12727 }
12728 table_ids__ =
12729 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12730 .into_iter().map(|x| x.0).collect())
12731 ;
12732 }
12733 }
12734 }
12735 Ok(ListTableFragmentsRequest {
12736 table_ids: table_ids__.unwrap_or_default(),
12737 })
12738 }
12739 }
12740 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12741 }
12742}
12743impl serde::Serialize for ListTableFragmentsResponse {
12744 #[allow(deprecated)]
12745 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12746 where
12747 S: serde::Serializer,
12748 {
12749 use serde::ser::SerializeStruct;
12750 let mut len = 0;
12751 if !self.table_fragments.is_empty() {
12752 len += 1;
12753 }
12754 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12755 if !self.table_fragments.is_empty() {
12756 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12757 }
12758 struct_ser.end()
12759 }
12760}
12761impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12762 #[allow(deprecated)]
12763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12764 where
12765 D: serde::Deserializer<'de>,
12766 {
12767 const FIELDS: &[&str] = &[
12768 "table_fragments",
12769 "tableFragments",
12770 ];
12771
12772 #[allow(clippy::enum_variant_names)]
12773 enum GeneratedField {
12774 TableFragments,
12775 }
12776 impl<'de> serde::Deserialize<'de> for GeneratedField {
12777 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12778 where
12779 D: serde::Deserializer<'de>,
12780 {
12781 struct GeneratedVisitor;
12782
12783 impl serde::de::Visitor<'_> for GeneratedVisitor {
12784 type Value = GeneratedField;
12785
12786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12787 write!(formatter, "expected one of: {:?}", &FIELDS)
12788 }
12789
12790 #[allow(unused_variables)]
12791 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12792 where
12793 E: serde::de::Error,
12794 {
12795 match value {
12796 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
12797 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12798 }
12799 }
12800 }
12801 deserializer.deserialize_identifier(GeneratedVisitor)
12802 }
12803 }
12804 struct GeneratedVisitor;
12805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12806 type Value = ListTableFragmentsResponse;
12807
12808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12809 formatter.write_str("struct meta.ListTableFragmentsResponse")
12810 }
12811
12812 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12813 where
12814 V: serde::de::MapAccess<'de>,
12815 {
12816 let mut table_fragments__ = None;
12817 while let Some(k) = map_.next_key()? {
12818 match k {
12819 GeneratedField::TableFragments => {
12820 if table_fragments__.is_some() {
12821 return Err(serde::de::Error::duplicate_field("tableFragments"));
12822 }
12823 table_fragments__ = Some(
12824 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12825 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12826 );
12827 }
12828 }
12829 }
12830 Ok(ListTableFragmentsResponse {
12831 table_fragments: table_fragments__.unwrap_or_default(),
12832 })
12833 }
12834 }
12835 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
12836 }
12837}
12838impl serde::Serialize for list_table_fragments_response::ActorInfo {
12839 #[allow(deprecated)]
12840 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12841 where
12842 S: serde::Serializer,
12843 {
12844 use serde::ser::SerializeStruct;
12845 let mut len = 0;
12846 if self.id != 0 {
12847 len += 1;
12848 }
12849 if self.node.is_some() {
12850 len += 1;
12851 }
12852 if !self.dispatcher.is_empty() {
12853 len += 1;
12854 }
12855 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
12856 if self.id != 0 {
12857 struct_ser.serialize_field("id", &self.id)?;
12858 }
12859 if let Some(v) = self.node.as_ref() {
12860 struct_ser.serialize_field("node", v)?;
12861 }
12862 if !self.dispatcher.is_empty() {
12863 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12864 }
12865 struct_ser.end()
12866 }
12867}
12868impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
12869 #[allow(deprecated)]
12870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12871 where
12872 D: serde::Deserializer<'de>,
12873 {
12874 const FIELDS: &[&str] = &[
12875 "id",
12876 "node",
12877 "dispatcher",
12878 ];
12879
12880 #[allow(clippy::enum_variant_names)]
12881 enum GeneratedField {
12882 Id,
12883 Node,
12884 Dispatcher,
12885 }
12886 impl<'de> serde::Deserialize<'de> for GeneratedField {
12887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12888 where
12889 D: serde::Deserializer<'de>,
12890 {
12891 struct GeneratedVisitor;
12892
12893 impl serde::de::Visitor<'_> for GeneratedVisitor {
12894 type Value = GeneratedField;
12895
12896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12897 write!(formatter, "expected one of: {:?}", &FIELDS)
12898 }
12899
12900 #[allow(unused_variables)]
12901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12902 where
12903 E: serde::de::Error,
12904 {
12905 match value {
12906 "id" => Ok(GeneratedField::Id),
12907 "node" => Ok(GeneratedField::Node),
12908 "dispatcher" => Ok(GeneratedField::Dispatcher),
12909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12910 }
12911 }
12912 }
12913 deserializer.deserialize_identifier(GeneratedVisitor)
12914 }
12915 }
12916 struct GeneratedVisitor;
12917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12918 type Value = list_table_fragments_response::ActorInfo;
12919
12920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12921 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
12922 }
12923
12924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12925 where
12926 V: serde::de::MapAccess<'de>,
12927 {
12928 let mut id__ = None;
12929 let mut node__ = None;
12930 let mut dispatcher__ = None;
12931 while let Some(k) = map_.next_key()? {
12932 match k {
12933 GeneratedField::Id => {
12934 if id__.is_some() {
12935 return Err(serde::de::Error::duplicate_field("id"));
12936 }
12937 id__ =
12938 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12939 ;
12940 }
12941 GeneratedField::Node => {
12942 if node__.is_some() {
12943 return Err(serde::de::Error::duplicate_field("node"));
12944 }
12945 node__ = map_.next_value()?;
12946 }
12947 GeneratedField::Dispatcher => {
12948 if dispatcher__.is_some() {
12949 return Err(serde::de::Error::duplicate_field("dispatcher"));
12950 }
12951 dispatcher__ = Some(map_.next_value()?);
12952 }
12953 }
12954 }
12955 Ok(list_table_fragments_response::ActorInfo {
12956 id: id__.unwrap_or_default(),
12957 node: node__,
12958 dispatcher: dispatcher__.unwrap_or_default(),
12959 })
12960 }
12961 }
12962 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12963 }
12964}
12965impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12966 #[allow(deprecated)]
12967 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12968 where
12969 S: serde::Serializer,
12970 {
12971 use serde::ser::SerializeStruct;
12972 let mut len = 0;
12973 if self.id != 0 {
12974 len += 1;
12975 }
12976 if !self.actors.is_empty() {
12977 len += 1;
12978 }
12979 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12980 if self.id != 0 {
12981 struct_ser.serialize_field("id", &self.id)?;
12982 }
12983 if !self.actors.is_empty() {
12984 struct_ser.serialize_field("actors", &self.actors)?;
12985 }
12986 struct_ser.end()
12987 }
12988}
12989impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12990 #[allow(deprecated)]
12991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12992 where
12993 D: serde::Deserializer<'de>,
12994 {
12995 const FIELDS: &[&str] = &[
12996 "id",
12997 "actors",
12998 ];
12999
13000 #[allow(clippy::enum_variant_names)]
13001 enum GeneratedField {
13002 Id,
13003 Actors,
13004 }
13005 impl<'de> serde::Deserialize<'de> for GeneratedField {
13006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13007 where
13008 D: serde::Deserializer<'de>,
13009 {
13010 struct GeneratedVisitor;
13011
13012 impl serde::de::Visitor<'_> for GeneratedVisitor {
13013 type Value = GeneratedField;
13014
13015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13016 write!(formatter, "expected one of: {:?}", &FIELDS)
13017 }
13018
13019 #[allow(unused_variables)]
13020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13021 where
13022 E: serde::de::Error,
13023 {
13024 match value {
13025 "id" => Ok(GeneratedField::Id),
13026 "actors" => Ok(GeneratedField::Actors),
13027 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13028 }
13029 }
13030 }
13031 deserializer.deserialize_identifier(GeneratedVisitor)
13032 }
13033 }
13034 struct GeneratedVisitor;
13035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13036 type Value = list_table_fragments_response::FragmentInfo;
13037
13038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13039 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
13040 }
13041
13042 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
13043 where
13044 V: serde::de::MapAccess<'de>,
13045 {
13046 let mut id__ = None;
13047 let mut actors__ = None;
13048 while let Some(k) = map_.next_key()? {
13049 match k {
13050 GeneratedField::Id => {
13051 if id__.is_some() {
13052 return Err(serde::de::Error::duplicate_field("id"));
13053 }
13054 id__ =
13055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13056 ;
13057 }
13058 GeneratedField::Actors => {
13059 if actors__.is_some() {
13060 return Err(serde::de::Error::duplicate_field("actors"));
13061 }
13062 actors__ = Some(map_.next_value()?);
13063 }
13064 }
13065 }
13066 Ok(list_table_fragments_response::FragmentInfo {
13067 id: id__.unwrap_or_default(),
13068 actors: actors__.unwrap_or_default(),
13069 })
13070 }
13071 }
13072 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
13073 }
13074}
13075impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
13076 #[allow(deprecated)]
13077 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13078 where
13079 S: serde::Serializer,
13080 {
13081 use serde::ser::SerializeStruct;
13082 let mut len = 0;
13083 if !self.fragments.is_empty() {
13084 len += 1;
13085 }
13086 if self.ctx.is_some() {
13087 len += 1;
13088 }
13089 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
13090 if !self.fragments.is_empty() {
13091 struct_ser.serialize_field("fragments", &self.fragments)?;
13092 }
13093 if let Some(v) = self.ctx.as_ref() {
13094 struct_ser.serialize_field("ctx", v)?;
13095 }
13096 struct_ser.end()
13097 }
13098}
13099impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
13100 #[allow(deprecated)]
13101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13102 where
13103 D: serde::Deserializer<'de>,
13104 {
13105 const FIELDS: &[&str] = &[
13106 "fragments",
13107 "ctx",
13108 ];
13109
13110 #[allow(clippy::enum_variant_names)]
13111 enum GeneratedField {
13112 Fragments,
13113 Ctx,
13114 }
13115 impl<'de> serde::Deserialize<'de> for GeneratedField {
13116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13117 where
13118 D: serde::Deserializer<'de>,
13119 {
13120 struct GeneratedVisitor;
13121
13122 impl serde::de::Visitor<'_> for GeneratedVisitor {
13123 type Value = GeneratedField;
13124
13125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13126 write!(formatter, "expected one of: {:?}", &FIELDS)
13127 }
13128
13129 #[allow(unused_variables)]
13130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13131 where
13132 E: serde::de::Error,
13133 {
13134 match value {
13135 "fragments" => Ok(GeneratedField::Fragments),
13136 "ctx" => Ok(GeneratedField::Ctx),
13137 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13138 }
13139 }
13140 }
13141 deserializer.deserialize_identifier(GeneratedVisitor)
13142 }
13143 }
13144 struct GeneratedVisitor;
13145 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13146 type Value = list_table_fragments_response::TableFragmentInfo;
13147
13148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13149 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
13150 }
13151
13152 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
13153 where
13154 V: serde::de::MapAccess<'de>,
13155 {
13156 let mut fragments__ = None;
13157 let mut ctx__ = None;
13158 while let Some(k) = map_.next_key()? {
13159 match k {
13160 GeneratedField::Fragments => {
13161 if fragments__.is_some() {
13162 return Err(serde::de::Error::duplicate_field("fragments"));
13163 }
13164 fragments__ = Some(map_.next_value()?);
13165 }
13166 GeneratedField::Ctx => {
13167 if ctx__.is_some() {
13168 return Err(serde::de::Error::duplicate_field("ctx"));
13169 }
13170 ctx__ = map_.next_value()?;
13171 }
13172 }
13173 }
13174 Ok(list_table_fragments_response::TableFragmentInfo {
13175 fragments: fragments__.unwrap_or_default(),
13176 ctx: ctx__,
13177 })
13178 }
13179 }
13180 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
13181 }
13182}
13183impl serde::Serialize for ListUnmigratedTablesRequest {
13184 #[allow(deprecated)]
13185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13186 where
13187 S: serde::Serializer,
13188 {
13189 use serde::ser::SerializeStruct;
13190 let len = 0;
13191 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
13192 struct_ser.end()
13193 }
13194}
13195impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
13196 #[allow(deprecated)]
13197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13198 where
13199 D: serde::Deserializer<'de>,
13200 {
13201 const FIELDS: &[&str] = &[
13202 ];
13203
13204 #[allow(clippy::enum_variant_names)]
13205 enum GeneratedField {
13206 }
13207 impl<'de> serde::Deserialize<'de> for GeneratedField {
13208 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13209 where
13210 D: serde::Deserializer<'de>,
13211 {
13212 struct GeneratedVisitor;
13213
13214 impl serde::de::Visitor<'_> for GeneratedVisitor {
13215 type Value = GeneratedField;
13216
13217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13218 write!(formatter, "expected one of: {:?}", &FIELDS)
13219 }
13220
13221 #[allow(unused_variables)]
13222 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13223 where
13224 E: serde::de::Error,
13225 {
13226 Err(serde::de::Error::unknown_field(value, FIELDS))
13227 }
13228 }
13229 deserializer.deserialize_identifier(GeneratedVisitor)
13230 }
13231 }
13232 struct GeneratedVisitor;
13233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13234 type Value = ListUnmigratedTablesRequest;
13235
13236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13237 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
13238 }
13239
13240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
13241 where
13242 V: serde::de::MapAccess<'de>,
13243 {
13244 while map_.next_key::<GeneratedField>()?.is_some() {
13245 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13246 }
13247 Ok(ListUnmigratedTablesRequest {
13248 })
13249 }
13250 }
13251 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
13252 }
13253}
13254impl serde::Serialize for ListUnmigratedTablesResponse {
13255 #[allow(deprecated)]
13256 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13257 where
13258 S: serde::Serializer,
13259 {
13260 use serde::ser::SerializeStruct;
13261 let mut len = 0;
13262 if !self.tables.is_empty() {
13263 len += 1;
13264 }
13265 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
13266 if !self.tables.is_empty() {
13267 struct_ser.serialize_field("tables", &self.tables)?;
13268 }
13269 struct_ser.end()
13270 }
13271}
13272impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
13273 #[allow(deprecated)]
13274 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13275 where
13276 D: serde::Deserializer<'de>,
13277 {
13278 const FIELDS: &[&str] = &[
13279 "tables",
13280 ];
13281
13282 #[allow(clippy::enum_variant_names)]
13283 enum GeneratedField {
13284 Tables,
13285 }
13286 impl<'de> serde::Deserialize<'de> for GeneratedField {
13287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13288 where
13289 D: serde::Deserializer<'de>,
13290 {
13291 struct GeneratedVisitor;
13292
13293 impl serde::de::Visitor<'_> for GeneratedVisitor {
13294 type Value = GeneratedField;
13295
13296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13297 write!(formatter, "expected one of: {:?}", &FIELDS)
13298 }
13299
13300 #[allow(unused_variables)]
13301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13302 where
13303 E: serde::de::Error,
13304 {
13305 match value {
13306 "tables" => Ok(GeneratedField::Tables),
13307 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13308 }
13309 }
13310 }
13311 deserializer.deserialize_identifier(GeneratedVisitor)
13312 }
13313 }
13314 struct GeneratedVisitor;
13315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13316 type Value = ListUnmigratedTablesResponse;
13317
13318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13319 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
13320 }
13321
13322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
13323 where
13324 V: serde::de::MapAccess<'de>,
13325 {
13326 let mut tables__ = None;
13327 while let Some(k) = map_.next_key()? {
13328 match k {
13329 GeneratedField::Tables => {
13330 if tables__.is_some() {
13331 return Err(serde::de::Error::duplicate_field("tables"));
13332 }
13333 tables__ = Some(map_.next_value()?);
13334 }
13335 }
13336 }
13337 Ok(ListUnmigratedTablesResponse {
13338 tables: tables__.unwrap_or_default(),
13339 })
13340 }
13341 }
13342 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
13343 }
13344}
13345impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
13346 #[allow(deprecated)]
13347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13348 where
13349 S: serde::Serializer,
13350 {
13351 use serde::ser::SerializeStruct;
13352 let mut len = 0;
13353 if self.table_id != 0 {
13354 len += 1;
13355 }
13356 if !self.table_name.is_empty() {
13357 len += 1;
13358 }
13359 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
13360 if self.table_id != 0 {
13361 struct_ser.serialize_field("tableId", &self.table_id)?;
13362 }
13363 if !self.table_name.is_empty() {
13364 struct_ser.serialize_field("tableName", &self.table_name)?;
13365 }
13366 struct_ser.end()
13367 }
13368}
13369impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
13370 #[allow(deprecated)]
13371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13372 where
13373 D: serde::Deserializer<'de>,
13374 {
13375 const FIELDS: &[&str] = &[
13376 "table_id",
13377 "tableId",
13378 "table_name",
13379 "tableName",
13380 ];
13381
13382 #[allow(clippy::enum_variant_names)]
13383 enum GeneratedField {
13384 TableId,
13385 TableName,
13386 }
13387 impl<'de> serde::Deserialize<'de> for GeneratedField {
13388 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13389 where
13390 D: serde::Deserializer<'de>,
13391 {
13392 struct GeneratedVisitor;
13393
13394 impl serde::de::Visitor<'_> for GeneratedVisitor {
13395 type Value = GeneratedField;
13396
13397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13398 write!(formatter, "expected one of: {:?}", &FIELDS)
13399 }
13400
13401 #[allow(unused_variables)]
13402 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13403 where
13404 E: serde::de::Error,
13405 {
13406 match value {
13407 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13408 "tableName" | "table_name" => Ok(GeneratedField::TableName),
13409 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13410 }
13411 }
13412 }
13413 deserializer.deserialize_identifier(GeneratedVisitor)
13414 }
13415 }
13416 struct GeneratedVisitor;
13417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13418 type Value = list_unmigrated_tables_response::UnmigratedTable;
13419
13420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13421 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
13422 }
13423
13424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
13425 where
13426 V: serde::de::MapAccess<'de>,
13427 {
13428 let mut table_id__ = None;
13429 let mut table_name__ = None;
13430 while let Some(k) = map_.next_key()? {
13431 match k {
13432 GeneratedField::TableId => {
13433 if table_id__.is_some() {
13434 return Err(serde::de::Error::duplicate_field("tableId"));
13435 }
13436 table_id__ =
13437 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13438 ;
13439 }
13440 GeneratedField::TableName => {
13441 if table_name__.is_some() {
13442 return Err(serde::de::Error::duplicate_field("tableName"));
13443 }
13444 table_name__ = Some(map_.next_value()?);
13445 }
13446 }
13447 }
13448 Ok(list_unmigrated_tables_response::UnmigratedTable {
13449 table_id: table_id__.unwrap_or_default(),
13450 table_name: table_name__.unwrap_or_default(),
13451 })
13452 }
13453 }
13454 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13455 }
13456}
13457impl serde::Serialize for MembersRequest {
13458 #[allow(deprecated)]
13459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13460 where
13461 S: serde::Serializer,
13462 {
13463 use serde::ser::SerializeStruct;
13464 let len = 0;
13465 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13466 struct_ser.end()
13467 }
13468}
13469impl<'de> serde::Deserialize<'de> for MembersRequest {
13470 #[allow(deprecated)]
13471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13472 where
13473 D: serde::Deserializer<'de>,
13474 {
13475 const FIELDS: &[&str] = &[
13476 ];
13477
13478 #[allow(clippy::enum_variant_names)]
13479 enum GeneratedField {
13480 }
13481 impl<'de> serde::Deserialize<'de> for GeneratedField {
13482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13483 where
13484 D: serde::Deserializer<'de>,
13485 {
13486 struct GeneratedVisitor;
13487
13488 impl serde::de::Visitor<'_> for GeneratedVisitor {
13489 type Value = GeneratedField;
13490
13491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13492 write!(formatter, "expected one of: {:?}", &FIELDS)
13493 }
13494
13495 #[allow(unused_variables)]
13496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13497 where
13498 E: serde::de::Error,
13499 {
13500 Err(serde::de::Error::unknown_field(value, FIELDS))
13501 }
13502 }
13503 deserializer.deserialize_identifier(GeneratedVisitor)
13504 }
13505 }
13506 struct GeneratedVisitor;
13507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13508 type Value = MembersRequest;
13509
13510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13511 formatter.write_str("struct meta.MembersRequest")
13512 }
13513
13514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13515 where
13516 V: serde::de::MapAccess<'de>,
13517 {
13518 while map_.next_key::<GeneratedField>()?.is_some() {
13519 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13520 }
13521 Ok(MembersRequest {
13522 })
13523 }
13524 }
13525 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13526 }
13527}
13528impl serde::Serialize for MembersResponse {
13529 #[allow(deprecated)]
13530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13531 where
13532 S: serde::Serializer,
13533 {
13534 use serde::ser::SerializeStruct;
13535 let mut len = 0;
13536 if !self.members.is_empty() {
13537 len += 1;
13538 }
13539 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13540 if !self.members.is_empty() {
13541 struct_ser.serialize_field("members", &self.members)?;
13542 }
13543 struct_ser.end()
13544 }
13545}
13546impl<'de> serde::Deserialize<'de> for MembersResponse {
13547 #[allow(deprecated)]
13548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13549 where
13550 D: serde::Deserializer<'de>,
13551 {
13552 const FIELDS: &[&str] = &[
13553 "members",
13554 ];
13555
13556 #[allow(clippy::enum_variant_names)]
13557 enum GeneratedField {
13558 Members,
13559 }
13560 impl<'de> serde::Deserialize<'de> for GeneratedField {
13561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13562 where
13563 D: serde::Deserializer<'de>,
13564 {
13565 struct GeneratedVisitor;
13566
13567 impl serde::de::Visitor<'_> for GeneratedVisitor {
13568 type Value = GeneratedField;
13569
13570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13571 write!(formatter, "expected one of: {:?}", &FIELDS)
13572 }
13573
13574 #[allow(unused_variables)]
13575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13576 where
13577 E: serde::de::Error,
13578 {
13579 match value {
13580 "members" => Ok(GeneratedField::Members),
13581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13582 }
13583 }
13584 }
13585 deserializer.deserialize_identifier(GeneratedVisitor)
13586 }
13587 }
13588 struct GeneratedVisitor;
13589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13590 type Value = MembersResponse;
13591
13592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13593 formatter.write_str("struct meta.MembersResponse")
13594 }
13595
13596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13597 where
13598 V: serde::de::MapAccess<'de>,
13599 {
13600 let mut members__ = None;
13601 while let Some(k) = map_.next_key()? {
13602 match k {
13603 GeneratedField::Members => {
13604 if members__.is_some() {
13605 return Err(serde::de::Error::duplicate_field("members"));
13606 }
13607 members__ = Some(map_.next_value()?);
13608 }
13609 }
13610 }
13611 Ok(MembersResponse {
13612 members: members__.unwrap_or_default(),
13613 })
13614 }
13615 }
13616 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13617 }
13618}
13619impl serde::Serialize for MetaMember {
13620 #[allow(deprecated)]
13621 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13622 where
13623 S: serde::Serializer,
13624 {
13625 use serde::ser::SerializeStruct;
13626 let mut len = 0;
13627 if self.address.is_some() {
13628 len += 1;
13629 }
13630 if self.is_leader {
13631 len += 1;
13632 }
13633 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13634 if let Some(v) = self.address.as_ref() {
13635 struct_ser.serialize_field("address", v)?;
13636 }
13637 if self.is_leader {
13638 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13639 }
13640 struct_ser.end()
13641 }
13642}
13643impl<'de> serde::Deserialize<'de> for MetaMember {
13644 #[allow(deprecated)]
13645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13646 where
13647 D: serde::Deserializer<'de>,
13648 {
13649 const FIELDS: &[&str] = &[
13650 "address",
13651 "is_leader",
13652 "isLeader",
13653 ];
13654
13655 #[allow(clippy::enum_variant_names)]
13656 enum GeneratedField {
13657 Address,
13658 IsLeader,
13659 }
13660 impl<'de> serde::Deserialize<'de> for GeneratedField {
13661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13662 where
13663 D: serde::Deserializer<'de>,
13664 {
13665 struct GeneratedVisitor;
13666
13667 impl serde::de::Visitor<'_> for GeneratedVisitor {
13668 type Value = GeneratedField;
13669
13670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13671 write!(formatter, "expected one of: {:?}", &FIELDS)
13672 }
13673
13674 #[allow(unused_variables)]
13675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13676 where
13677 E: serde::de::Error,
13678 {
13679 match value {
13680 "address" => Ok(GeneratedField::Address),
13681 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13683 }
13684 }
13685 }
13686 deserializer.deserialize_identifier(GeneratedVisitor)
13687 }
13688 }
13689 struct GeneratedVisitor;
13690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13691 type Value = MetaMember;
13692
13693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13694 formatter.write_str("struct meta.MetaMember")
13695 }
13696
13697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13698 where
13699 V: serde::de::MapAccess<'de>,
13700 {
13701 let mut address__ = None;
13702 let mut is_leader__ = None;
13703 while let Some(k) = map_.next_key()? {
13704 match k {
13705 GeneratedField::Address => {
13706 if address__.is_some() {
13707 return Err(serde::de::Error::duplicate_field("address"));
13708 }
13709 address__ = map_.next_value()?;
13710 }
13711 GeneratedField::IsLeader => {
13712 if is_leader__.is_some() {
13713 return Err(serde::de::Error::duplicate_field("isLeader"));
13714 }
13715 is_leader__ = Some(map_.next_value()?);
13716 }
13717 }
13718 }
13719 Ok(MetaMember {
13720 address: address__,
13721 is_leader: is_leader__.unwrap_or_default(),
13722 })
13723 }
13724 }
13725 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13726 }
13727}
13728impl serde::Serialize for MetaSnapshot {
13729 #[allow(deprecated)]
13730 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13731 where
13732 S: serde::Serializer,
13733 {
13734 use serde::ser::SerializeStruct;
13735 let mut len = 0;
13736 if !self.databases.is_empty() {
13737 len += 1;
13738 }
13739 if !self.schemas.is_empty() {
13740 len += 1;
13741 }
13742 if !self.sources.is_empty() {
13743 len += 1;
13744 }
13745 if !self.sinks.is_empty() {
13746 len += 1;
13747 }
13748 if !self.tables.is_empty() {
13749 len += 1;
13750 }
13751 if !self.indexes.is_empty() {
13752 len += 1;
13753 }
13754 if !self.views.is_empty() {
13755 len += 1;
13756 }
13757 if !self.functions.is_empty() {
13758 len += 1;
13759 }
13760 if !self.connections.is_empty() {
13761 len += 1;
13762 }
13763 if !self.subscriptions.is_empty() {
13764 len += 1;
13765 }
13766 if !self.users.is_empty() {
13767 len += 1;
13768 }
13769 if self.session_params.is_some() {
13770 len += 1;
13771 }
13772 if !self.secrets.is_empty() {
13773 len += 1;
13774 }
13775 if self.cluster_resource.is_some() {
13776 len += 1;
13777 }
13778 if !self.nodes.is_empty() {
13779 len += 1;
13780 }
13781 if self.hummock_version.is_some() {
13782 len += 1;
13783 }
13784 if self.meta_backup_manifest_id.is_some() {
13785 len += 1;
13786 }
13787 if self.hummock_write_limits.is_some() {
13788 len += 1;
13789 }
13790 if !self.streaming_worker_slot_mappings.is_empty() {
13791 len += 1;
13792 }
13793 if !self.serving_worker_slot_mappings.is_empty() {
13794 len += 1;
13795 }
13796 if !self.object_dependencies.is_empty() {
13797 len += 1;
13798 }
13799 if self.version.is_some() {
13800 len += 1;
13801 }
13802 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13803 if !self.databases.is_empty() {
13804 struct_ser.serialize_field("databases", &self.databases)?;
13805 }
13806 if !self.schemas.is_empty() {
13807 struct_ser.serialize_field("schemas", &self.schemas)?;
13808 }
13809 if !self.sources.is_empty() {
13810 struct_ser.serialize_field("sources", &self.sources)?;
13811 }
13812 if !self.sinks.is_empty() {
13813 struct_ser.serialize_field("sinks", &self.sinks)?;
13814 }
13815 if !self.tables.is_empty() {
13816 struct_ser.serialize_field("tables", &self.tables)?;
13817 }
13818 if !self.indexes.is_empty() {
13819 struct_ser.serialize_field("indexes", &self.indexes)?;
13820 }
13821 if !self.views.is_empty() {
13822 struct_ser.serialize_field("views", &self.views)?;
13823 }
13824 if !self.functions.is_empty() {
13825 struct_ser.serialize_field("functions", &self.functions)?;
13826 }
13827 if !self.connections.is_empty() {
13828 struct_ser.serialize_field("connections", &self.connections)?;
13829 }
13830 if !self.subscriptions.is_empty() {
13831 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13832 }
13833 if !self.users.is_empty() {
13834 struct_ser.serialize_field("users", &self.users)?;
13835 }
13836 if let Some(v) = self.session_params.as_ref() {
13837 struct_ser.serialize_field("sessionParams", v)?;
13838 }
13839 if !self.secrets.is_empty() {
13840 struct_ser.serialize_field("secrets", &self.secrets)?;
13841 }
13842 if let Some(v) = self.cluster_resource.as_ref() {
13843 struct_ser.serialize_field("clusterResource", v)?;
13844 }
13845 if !self.nodes.is_empty() {
13846 struct_ser.serialize_field("nodes", &self.nodes)?;
13847 }
13848 if let Some(v) = self.hummock_version.as_ref() {
13849 struct_ser.serialize_field("hummockVersion", v)?;
13850 }
13851 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
13852 struct_ser.serialize_field("metaBackupManifestId", v)?;
13853 }
13854 if let Some(v) = self.hummock_write_limits.as_ref() {
13855 struct_ser.serialize_field("hummockWriteLimits", v)?;
13856 }
13857 if !self.streaming_worker_slot_mappings.is_empty() {
13858 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
13859 }
13860 if !self.serving_worker_slot_mappings.is_empty() {
13861 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
13862 }
13863 if !self.object_dependencies.is_empty() {
13864 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
13865 }
13866 if let Some(v) = self.version.as_ref() {
13867 struct_ser.serialize_field("version", v)?;
13868 }
13869 struct_ser.end()
13870 }
13871}
13872impl<'de> serde::Deserialize<'de> for MetaSnapshot {
13873 #[allow(deprecated)]
13874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13875 where
13876 D: serde::Deserializer<'de>,
13877 {
13878 const FIELDS: &[&str] = &[
13879 "databases",
13880 "schemas",
13881 "sources",
13882 "sinks",
13883 "tables",
13884 "indexes",
13885 "views",
13886 "functions",
13887 "connections",
13888 "subscriptions",
13889 "users",
13890 "session_params",
13891 "sessionParams",
13892 "secrets",
13893 "cluster_resource",
13894 "clusterResource",
13895 "nodes",
13896 "hummock_version",
13897 "hummockVersion",
13898 "meta_backup_manifest_id",
13899 "metaBackupManifestId",
13900 "hummock_write_limits",
13901 "hummockWriteLimits",
13902 "streaming_worker_slot_mappings",
13903 "streamingWorkerSlotMappings",
13904 "serving_worker_slot_mappings",
13905 "servingWorkerSlotMappings",
13906 "object_dependencies",
13907 "objectDependencies",
13908 "version",
13909 ];
13910
13911 #[allow(clippy::enum_variant_names)]
13912 enum GeneratedField {
13913 Databases,
13914 Schemas,
13915 Sources,
13916 Sinks,
13917 Tables,
13918 Indexes,
13919 Views,
13920 Functions,
13921 Connections,
13922 Subscriptions,
13923 Users,
13924 SessionParams,
13925 Secrets,
13926 ClusterResource,
13927 Nodes,
13928 HummockVersion,
13929 MetaBackupManifestId,
13930 HummockWriteLimits,
13931 StreamingWorkerSlotMappings,
13932 ServingWorkerSlotMappings,
13933 ObjectDependencies,
13934 Version,
13935 }
13936 impl<'de> serde::Deserialize<'de> for GeneratedField {
13937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13938 where
13939 D: serde::Deserializer<'de>,
13940 {
13941 struct GeneratedVisitor;
13942
13943 impl serde::de::Visitor<'_> for GeneratedVisitor {
13944 type Value = GeneratedField;
13945
13946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13947 write!(formatter, "expected one of: {:?}", &FIELDS)
13948 }
13949
13950 #[allow(unused_variables)]
13951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13952 where
13953 E: serde::de::Error,
13954 {
13955 match value {
13956 "databases" => Ok(GeneratedField::Databases),
13957 "schemas" => Ok(GeneratedField::Schemas),
13958 "sources" => Ok(GeneratedField::Sources),
13959 "sinks" => Ok(GeneratedField::Sinks),
13960 "tables" => Ok(GeneratedField::Tables),
13961 "indexes" => Ok(GeneratedField::Indexes),
13962 "views" => Ok(GeneratedField::Views),
13963 "functions" => Ok(GeneratedField::Functions),
13964 "connections" => Ok(GeneratedField::Connections),
13965 "subscriptions" => Ok(GeneratedField::Subscriptions),
13966 "users" => Ok(GeneratedField::Users),
13967 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13968 "secrets" => Ok(GeneratedField::Secrets),
13969 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13970 "nodes" => Ok(GeneratedField::Nodes),
13971 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13972 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13973 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13974 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13975 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13976 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
13977 "version" => Ok(GeneratedField::Version),
13978 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13979 }
13980 }
13981 }
13982 deserializer.deserialize_identifier(GeneratedVisitor)
13983 }
13984 }
13985 struct GeneratedVisitor;
13986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13987 type Value = MetaSnapshot;
13988
13989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13990 formatter.write_str("struct meta.MetaSnapshot")
13991 }
13992
13993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13994 where
13995 V: serde::de::MapAccess<'de>,
13996 {
13997 let mut databases__ = None;
13998 let mut schemas__ = None;
13999 let mut sources__ = None;
14000 let mut sinks__ = None;
14001 let mut tables__ = None;
14002 let mut indexes__ = None;
14003 let mut views__ = None;
14004 let mut functions__ = None;
14005 let mut connections__ = None;
14006 let mut subscriptions__ = None;
14007 let mut users__ = None;
14008 let mut session_params__ = None;
14009 let mut secrets__ = None;
14010 let mut cluster_resource__ = None;
14011 let mut nodes__ = None;
14012 let mut hummock_version__ = None;
14013 let mut meta_backup_manifest_id__ = None;
14014 let mut hummock_write_limits__ = None;
14015 let mut streaming_worker_slot_mappings__ = None;
14016 let mut serving_worker_slot_mappings__ = None;
14017 let mut object_dependencies__ = None;
14018 let mut version__ = None;
14019 while let Some(k) = map_.next_key()? {
14020 match k {
14021 GeneratedField::Databases => {
14022 if databases__.is_some() {
14023 return Err(serde::de::Error::duplicate_field("databases"));
14024 }
14025 databases__ = Some(map_.next_value()?);
14026 }
14027 GeneratedField::Schemas => {
14028 if schemas__.is_some() {
14029 return Err(serde::de::Error::duplicate_field("schemas"));
14030 }
14031 schemas__ = Some(map_.next_value()?);
14032 }
14033 GeneratedField::Sources => {
14034 if sources__.is_some() {
14035 return Err(serde::de::Error::duplicate_field("sources"));
14036 }
14037 sources__ = Some(map_.next_value()?);
14038 }
14039 GeneratedField::Sinks => {
14040 if sinks__.is_some() {
14041 return Err(serde::de::Error::duplicate_field("sinks"));
14042 }
14043 sinks__ = Some(map_.next_value()?);
14044 }
14045 GeneratedField::Tables => {
14046 if tables__.is_some() {
14047 return Err(serde::de::Error::duplicate_field("tables"));
14048 }
14049 tables__ = Some(map_.next_value()?);
14050 }
14051 GeneratedField::Indexes => {
14052 if indexes__.is_some() {
14053 return Err(serde::de::Error::duplicate_field("indexes"));
14054 }
14055 indexes__ = Some(map_.next_value()?);
14056 }
14057 GeneratedField::Views => {
14058 if views__.is_some() {
14059 return Err(serde::de::Error::duplicate_field("views"));
14060 }
14061 views__ = Some(map_.next_value()?);
14062 }
14063 GeneratedField::Functions => {
14064 if functions__.is_some() {
14065 return Err(serde::de::Error::duplicate_field("functions"));
14066 }
14067 functions__ = Some(map_.next_value()?);
14068 }
14069 GeneratedField::Connections => {
14070 if connections__.is_some() {
14071 return Err(serde::de::Error::duplicate_field("connections"));
14072 }
14073 connections__ = Some(map_.next_value()?);
14074 }
14075 GeneratedField::Subscriptions => {
14076 if subscriptions__.is_some() {
14077 return Err(serde::de::Error::duplicate_field("subscriptions"));
14078 }
14079 subscriptions__ = Some(map_.next_value()?);
14080 }
14081 GeneratedField::Users => {
14082 if users__.is_some() {
14083 return Err(serde::de::Error::duplicate_field("users"));
14084 }
14085 users__ = Some(map_.next_value()?);
14086 }
14087 GeneratedField::SessionParams => {
14088 if session_params__.is_some() {
14089 return Err(serde::de::Error::duplicate_field("sessionParams"));
14090 }
14091 session_params__ = map_.next_value()?;
14092 }
14093 GeneratedField::Secrets => {
14094 if secrets__.is_some() {
14095 return Err(serde::de::Error::duplicate_field("secrets"));
14096 }
14097 secrets__ = Some(map_.next_value()?);
14098 }
14099 GeneratedField::ClusterResource => {
14100 if cluster_resource__.is_some() {
14101 return Err(serde::de::Error::duplicate_field("clusterResource"));
14102 }
14103 cluster_resource__ = map_.next_value()?;
14104 }
14105 GeneratedField::Nodes => {
14106 if nodes__.is_some() {
14107 return Err(serde::de::Error::duplicate_field("nodes"));
14108 }
14109 nodes__ = Some(map_.next_value()?);
14110 }
14111 GeneratedField::HummockVersion => {
14112 if hummock_version__.is_some() {
14113 return Err(serde::de::Error::duplicate_field("hummockVersion"));
14114 }
14115 hummock_version__ = map_.next_value()?;
14116 }
14117 GeneratedField::MetaBackupManifestId => {
14118 if meta_backup_manifest_id__.is_some() {
14119 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14120 }
14121 meta_backup_manifest_id__ = map_.next_value()?;
14122 }
14123 GeneratedField::HummockWriteLimits => {
14124 if hummock_write_limits__.is_some() {
14125 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14126 }
14127 hummock_write_limits__ = map_.next_value()?;
14128 }
14129 GeneratedField::StreamingWorkerSlotMappings => {
14130 if streaming_worker_slot_mappings__.is_some() {
14131 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
14132 }
14133 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
14134 }
14135 GeneratedField::ServingWorkerSlotMappings => {
14136 if serving_worker_slot_mappings__.is_some() {
14137 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14138 }
14139 serving_worker_slot_mappings__ = Some(map_.next_value()?);
14140 }
14141 GeneratedField::ObjectDependencies => {
14142 if object_dependencies__.is_some() {
14143 return Err(serde::de::Error::duplicate_field("objectDependencies"));
14144 }
14145 object_dependencies__ = Some(map_.next_value()?);
14146 }
14147 GeneratedField::Version => {
14148 if version__.is_some() {
14149 return Err(serde::de::Error::duplicate_field("version"));
14150 }
14151 version__ = map_.next_value()?;
14152 }
14153 }
14154 }
14155 Ok(MetaSnapshot {
14156 databases: databases__.unwrap_or_default(),
14157 schemas: schemas__.unwrap_or_default(),
14158 sources: sources__.unwrap_or_default(),
14159 sinks: sinks__.unwrap_or_default(),
14160 tables: tables__.unwrap_or_default(),
14161 indexes: indexes__.unwrap_or_default(),
14162 views: views__.unwrap_or_default(),
14163 functions: functions__.unwrap_or_default(),
14164 connections: connections__.unwrap_or_default(),
14165 subscriptions: subscriptions__.unwrap_or_default(),
14166 users: users__.unwrap_or_default(),
14167 session_params: session_params__,
14168 secrets: secrets__.unwrap_or_default(),
14169 cluster_resource: cluster_resource__,
14170 nodes: nodes__.unwrap_or_default(),
14171 hummock_version: hummock_version__,
14172 meta_backup_manifest_id: meta_backup_manifest_id__,
14173 hummock_write_limits: hummock_write_limits__,
14174 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
14175 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
14176 object_dependencies: object_dependencies__.unwrap_or_default(),
14177 version: version__,
14178 })
14179 }
14180 }
14181 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
14182 }
14183}
14184impl serde::Serialize for meta_snapshot::SnapshotVersion {
14185 #[allow(deprecated)]
14186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14187 where
14188 S: serde::Serializer,
14189 {
14190 use serde::ser::SerializeStruct;
14191 let mut len = 0;
14192 if self.catalog_version != 0 {
14193 len += 1;
14194 }
14195 if self.worker_node_version != 0 {
14196 len += 1;
14197 }
14198 if self.streaming_worker_slot_mapping_version != 0 {
14199 len += 1;
14200 }
14201 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
14202 if self.catalog_version != 0 {
14203 #[allow(clippy::needless_borrow)]
14204 #[allow(clippy::needless_borrows_for_generic_args)]
14205 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
14206 }
14207 if self.worker_node_version != 0 {
14208 #[allow(clippy::needless_borrow)]
14209 #[allow(clippy::needless_borrows_for_generic_args)]
14210 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
14211 }
14212 if self.streaming_worker_slot_mapping_version != 0 {
14213 #[allow(clippy::needless_borrow)]
14214 #[allow(clippy::needless_borrows_for_generic_args)]
14215 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
14216 }
14217 struct_ser.end()
14218 }
14219}
14220impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
14221 #[allow(deprecated)]
14222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14223 where
14224 D: serde::Deserializer<'de>,
14225 {
14226 const FIELDS: &[&str] = &[
14227 "catalog_version",
14228 "catalogVersion",
14229 "worker_node_version",
14230 "workerNodeVersion",
14231 "streaming_worker_slot_mapping_version",
14232 "streamingWorkerSlotMappingVersion",
14233 ];
14234
14235 #[allow(clippy::enum_variant_names)]
14236 enum GeneratedField {
14237 CatalogVersion,
14238 WorkerNodeVersion,
14239 StreamingWorkerSlotMappingVersion,
14240 }
14241 impl<'de> serde::Deserialize<'de> for GeneratedField {
14242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14243 where
14244 D: serde::Deserializer<'de>,
14245 {
14246 struct GeneratedVisitor;
14247
14248 impl serde::de::Visitor<'_> for GeneratedVisitor {
14249 type Value = GeneratedField;
14250
14251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14252 write!(formatter, "expected one of: {:?}", &FIELDS)
14253 }
14254
14255 #[allow(unused_variables)]
14256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14257 where
14258 E: serde::de::Error,
14259 {
14260 match value {
14261 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
14262 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
14263 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
14264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14265 }
14266 }
14267 }
14268 deserializer.deserialize_identifier(GeneratedVisitor)
14269 }
14270 }
14271 struct GeneratedVisitor;
14272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14273 type Value = meta_snapshot::SnapshotVersion;
14274
14275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14276 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
14277 }
14278
14279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
14280 where
14281 V: serde::de::MapAccess<'de>,
14282 {
14283 let mut catalog_version__ = None;
14284 let mut worker_node_version__ = None;
14285 let mut streaming_worker_slot_mapping_version__ = None;
14286 while let Some(k) = map_.next_key()? {
14287 match k {
14288 GeneratedField::CatalogVersion => {
14289 if catalog_version__.is_some() {
14290 return Err(serde::de::Error::duplicate_field("catalogVersion"));
14291 }
14292 catalog_version__ =
14293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14294 ;
14295 }
14296 GeneratedField::WorkerNodeVersion => {
14297 if worker_node_version__.is_some() {
14298 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
14299 }
14300 worker_node_version__ =
14301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14302 ;
14303 }
14304 GeneratedField::StreamingWorkerSlotMappingVersion => {
14305 if streaming_worker_slot_mapping_version__.is_some() {
14306 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
14307 }
14308 streaming_worker_slot_mapping_version__ =
14309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14310 ;
14311 }
14312 }
14313 }
14314 Ok(meta_snapshot::SnapshotVersion {
14315 catalog_version: catalog_version__.unwrap_or_default(),
14316 worker_node_version: worker_node_version__.unwrap_or_default(),
14317 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
14318 })
14319 }
14320 }
14321 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
14322 }
14323}
14324impl serde::Serialize for MigrationPlan {
14325 #[allow(deprecated)]
14326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14327 where
14328 S: serde::Serializer,
14329 {
14330 use serde::ser::SerializeStruct;
14331 let mut len = 0;
14332 if !self.worker_slot_migration_plan.is_empty() {
14333 len += 1;
14334 }
14335 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
14336 if !self.worker_slot_migration_plan.is_empty() {
14337 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
14338 .map(|(k, v)| (k, v.to_string())).collect();
14339 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
14340 }
14341 struct_ser.end()
14342 }
14343}
14344impl<'de> serde::Deserialize<'de> for MigrationPlan {
14345 #[allow(deprecated)]
14346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14347 where
14348 D: serde::Deserializer<'de>,
14349 {
14350 const FIELDS: &[&str] = &[
14351 "worker_slot_migration_plan",
14352 "workerSlotMigrationPlan",
14353 ];
14354
14355 #[allow(clippy::enum_variant_names)]
14356 enum GeneratedField {
14357 WorkerSlotMigrationPlan,
14358 }
14359 impl<'de> serde::Deserialize<'de> for GeneratedField {
14360 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14361 where
14362 D: serde::Deserializer<'de>,
14363 {
14364 struct GeneratedVisitor;
14365
14366 impl serde::de::Visitor<'_> for GeneratedVisitor {
14367 type Value = GeneratedField;
14368
14369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14370 write!(formatter, "expected one of: {:?}", &FIELDS)
14371 }
14372
14373 #[allow(unused_variables)]
14374 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14375 where
14376 E: serde::de::Error,
14377 {
14378 match value {
14379 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
14380 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14381 }
14382 }
14383 }
14384 deserializer.deserialize_identifier(GeneratedVisitor)
14385 }
14386 }
14387 struct GeneratedVisitor;
14388 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14389 type Value = MigrationPlan;
14390
14391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14392 formatter.write_str("struct meta.MigrationPlan")
14393 }
14394
14395 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
14396 where
14397 V: serde::de::MapAccess<'de>,
14398 {
14399 let mut worker_slot_migration_plan__ = None;
14400 while let Some(k) = map_.next_key()? {
14401 match k {
14402 GeneratedField::WorkerSlotMigrationPlan => {
14403 if worker_slot_migration_plan__.is_some() {
14404 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
14405 }
14406 worker_slot_migration_plan__ = Some(
14407 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14408 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
14409 );
14410 }
14411 }
14412 }
14413 Ok(MigrationPlan {
14414 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
14415 })
14416 }
14417 }
14418 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
14419 }
14420}
14421impl serde::Serialize for Object {
14422 #[allow(deprecated)]
14423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14424 where
14425 S: serde::Serializer,
14426 {
14427 use serde::ser::SerializeStruct;
14428 let mut len = 0;
14429 if self.object_info.is_some() {
14430 len += 1;
14431 }
14432 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
14433 if let Some(v) = self.object_info.as_ref() {
14434 match v {
14435 object::ObjectInfo::Database(v) => {
14436 struct_ser.serialize_field("database", v)?;
14437 }
14438 object::ObjectInfo::Schema(v) => {
14439 struct_ser.serialize_field("schema", v)?;
14440 }
14441 object::ObjectInfo::Table(v) => {
14442 struct_ser.serialize_field("table", v)?;
14443 }
14444 object::ObjectInfo::Index(v) => {
14445 struct_ser.serialize_field("index", v)?;
14446 }
14447 object::ObjectInfo::Source(v) => {
14448 struct_ser.serialize_field("source", v)?;
14449 }
14450 object::ObjectInfo::Sink(v) => {
14451 struct_ser.serialize_field("sink", v)?;
14452 }
14453 object::ObjectInfo::View(v) => {
14454 struct_ser.serialize_field("view", v)?;
14455 }
14456 object::ObjectInfo::Function(v) => {
14457 struct_ser.serialize_field("function", v)?;
14458 }
14459 object::ObjectInfo::Connection(v) => {
14460 struct_ser.serialize_field("connection", v)?;
14461 }
14462 object::ObjectInfo::Subscription(v) => {
14463 struct_ser.serialize_field("subscription", v)?;
14464 }
14465 object::ObjectInfo::Secret(v) => {
14466 struct_ser.serialize_field("secret", v)?;
14467 }
14468 }
14469 }
14470 struct_ser.end()
14471 }
14472}
14473impl<'de> serde::Deserialize<'de> for Object {
14474 #[allow(deprecated)]
14475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14476 where
14477 D: serde::Deserializer<'de>,
14478 {
14479 const FIELDS: &[&str] = &[
14480 "database",
14481 "schema",
14482 "table",
14483 "index",
14484 "source",
14485 "sink",
14486 "view",
14487 "function",
14488 "connection",
14489 "subscription",
14490 "secret",
14491 ];
14492
14493 #[allow(clippy::enum_variant_names)]
14494 enum GeneratedField {
14495 Database,
14496 Schema,
14497 Table,
14498 Index,
14499 Source,
14500 Sink,
14501 View,
14502 Function,
14503 Connection,
14504 Subscription,
14505 Secret,
14506 }
14507 impl<'de> serde::Deserialize<'de> for GeneratedField {
14508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14509 where
14510 D: serde::Deserializer<'de>,
14511 {
14512 struct GeneratedVisitor;
14513
14514 impl serde::de::Visitor<'_> for GeneratedVisitor {
14515 type Value = GeneratedField;
14516
14517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14518 write!(formatter, "expected one of: {:?}", &FIELDS)
14519 }
14520
14521 #[allow(unused_variables)]
14522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14523 where
14524 E: serde::de::Error,
14525 {
14526 match value {
14527 "database" => Ok(GeneratedField::Database),
14528 "schema" => Ok(GeneratedField::Schema),
14529 "table" => Ok(GeneratedField::Table),
14530 "index" => Ok(GeneratedField::Index),
14531 "source" => Ok(GeneratedField::Source),
14532 "sink" => Ok(GeneratedField::Sink),
14533 "view" => Ok(GeneratedField::View),
14534 "function" => Ok(GeneratedField::Function),
14535 "connection" => Ok(GeneratedField::Connection),
14536 "subscription" => Ok(GeneratedField::Subscription),
14537 "secret" => Ok(GeneratedField::Secret),
14538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14539 }
14540 }
14541 }
14542 deserializer.deserialize_identifier(GeneratedVisitor)
14543 }
14544 }
14545 struct GeneratedVisitor;
14546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14547 type Value = Object;
14548
14549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14550 formatter.write_str("struct meta.Object")
14551 }
14552
14553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14554 where
14555 V: serde::de::MapAccess<'de>,
14556 {
14557 let mut object_info__ = None;
14558 while let Some(k) = map_.next_key()? {
14559 match k {
14560 GeneratedField::Database => {
14561 if object_info__.is_some() {
14562 return Err(serde::de::Error::duplicate_field("database"));
14563 }
14564 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14565;
14566 }
14567 GeneratedField::Schema => {
14568 if object_info__.is_some() {
14569 return Err(serde::de::Error::duplicate_field("schema"));
14570 }
14571 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14572;
14573 }
14574 GeneratedField::Table => {
14575 if object_info__.is_some() {
14576 return Err(serde::de::Error::duplicate_field("table"));
14577 }
14578 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14579;
14580 }
14581 GeneratedField::Index => {
14582 if object_info__.is_some() {
14583 return Err(serde::de::Error::duplicate_field("index"));
14584 }
14585 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14586;
14587 }
14588 GeneratedField::Source => {
14589 if object_info__.is_some() {
14590 return Err(serde::de::Error::duplicate_field("source"));
14591 }
14592 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14593;
14594 }
14595 GeneratedField::Sink => {
14596 if object_info__.is_some() {
14597 return Err(serde::de::Error::duplicate_field("sink"));
14598 }
14599 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14600;
14601 }
14602 GeneratedField::View => {
14603 if object_info__.is_some() {
14604 return Err(serde::de::Error::duplicate_field("view"));
14605 }
14606 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14607;
14608 }
14609 GeneratedField::Function => {
14610 if object_info__.is_some() {
14611 return Err(serde::de::Error::duplicate_field("function"));
14612 }
14613 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14614;
14615 }
14616 GeneratedField::Connection => {
14617 if object_info__.is_some() {
14618 return Err(serde::de::Error::duplicate_field("connection"));
14619 }
14620 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14621;
14622 }
14623 GeneratedField::Subscription => {
14624 if object_info__.is_some() {
14625 return Err(serde::de::Error::duplicate_field("subscription"));
14626 }
14627 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14628;
14629 }
14630 GeneratedField::Secret => {
14631 if object_info__.is_some() {
14632 return Err(serde::de::Error::duplicate_field("secret"));
14633 }
14634 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14635;
14636 }
14637 }
14638 }
14639 Ok(Object {
14640 object_info: object_info__,
14641 })
14642 }
14643 }
14644 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14645 }
14646}
14647impl serde::Serialize for ObjectDependency {
14648 #[allow(deprecated)]
14649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14650 where
14651 S: serde::Serializer,
14652 {
14653 use serde::ser::SerializeStruct;
14654 let mut len = 0;
14655 if self.object_id != 0 {
14656 len += 1;
14657 }
14658 if self.referenced_object_id != 0 {
14659 len += 1;
14660 }
14661 if self.referenced_object_type != 0 {
14662 len += 1;
14663 }
14664 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14665 if self.object_id != 0 {
14666 struct_ser.serialize_field("objectId", &self.object_id)?;
14667 }
14668 if self.referenced_object_id != 0 {
14669 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14670 }
14671 if self.referenced_object_type != 0 {
14672 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14673 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14674 struct_ser.serialize_field("referencedObjectType", &v)?;
14675 }
14676 struct_ser.end()
14677 }
14678}
14679impl<'de> serde::Deserialize<'de> for ObjectDependency {
14680 #[allow(deprecated)]
14681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14682 where
14683 D: serde::Deserializer<'de>,
14684 {
14685 const FIELDS: &[&str] = &[
14686 "object_id",
14687 "objectId",
14688 "referenced_object_id",
14689 "referencedObjectId",
14690 "referenced_object_type",
14691 "referencedObjectType",
14692 ];
14693
14694 #[allow(clippy::enum_variant_names)]
14695 enum GeneratedField {
14696 ObjectId,
14697 ReferencedObjectId,
14698 ReferencedObjectType,
14699 }
14700 impl<'de> serde::Deserialize<'de> for GeneratedField {
14701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14702 where
14703 D: serde::Deserializer<'de>,
14704 {
14705 struct GeneratedVisitor;
14706
14707 impl serde::de::Visitor<'_> for GeneratedVisitor {
14708 type Value = GeneratedField;
14709
14710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14711 write!(formatter, "expected one of: {:?}", &FIELDS)
14712 }
14713
14714 #[allow(unused_variables)]
14715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14716 where
14717 E: serde::de::Error,
14718 {
14719 match value {
14720 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14721 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14722 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14723 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14724 }
14725 }
14726 }
14727 deserializer.deserialize_identifier(GeneratedVisitor)
14728 }
14729 }
14730 struct GeneratedVisitor;
14731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14732 type Value = ObjectDependency;
14733
14734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14735 formatter.write_str("struct meta.ObjectDependency")
14736 }
14737
14738 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14739 where
14740 V: serde::de::MapAccess<'de>,
14741 {
14742 let mut object_id__ = None;
14743 let mut referenced_object_id__ = None;
14744 let mut referenced_object_type__ = None;
14745 while let Some(k) = map_.next_key()? {
14746 match k {
14747 GeneratedField::ObjectId => {
14748 if object_id__.is_some() {
14749 return Err(serde::de::Error::duplicate_field("objectId"));
14750 }
14751 object_id__ =
14752 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14753 ;
14754 }
14755 GeneratedField::ReferencedObjectId => {
14756 if referenced_object_id__.is_some() {
14757 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14758 }
14759 referenced_object_id__ =
14760 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14761 ;
14762 }
14763 GeneratedField::ReferencedObjectType => {
14764 if referenced_object_type__.is_some() {
14765 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14766 }
14767 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14768 }
14769 }
14770 }
14771 Ok(ObjectDependency {
14772 object_id: object_id__.unwrap_or_default(),
14773 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14774 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14775 })
14776 }
14777 }
14778 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14779 }
14780}
14781impl serde::Serialize for ObjectGroup {
14782 #[allow(deprecated)]
14783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14784 where
14785 S: serde::Serializer,
14786 {
14787 use serde::ser::SerializeStruct;
14788 let mut len = 0;
14789 if !self.objects.is_empty() {
14790 len += 1;
14791 }
14792 if !self.dependencies.is_empty() {
14793 len += 1;
14794 }
14795 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14796 if !self.objects.is_empty() {
14797 struct_ser.serialize_field("objects", &self.objects)?;
14798 }
14799 if !self.dependencies.is_empty() {
14800 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14801 }
14802 struct_ser.end()
14803 }
14804}
14805impl<'de> serde::Deserialize<'de> for ObjectGroup {
14806 #[allow(deprecated)]
14807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14808 where
14809 D: serde::Deserializer<'de>,
14810 {
14811 const FIELDS: &[&str] = &[
14812 "objects",
14813 "dependencies",
14814 ];
14815
14816 #[allow(clippy::enum_variant_names)]
14817 enum GeneratedField {
14818 Objects,
14819 Dependencies,
14820 }
14821 impl<'de> serde::Deserialize<'de> for GeneratedField {
14822 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14823 where
14824 D: serde::Deserializer<'de>,
14825 {
14826 struct GeneratedVisitor;
14827
14828 impl serde::de::Visitor<'_> for GeneratedVisitor {
14829 type Value = GeneratedField;
14830
14831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14832 write!(formatter, "expected one of: {:?}", &FIELDS)
14833 }
14834
14835 #[allow(unused_variables)]
14836 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14837 where
14838 E: serde::de::Error,
14839 {
14840 match value {
14841 "objects" => Ok(GeneratedField::Objects),
14842 "dependencies" => Ok(GeneratedField::Dependencies),
14843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14844 }
14845 }
14846 }
14847 deserializer.deserialize_identifier(GeneratedVisitor)
14848 }
14849 }
14850 struct GeneratedVisitor;
14851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14852 type Value = ObjectGroup;
14853
14854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14855 formatter.write_str("struct meta.ObjectGroup")
14856 }
14857
14858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
14859 where
14860 V: serde::de::MapAccess<'de>,
14861 {
14862 let mut objects__ = None;
14863 let mut dependencies__ = None;
14864 while let Some(k) = map_.next_key()? {
14865 match k {
14866 GeneratedField::Objects => {
14867 if objects__.is_some() {
14868 return Err(serde::de::Error::duplicate_field("objects"));
14869 }
14870 objects__ = Some(map_.next_value()?);
14871 }
14872 GeneratedField::Dependencies => {
14873 if dependencies__.is_some() {
14874 return Err(serde::de::Error::duplicate_field("dependencies"));
14875 }
14876 dependencies__ = Some(map_.next_value()?);
14877 }
14878 }
14879 }
14880 Ok(ObjectGroup {
14881 objects: objects__.unwrap_or_default(),
14882 dependencies: dependencies__.unwrap_or_default(),
14883 })
14884 }
14885 }
14886 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
14887 }
14888}
14889impl serde::Serialize for PauseRequest {
14890 #[allow(deprecated)]
14891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14892 where
14893 S: serde::Serializer,
14894 {
14895 use serde::ser::SerializeStruct;
14896 let len = 0;
14897 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
14898 struct_ser.end()
14899 }
14900}
14901impl<'de> serde::Deserialize<'de> for PauseRequest {
14902 #[allow(deprecated)]
14903 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14904 where
14905 D: serde::Deserializer<'de>,
14906 {
14907 const FIELDS: &[&str] = &[
14908 ];
14909
14910 #[allow(clippy::enum_variant_names)]
14911 enum GeneratedField {
14912 }
14913 impl<'de> serde::Deserialize<'de> for GeneratedField {
14914 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14915 where
14916 D: serde::Deserializer<'de>,
14917 {
14918 struct GeneratedVisitor;
14919
14920 impl serde::de::Visitor<'_> for GeneratedVisitor {
14921 type Value = GeneratedField;
14922
14923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14924 write!(formatter, "expected one of: {:?}", &FIELDS)
14925 }
14926
14927 #[allow(unused_variables)]
14928 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14929 where
14930 E: serde::de::Error,
14931 {
14932 Err(serde::de::Error::unknown_field(value, FIELDS))
14933 }
14934 }
14935 deserializer.deserialize_identifier(GeneratedVisitor)
14936 }
14937 }
14938 struct GeneratedVisitor;
14939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14940 type Value = PauseRequest;
14941
14942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14943 formatter.write_str("struct meta.PauseRequest")
14944 }
14945
14946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
14947 where
14948 V: serde::de::MapAccess<'de>,
14949 {
14950 while map_.next_key::<GeneratedField>()?.is_some() {
14951 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14952 }
14953 Ok(PauseRequest {
14954 })
14955 }
14956 }
14957 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
14958 }
14959}
14960impl serde::Serialize for PauseResponse {
14961 #[allow(deprecated)]
14962 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14963 where
14964 S: serde::Serializer,
14965 {
14966 use serde::ser::SerializeStruct;
14967 let len = 0;
14968 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
14969 struct_ser.end()
14970 }
14971}
14972impl<'de> serde::Deserialize<'de> for PauseResponse {
14973 #[allow(deprecated)]
14974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14975 where
14976 D: serde::Deserializer<'de>,
14977 {
14978 const FIELDS: &[&str] = &[
14979 ];
14980
14981 #[allow(clippy::enum_variant_names)]
14982 enum GeneratedField {
14983 }
14984 impl<'de> serde::Deserialize<'de> for GeneratedField {
14985 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14986 where
14987 D: serde::Deserializer<'de>,
14988 {
14989 struct GeneratedVisitor;
14990
14991 impl serde::de::Visitor<'_> for GeneratedVisitor {
14992 type Value = GeneratedField;
14993
14994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14995 write!(formatter, "expected one of: {:?}", &FIELDS)
14996 }
14997
14998 #[allow(unused_variables)]
14999 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15000 where
15001 E: serde::de::Error,
15002 {
15003 Err(serde::de::Error::unknown_field(value, FIELDS))
15004 }
15005 }
15006 deserializer.deserialize_identifier(GeneratedVisitor)
15007 }
15008 }
15009 struct GeneratedVisitor;
15010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15011 type Value = PauseResponse;
15012
15013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15014 formatter.write_str("struct meta.PauseResponse")
15015 }
15016
15017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
15018 where
15019 V: serde::de::MapAccess<'de>,
15020 {
15021 while map_.next_key::<GeneratedField>()?.is_some() {
15022 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15023 }
15024 Ok(PauseResponse {
15025 })
15026 }
15027 }
15028 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
15029 }
15030}
15031impl serde::Serialize for PropertyUpdateOptions {
15032 #[allow(deprecated)]
15033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15034 where
15035 S: serde::Serializer,
15036 {
15037 use serde::ser::SerializeStruct;
15038 let mut len = 0;
15039 if self.reset_splits {
15040 len += 1;
15041 }
15042 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
15043 if self.reset_splits {
15044 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
15045 }
15046 struct_ser.end()
15047 }
15048}
15049impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
15050 #[allow(deprecated)]
15051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15052 where
15053 D: serde::Deserializer<'de>,
15054 {
15055 const FIELDS: &[&str] = &[
15056 "reset_splits",
15057 "resetSplits",
15058 ];
15059
15060 #[allow(clippy::enum_variant_names)]
15061 enum GeneratedField {
15062 ResetSplits,
15063 }
15064 impl<'de> serde::Deserialize<'de> for GeneratedField {
15065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15066 where
15067 D: serde::Deserializer<'de>,
15068 {
15069 struct GeneratedVisitor;
15070
15071 impl serde::de::Visitor<'_> for GeneratedVisitor {
15072 type Value = GeneratedField;
15073
15074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15075 write!(formatter, "expected one of: {:?}", &FIELDS)
15076 }
15077
15078 #[allow(unused_variables)]
15079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15080 where
15081 E: serde::de::Error,
15082 {
15083 match value {
15084 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
15085 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15086 }
15087 }
15088 }
15089 deserializer.deserialize_identifier(GeneratedVisitor)
15090 }
15091 }
15092 struct GeneratedVisitor;
15093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15094 type Value = PropertyUpdateOptions;
15095
15096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15097 formatter.write_str("struct meta.PropertyUpdateOptions")
15098 }
15099
15100 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
15101 where
15102 V: serde::de::MapAccess<'de>,
15103 {
15104 let mut reset_splits__ = None;
15105 while let Some(k) = map_.next_key()? {
15106 match k {
15107 GeneratedField::ResetSplits => {
15108 if reset_splits__.is_some() {
15109 return Err(serde::de::Error::duplicate_field("resetSplits"));
15110 }
15111 reset_splits__ = Some(map_.next_value()?);
15112 }
15113 }
15114 }
15115 Ok(PropertyUpdateOptions {
15116 reset_splits: reset_splits__.unwrap_or_default(),
15117 })
15118 }
15119 }
15120 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
15121 }
15122}
15123impl serde::Serialize for RecoverRequest {
15124 #[allow(deprecated)]
15125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15126 where
15127 S: serde::Serializer,
15128 {
15129 use serde::ser::SerializeStruct;
15130 let len = 0;
15131 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
15132 struct_ser.end()
15133 }
15134}
15135impl<'de> serde::Deserialize<'de> for RecoverRequest {
15136 #[allow(deprecated)]
15137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15138 where
15139 D: serde::Deserializer<'de>,
15140 {
15141 const FIELDS: &[&str] = &[
15142 ];
15143
15144 #[allow(clippy::enum_variant_names)]
15145 enum GeneratedField {
15146 }
15147 impl<'de> serde::Deserialize<'de> for GeneratedField {
15148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15149 where
15150 D: serde::Deserializer<'de>,
15151 {
15152 struct GeneratedVisitor;
15153
15154 impl serde::de::Visitor<'_> for GeneratedVisitor {
15155 type Value = GeneratedField;
15156
15157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15158 write!(formatter, "expected one of: {:?}", &FIELDS)
15159 }
15160
15161 #[allow(unused_variables)]
15162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15163 where
15164 E: serde::de::Error,
15165 {
15166 Err(serde::de::Error::unknown_field(value, FIELDS))
15167 }
15168 }
15169 deserializer.deserialize_identifier(GeneratedVisitor)
15170 }
15171 }
15172 struct GeneratedVisitor;
15173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15174 type Value = RecoverRequest;
15175
15176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15177 formatter.write_str("struct meta.RecoverRequest")
15178 }
15179
15180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
15181 where
15182 V: serde::de::MapAccess<'de>,
15183 {
15184 while map_.next_key::<GeneratedField>()?.is_some() {
15185 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15186 }
15187 Ok(RecoverRequest {
15188 })
15189 }
15190 }
15191 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
15192 }
15193}
15194impl serde::Serialize for RecoverResponse {
15195 #[allow(deprecated)]
15196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15197 where
15198 S: serde::Serializer,
15199 {
15200 use serde::ser::SerializeStruct;
15201 let len = 0;
15202 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
15203 struct_ser.end()
15204 }
15205}
15206impl<'de> serde::Deserialize<'de> for RecoverResponse {
15207 #[allow(deprecated)]
15208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15209 where
15210 D: serde::Deserializer<'de>,
15211 {
15212 const FIELDS: &[&str] = &[
15213 ];
15214
15215 #[allow(clippy::enum_variant_names)]
15216 enum GeneratedField {
15217 }
15218 impl<'de> serde::Deserialize<'de> for GeneratedField {
15219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15220 where
15221 D: serde::Deserializer<'de>,
15222 {
15223 struct GeneratedVisitor;
15224
15225 impl serde::de::Visitor<'_> for GeneratedVisitor {
15226 type Value = GeneratedField;
15227
15228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15229 write!(formatter, "expected one of: {:?}", &FIELDS)
15230 }
15231
15232 #[allow(unused_variables)]
15233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15234 where
15235 E: serde::de::Error,
15236 {
15237 Err(serde::de::Error::unknown_field(value, FIELDS))
15238 }
15239 }
15240 deserializer.deserialize_identifier(GeneratedVisitor)
15241 }
15242 }
15243 struct GeneratedVisitor;
15244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15245 type Value = RecoverResponse;
15246
15247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15248 formatter.write_str("struct meta.RecoverResponse")
15249 }
15250
15251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
15252 where
15253 V: serde::de::MapAccess<'de>,
15254 {
15255 while map_.next_key::<GeneratedField>()?.is_some() {
15256 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15257 }
15258 Ok(RecoverResponse {
15259 })
15260 }
15261 }
15262 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
15263 }
15264}
15265impl serde::Serialize for Recovery {
15266 #[allow(deprecated)]
15267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15268 where
15269 S: serde::Serializer,
15270 {
15271 use serde::ser::SerializeStruct;
15272 let len = 0;
15273 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
15274 struct_ser.end()
15275 }
15276}
15277impl<'de> serde::Deserialize<'de> for Recovery {
15278 #[allow(deprecated)]
15279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15280 where
15281 D: serde::Deserializer<'de>,
15282 {
15283 const FIELDS: &[&str] = &[
15284 ];
15285
15286 #[allow(clippy::enum_variant_names)]
15287 enum GeneratedField {
15288 }
15289 impl<'de> serde::Deserialize<'de> for GeneratedField {
15290 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15291 where
15292 D: serde::Deserializer<'de>,
15293 {
15294 struct GeneratedVisitor;
15295
15296 impl serde::de::Visitor<'_> for GeneratedVisitor {
15297 type Value = GeneratedField;
15298
15299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15300 write!(formatter, "expected one of: {:?}", &FIELDS)
15301 }
15302
15303 #[allow(unused_variables)]
15304 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15305 where
15306 E: serde::de::Error,
15307 {
15308 Err(serde::de::Error::unknown_field(value, FIELDS))
15309 }
15310 }
15311 deserializer.deserialize_identifier(GeneratedVisitor)
15312 }
15313 }
15314 struct GeneratedVisitor;
15315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15316 type Value = Recovery;
15317
15318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15319 formatter.write_str("struct meta.Recovery")
15320 }
15321
15322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
15323 where
15324 V: serde::de::MapAccess<'de>,
15325 {
15326 while map_.next_key::<GeneratedField>()?.is_some() {
15327 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15328 }
15329 Ok(Recovery {
15330 })
15331 }
15332 }
15333 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
15334 }
15335}
15336impl serde::Serialize for RecoveryStatus {
15337 #[allow(deprecated)]
15338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15339 where
15340 S: serde::Serializer,
15341 {
15342 let variant = match self {
15343 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
15344 Self::StatusStarting => "STATUS_STARTING",
15345 Self::StatusRecovering => "STATUS_RECOVERING",
15346 Self::StatusRunning => "STATUS_RUNNING",
15347 };
15348 serializer.serialize_str(variant)
15349 }
15350}
15351impl<'de> serde::Deserialize<'de> for RecoveryStatus {
15352 #[allow(deprecated)]
15353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15354 where
15355 D: serde::Deserializer<'de>,
15356 {
15357 const FIELDS: &[&str] = &[
15358 "STATUS_UNSPECIFIED",
15359 "STATUS_STARTING",
15360 "STATUS_RECOVERING",
15361 "STATUS_RUNNING",
15362 ];
15363
15364 struct GeneratedVisitor;
15365
15366 impl serde::de::Visitor<'_> for GeneratedVisitor {
15367 type Value = RecoveryStatus;
15368
15369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15370 write!(formatter, "expected one of: {:?}", &FIELDS)
15371 }
15372
15373 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15374 where
15375 E: serde::de::Error,
15376 {
15377 i32::try_from(v)
15378 .ok()
15379 .and_then(|x| x.try_into().ok())
15380 .ok_or_else(|| {
15381 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15382 })
15383 }
15384
15385 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15386 where
15387 E: serde::de::Error,
15388 {
15389 i32::try_from(v)
15390 .ok()
15391 .and_then(|x| x.try_into().ok())
15392 .ok_or_else(|| {
15393 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15394 })
15395 }
15396
15397 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15398 where
15399 E: serde::de::Error,
15400 {
15401 match value {
15402 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
15403 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
15404 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
15405 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
15406 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15407 }
15408 }
15409 }
15410 deserializer.deserialize_any(GeneratedVisitor)
15411 }
15412}
15413impl serde::Serialize for RefreshRequest {
15414 #[allow(deprecated)]
15415 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15416 where
15417 S: serde::Serializer,
15418 {
15419 use serde::ser::SerializeStruct;
15420 let mut len = 0;
15421 if self.table_id != 0 {
15422 len += 1;
15423 }
15424 if self.associated_source_id != 0 {
15425 len += 1;
15426 }
15427 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
15428 if self.table_id != 0 {
15429 struct_ser.serialize_field("tableId", &self.table_id)?;
15430 }
15431 if self.associated_source_id != 0 {
15432 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
15433 }
15434 struct_ser.end()
15435 }
15436}
15437impl<'de> serde::Deserialize<'de> for RefreshRequest {
15438 #[allow(deprecated)]
15439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15440 where
15441 D: serde::Deserializer<'de>,
15442 {
15443 const FIELDS: &[&str] = &[
15444 "table_id",
15445 "tableId",
15446 "associated_source_id",
15447 "associatedSourceId",
15448 ];
15449
15450 #[allow(clippy::enum_variant_names)]
15451 enum GeneratedField {
15452 TableId,
15453 AssociatedSourceId,
15454 }
15455 impl<'de> serde::Deserialize<'de> for GeneratedField {
15456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15457 where
15458 D: serde::Deserializer<'de>,
15459 {
15460 struct GeneratedVisitor;
15461
15462 impl serde::de::Visitor<'_> for GeneratedVisitor {
15463 type Value = GeneratedField;
15464
15465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15466 write!(formatter, "expected one of: {:?}", &FIELDS)
15467 }
15468
15469 #[allow(unused_variables)]
15470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15471 where
15472 E: serde::de::Error,
15473 {
15474 match value {
15475 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15476 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15478 }
15479 }
15480 }
15481 deserializer.deserialize_identifier(GeneratedVisitor)
15482 }
15483 }
15484 struct GeneratedVisitor;
15485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15486 type Value = RefreshRequest;
15487
15488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15489 formatter.write_str("struct meta.RefreshRequest")
15490 }
15491
15492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15493 where
15494 V: serde::de::MapAccess<'de>,
15495 {
15496 let mut table_id__ = None;
15497 let mut associated_source_id__ = None;
15498 while let Some(k) = map_.next_key()? {
15499 match k {
15500 GeneratedField::TableId => {
15501 if table_id__.is_some() {
15502 return Err(serde::de::Error::duplicate_field("tableId"));
15503 }
15504 table_id__ =
15505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15506 ;
15507 }
15508 GeneratedField::AssociatedSourceId => {
15509 if associated_source_id__.is_some() {
15510 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15511 }
15512 associated_source_id__ =
15513 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15514 ;
15515 }
15516 }
15517 }
15518 Ok(RefreshRequest {
15519 table_id: table_id__.unwrap_or_default(),
15520 associated_source_id: associated_source_id__.unwrap_or_default(),
15521 })
15522 }
15523 }
15524 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15525 }
15526}
15527impl serde::Serialize for RefreshResponse {
15528 #[allow(deprecated)]
15529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15530 where
15531 S: serde::Serializer,
15532 {
15533 use serde::ser::SerializeStruct;
15534 let mut len = 0;
15535 if self.status.is_some() {
15536 len += 1;
15537 }
15538 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15539 if let Some(v) = self.status.as_ref() {
15540 struct_ser.serialize_field("status", v)?;
15541 }
15542 struct_ser.end()
15543 }
15544}
15545impl<'de> serde::Deserialize<'de> for RefreshResponse {
15546 #[allow(deprecated)]
15547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15548 where
15549 D: serde::Deserializer<'de>,
15550 {
15551 const FIELDS: &[&str] = &[
15552 "status",
15553 ];
15554
15555 #[allow(clippy::enum_variant_names)]
15556 enum GeneratedField {
15557 Status,
15558 }
15559 impl<'de> serde::Deserialize<'de> for GeneratedField {
15560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15561 where
15562 D: serde::Deserializer<'de>,
15563 {
15564 struct GeneratedVisitor;
15565
15566 impl serde::de::Visitor<'_> for GeneratedVisitor {
15567 type Value = GeneratedField;
15568
15569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15570 write!(formatter, "expected one of: {:?}", &FIELDS)
15571 }
15572
15573 #[allow(unused_variables)]
15574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15575 where
15576 E: serde::de::Error,
15577 {
15578 match value {
15579 "status" => Ok(GeneratedField::Status),
15580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15581 }
15582 }
15583 }
15584 deserializer.deserialize_identifier(GeneratedVisitor)
15585 }
15586 }
15587 struct GeneratedVisitor;
15588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15589 type Value = RefreshResponse;
15590
15591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15592 formatter.write_str("struct meta.RefreshResponse")
15593 }
15594
15595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15596 where
15597 V: serde::de::MapAccess<'de>,
15598 {
15599 let mut status__ = None;
15600 while let Some(k) = map_.next_key()? {
15601 match k {
15602 GeneratedField::Status => {
15603 if status__.is_some() {
15604 return Err(serde::de::Error::duplicate_field("status"));
15605 }
15606 status__ = map_.next_value()?;
15607 }
15608 }
15609 }
15610 Ok(RefreshResponse {
15611 status: status__,
15612 })
15613 }
15614 }
15615 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15616 }
15617}
15618impl serde::Serialize for RelationIdInfos {
15619 #[allow(deprecated)]
15620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15621 where
15622 S: serde::Serializer,
15623 {
15624 use serde::ser::SerializeStruct;
15625 let mut len = 0;
15626 if !self.map.is_empty() {
15627 len += 1;
15628 }
15629 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15630 if !self.map.is_empty() {
15631 struct_ser.serialize_field("map", &self.map)?;
15632 }
15633 struct_ser.end()
15634 }
15635}
15636impl<'de> serde::Deserialize<'de> for RelationIdInfos {
15637 #[allow(deprecated)]
15638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15639 where
15640 D: serde::Deserializer<'de>,
15641 {
15642 const FIELDS: &[&str] = &[
15643 "map",
15644 ];
15645
15646 #[allow(clippy::enum_variant_names)]
15647 enum GeneratedField {
15648 Map,
15649 }
15650 impl<'de> serde::Deserialize<'de> for GeneratedField {
15651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15652 where
15653 D: serde::Deserializer<'de>,
15654 {
15655 struct GeneratedVisitor;
15656
15657 impl serde::de::Visitor<'_> for GeneratedVisitor {
15658 type Value = GeneratedField;
15659
15660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15661 write!(formatter, "expected one of: {:?}", &FIELDS)
15662 }
15663
15664 #[allow(unused_variables)]
15665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15666 where
15667 E: serde::de::Error,
15668 {
15669 match value {
15670 "map" => Ok(GeneratedField::Map),
15671 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15672 }
15673 }
15674 }
15675 deserializer.deserialize_identifier(GeneratedVisitor)
15676 }
15677 }
15678 struct GeneratedVisitor;
15679 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15680 type Value = RelationIdInfos;
15681
15682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15683 formatter.write_str("struct meta.RelationIdInfos")
15684 }
15685
15686 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15687 where
15688 V: serde::de::MapAccess<'de>,
15689 {
15690 let mut map__ = None;
15691 while let Some(k) = map_.next_key()? {
15692 match k {
15693 GeneratedField::Map => {
15694 if map__.is_some() {
15695 return Err(serde::de::Error::duplicate_field("map"));
15696 }
15697 map__ = Some(
15698 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15699 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15700 );
15701 }
15702 }
15703 }
15704 Ok(RelationIdInfos {
15705 map: map__.unwrap_or_default(),
15706 })
15707 }
15708 }
15709 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15710 }
15711}
15712impl serde::Serialize for RescheduleRequest {
15713 #[allow(deprecated)]
15714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15715 where
15716 S: serde::Serializer,
15717 {
15718 use serde::ser::SerializeStruct;
15719 let mut len = 0;
15720 if self.revision != 0 {
15721 len += 1;
15722 }
15723 if self.resolve_no_shuffle_upstream {
15724 len += 1;
15725 }
15726 if !self.worker_reschedules.is_empty() {
15727 len += 1;
15728 }
15729 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15730 if self.revision != 0 {
15731 #[allow(clippy::needless_borrow)]
15732 #[allow(clippy::needless_borrows_for_generic_args)]
15733 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15734 }
15735 if self.resolve_no_shuffle_upstream {
15736 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15737 }
15738 if !self.worker_reschedules.is_empty() {
15739 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15740 }
15741 struct_ser.end()
15742 }
15743}
15744impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15745 #[allow(deprecated)]
15746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15747 where
15748 D: serde::Deserializer<'de>,
15749 {
15750 const FIELDS: &[&str] = &[
15751 "revision",
15752 "resolve_no_shuffle_upstream",
15753 "resolveNoShuffleUpstream",
15754 "worker_reschedules",
15755 "workerReschedules",
15756 ];
15757
15758 #[allow(clippy::enum_variant_names)]
15759 enum GeneratedField {
15760 Revision,
15761 ResolveNoShuffleUpstream,
15762 WorkerReschedules,
15763 }
15764 impl<'de> serde::Deserialize<'de> for GeneratedField {
15765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15766 where
15767 D: serde::Deserializer<'de>,
15768 {
15769 struct GeneratedVisitor;
15770
15771 impl serde::de::Visitor<'_> for GeneratedVisitor {
15772 type Value = GeneratedField;
15773
15774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15775 write!(formatter, "expected one of: {:?}", &FIELDS)
15776 }
15777
15778 #[allow(unused_variables)]
15779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15780 where
15781 E: serde::de::Error,
15782 {
15783 match value {
15784 "revision" => Ok(GeneratedField::Revision),
15785 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15786 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15788 }
15789 }
15790 }
15791 deserializer.deserialize_identifier(GeneratedVisitor)
15792 }
15793 }
15794 struct GeneratedVisitor;
15795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15796 type Value = RescheduleRequest;
15797
15798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15799 formatter.write_str("struct meta.RescheduleRequest")
15800 }
15801
15802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15803 where
15804 V: serde::de::MapAccess<'de>,
15805 {
15806 let mut revision__ = None;
15807 let mut resolve_no_shuffle_upstream__ = None;
15808 let mut worker_reschedules__ = None;
15809 while let Some(k) = map_.next_key()? {
15810 match k {
15811 GeneratedField::Revision => {
15812 if revision__.is_some() {
15813 return Err(serde::de::Error::duplicate_field("revision"));
15814 }
15815 revision__ =
15816 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15817 ;
15818 }
15819 GeneratedField::ResolveNoShuffleUpstream => {
15820 if resolve_no_shuffle_upstream__.is_some() {
15821 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
15822 }
15823 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
15824 }
15825 GeneratedField::WorkerReschedules => {
15826 if worker_reschedules__.is_some() {
15827 return Err(serde::de::Error::duplicate_field("workerReschedules"));
15828 }
15829 worker_reschedules__ = Some(
15830 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15831 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15832 );
15833 }
15834 }
15835 }
15836 Ok(RescheduleRequest {
15837 revision: revision__.unwrap_or_default(),
15838 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
15839 worker_reschedules: worker_reschedules__.unwrap_or_default(),
15840 })
15841 }
15842 }
15843 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
15844 }
15845}
15846impl serde::Serialize for RescheduleResponse {
15847 #[allow(deprecated)]
15848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15849 where
15850 S: serde::Serializer,
15851 {
15852 use serde::ser::SerializeStruct;
15853 let mut len = 0;
15854 if self.success {
15855 len += 1;
15856 }
15857 if self.revision != 0 {
15858 len += 1;
15859 }
15860 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
15861 if self.success {
15862 struct_ser.serialize_field("success", &self.success)?;
15863 }
15864 if self.revision != 0 {
15865 #[allow(clippy::needless_borrow)]
15866 #[allow(clippy::needless_borrows_for_generic_args)]
15867 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15868 }
15869 struct_ser.end()
15870 }
15871}
15872impl<'de> serde::Deserialize<'de> for RescheduleResponse {
15873 #[allow(deprecated)]
15874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15875 where
15876 D: serde::Deserializer<'de>,
15877 {
15878 const FIELDS: &[&str] = &[
15879 "success",
15880 "revision",
15881 ];
15882
15883 #[allow(clippy::enum_variant_names)]
15884 enum GeneratedField {
15885 Success,
15886 Revision,
15887 }
15888 impl<'de> serde::Deserialize<'de> for GeneratedField {
15889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15890 where
15891 D: serde::Deserializer<'de>,
15892 {
15893 struct GeneratedVisitor;
15894
15895 impl serde::de::Visitor<'_> for GeneratedVisitor {
15896 type Value = GeneratedField;
15897
15898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15899 write!(formatter, "expected one of: {:?}", &FIELDS)
15900 }
15901
15902 #[allow(unused_variables)]
15903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15904 where
15905 E: serde::de::Error,
15906 {
15907 match value {
15908 "success" => Ok(GeneratedField::Success),
15909 "revision" => Ok(GeneratedField::Revision),
15910 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15911 }
15912 }
15913 }
15914 deserializer.deserialize_identifier(GeneratedVisitor)
15915 }
15916 }
15917 struct GeneratedVisitor;
15918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15919 type Value = RescheduleResponse;
15920
15921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15922 formatter.write_str("struct meta.RescheduleResponse")
15923 }
15924
15925 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
15926 where
15927 V: serde::de::MapAccess<'de>,
15928 {
15929 let mut success__ = None;
15930 let mut revision__ = None;
15931 while let Some(k) = map_.next_key()? {
15932 match k {
15933 GeneratedField::Success => {
15934 if success__.is_some() {
15935 return Err(serde::de::Error::duplicate_field("success"));
15936 }
15937 success__ = Some(map_.next_value()?);
15938 }
15939 GeneratedField::Revision => {
15940 if revision__.is_some() {
15941 return Err(serde::de::Error::duplicate_field("revision"));
15942 }
15943 revision__ =
15944 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15945 ;
15946 }
15947 }
15948 }
15949 Ok(RescheduleResponse {
15950 success: success__.unwrap_or_default(),
15951 revision: revision__.unwrap_or_default(),
15952 })
15953 }
15954 }
15955 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
15956 }
15957}
15958impl serde::Serialize for ResetSourceSplitsRequest {
15959 #[allow(deprecated)]
15960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15961 where
15962 S: serde::Serializer,
15963 {
15964 use serde::ser::SerializeStruct;
15965 let mut len = 0;
15966 if self.source_id != 0 {
15967 len += 1;
15968 }
15969 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
15970 if self.source_id != 0 {
15971 struct_ser.serialize_field("sourceId", &self.source_id)?;
15972 }
15973 struct_ser.end()
15974 }
15975}
15976impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
15977 #[allow(deprecated)]
15978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15979 where
15980 D: serde::Deserializer<'de>,
15981 {
15982 const FIELDS: &[&str] = &[
15983 "source_id",
15984 "sourceId",
15985 ];
15986
15987 #[allow(clippy::enum_variant_names)]
15988 enum GeneratedField {
15989 SourceId,
15990 }
15991 impl<'de> serde::Deserialize<'de> for GeneratedField {
15992 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15993 where
15994 D: serde::Deserializer<'de>,
15995 {
15996 struct GeneratedVisitor;
15997
15998 impl serde::de::Visitor<'_> for GeneratedVisitor {
15999 type Value = GeneratedField;
16000
16001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16002 write!(formatter, "expected one of: {:?}", &FIELDS)
16003 }
16004
16005 #[allow(unused_variables)]
16006 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16007 where
16008 E: serde::de::Error,
16009 {
16010 match value {
16011 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16012 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16013 }
16014 }
16015 }
16016 deserializer.deserialize_identifier(GeneratedVisitor)
16017 }
16018 }
16019 struct GeneratedVisitor;
16020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16021 type Value = ResetSourceSplitsRequest;
16022
16023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16024 formatter.write_str("struct meta.ResetSourceSplitsRequest")
16025 }
16026
16027 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
16028 where
16029 V: serde::de::MapAccess<'de>,
16030 {
16031 let mut source_id__ = None;
16032 while let Some(k) = map_.next_key()? {
16033 match k {
16034 GeneratedField::SourceId => {
16035 if source_id__.is_some() {
16036 return Err(serde::de::Error::duplicate_field("sourceId"));
16037 }
16038 source_id__ =
16039 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16040 ;
16041 }
16042 }
16043 }
16044 Ok(ResetSourceSplitsRequest {
16045 source_id: source_id__.unwrap_or_default(),
16046 })
16047 }
16048 }
16049 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
16050 }
16051}
16052impl serde::Serialize for ResetSourceSplitsResponse {
16053 #[allow(deprecated)]
16054 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16055 where
16056 S: serde::Serializer,
16057 {
16058 use serde::ser::SerializeStruct;
16059 let len = 0;
16060 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
16061 struct_ser.end()
16062 }
16063}
16064impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
16065 #[allow(deprecated)]
16066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16067 where
16068 D: serde::Deserializer<'de>,
16069 {
16070 const FIELDS: &[&str] = &[
16071 ];
16072
16073 #[allow(clippy::enum_variant_names)]
16074 enum GeneratedField {
16075 }
16076 impl<'de> serde::Deserialize<'de> for GeneratedField {
16077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16078 where
16079 D: serde::Deserializer<'de>,
16080 {
16081 struct GeneratedVisitor;
16082
16083 impl serde::de::Visitor<'_> for GeneratedVisitor {
16084 type Value = GeneratedField;
16085
16086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16087 write!(formatter, "expected one of: {:?}", &FIELDS)
16088 }
16089
16090 #[allow(unused_variables)]
16091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16092 where
16093 E: serde::de::Error,
16094 {
16095 Err(serde::de::Error::unknown_field(value, FIELDS))
16096 }
16097 }
16098 deserializer.deserialize_identifier(GeneratedVisitor)
16099 }
16100 }
16101 struct GeneratedVisitor;
16102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16103 type Value = ResetSourceSplitsResponse;
16104
16105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16106 formatter.write_str("struct meta.ResetSourceSplitsResponse")
16107 }
16108
16109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
16110 where
16111 V: serde::de::MapAccess<'de>,
16112 {
16113 while map_.next_key::<GeneratedField>()?.is_some() {
16114 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16115 }
16116 Ok(ResetSourceSplitsResponse {
16117 })
16118 }
16119 }
16120 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
16121 }
16122}
16123impl serde::Serialize for ResumeRequest {
16124 #[allow(deprecated)]
16125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16126 where
16127 S: serde::Serializer,
16128 {
16129 use serde::ser::SerializeStruct;
16130 let len = 0;
16131 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
16132 struct_ser.end()
16133 }
16134}
16135impl<'de> serde::Deserialize<'de> for ResumeRequest {
16136 #[allow(deprecated)]
16137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16138 where
16139 D: serde::Deserializer<'de>,
16140 {
16141 const FIELDS: &[&str] = &[
16142 ];
16143
16144 #[allow(clippy::enum_variant_names)]
16145 enum GeneratedField {
16146 }
16147 impl<'de> serde::Deserialize<'de> for GeneratedField {
16148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16149 where
16150 D: serde::Deserializer<'de>,
16151 {
16152 struct GeneratedVisitor;
16153
16154 impl serde::de::Visitor<'_> for GeneratedVisitor {
16155 type Value = GeneratedField;
16156
16157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16158 write!(formatter, "expected one of: {:?}", &FIELDS)
16159 }
16160
16161 #[allow(unused_variables)]
16162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16163 where
16164 E: serde::de::Error,
16165 {
16166 Err(serde::de::Error::unknown_field(value, FIELDS))
16167 }
16168 }
16169 deserializer.deserialize_identifier(GeneratedVisitor)
16170 }
16171 }
16172 struct GeneratedVisitor;
16173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16174 type Value = ResumeRequest;
16175
16176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16177 formatter.write_str("struct meta.ResumeRequest")
16178 }
16179
16180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
16181 where
16182 V: serde::de::MapAccess<'de>,
16183 {
16184 while map_.next_key::<GeneratedField>()?.is_some() {
16185 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16186 }
16187 Ok(ResumeRequest {
16188 })
16189 }
16190 }
16191 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
16192 }
16193}
16194impl serde::Serialize for ResumeResponse {
16195 #[allow(deprecated)]
16196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16197 where
16198 S: serde::Serializer,
16199 {
16200 use serde::ser::SerializeStruct;
16201 let len = 0;
16202 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
16203 struct_ser.end()
16204 }
16205}
16206impl<'de> serde::Deserialize<'de> for ResumeResponse {
16207 #[allow(deprecated)]
16208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16209 where
16210 D: serde::Deserializer<'de>,
16211 {
16212 const FIELDS: &[&str] = &[
16213 ];
16214
16215 #[allow(clippy::enum_variant_names)]
16216 enum GeneratedField {
16217 }
16218 impl<'de> serde::Deserialize<'de> for GeneratedField {
16219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16220 where
16221 D: serde::Deserializer<'de>,
16222 {
16223 struct GeneratedVisitor;
16224
16225 impl serde::de::Visitor<'_> for GeneratedVisitor {
16226 type Value = GeneratedField;
16227
16228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16229 write!(formatter, "expected one of: {:?}", &FIELDS)
16230 }
16231
16232 #[allow(unused_variables)]
16233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16234 where
16235 E: serde::de::Error,
16236 {
16237 Err(serde::de::Error::unknown_field(value, FIELDS))
16238 }
16239 }
16240 deserializer.deserialize_identifier(GeneratedVisitor)
16241 }
16242 }
16243 struct GeneratedVisitor;
16244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16245 type Value = ResumeResponse;
16246
16247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16248 formatter.write_str("struct meta.ResumeResponse")
16249 }
16250
16251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
16252 where
16253 V: serde::de::MapAccess<'de>,
16254 {
16255 while map_.next_key::<GeneratedField>()?.is_some() {
16256 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16257 }
16258 Ok(ResumeResponse {
16259 })
16260 }
16261 }
16262 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
16263 }
16264}
16265impl serde::Serialize for SetSessionParamRequest {
16266 #[allow(deprecated)]
16267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16268 where
16269 S: serde::Serializer,
16270 {
16271 use serde::ser::SerializeStruct;
16272 let mut len = 0;
16273 if !self.param.is_empty() {
16274 len += 1;
16275 }
16276 if self.value.is_some() {
16277 len += 1;
16278 }
16279 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
16280 if !self.param.is_empty() {
16281 struct_ser.serialize_field("param", &self.param)?;
16282 }
16283 if let Some(v) = self.value.as_ref() {
16284 struct_ser.serialize_field("value", v)?;
16285 }
16286 struct_ser.end()
16287 }
16288}
16289impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
16290 #[allow(deprecated)]
16291 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16292 where
16293 D: serde::Deserializer<'de>,
16294 {
16295 const FIELDS: &[&str] = &[
16296 "param",
16297 "value",
16298 ];
16299
16300 #[allow(clippy::enum_variant_names)]
16301 enum GeneratedField {
16302 Param,
16303 Value,
16304 }
16305 impl<'de> serde::Deserialize<'de> for GeneratedField {
16306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16307 where
16308 D: serde::Deserializer<'de>,
16309 {
16310 struct GeneratedVisitor;
16311
16312 impl serde::de::Visitor<'_> for GeneratedVisitor {
16313 type Value = GeneratedField;
16314
16315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16316 write!(formatter, "expected one of: {:?}", &FIELDS)
16317 }
16318
16319 #[allow(unused_variables)]
16320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16321 where
16322 E: serde::de::Error,
16323 {
16324 match value {
16325 "param" => Ok(GeneratedField::Param),
16326 "value" => Ok(GeneratedField::Value),
16327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16328 }
16329 }
16330 }
16331 deserializer.deserialize_identifier(GeneratedVisitor)
16332 }
16333 }
16334 struct GeneratedVisitor;
16335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16336 type Value = SetSessionParamRequest;
16337
16338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16339 formatter.write_str("struct meta.SetSessionParamRequest")
16340 }
16341
16342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
16343 where
16344 V: serde::de::MapAccess<'de>,
16345 {
16346 let mut param__ = None;
16347 let mut value__ = None;
16348 while let Some(k) = map_.next_key()? {
16349 match k {
16350 GeneratedField::Param => {
16351 if param__.is_some() {
16352 return Err(serde::de::Error::duplicate_field("param"));
16353 }
16354 param__ = Some(map_.next_value()?);
16355 }
16356 GeneratedField::Value => {
16357 if value__.is_some() {
16358 return Err(serde::de::Error::duplicate_field("value"));
16359 }
16360 value__ = map_.next_value()?;
16361 }
16362 }
16363 }
16364 Ok(SetSessionParamRequest {
16365 param: param__.unwrap_or_default(),
16366 value: value__,
16367 })
16368 }
16369 }
16370 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
16371 }
16372}
16373impl serde::Serialize for SetSessionParamResponse {
16374 #[allow(deprecated)]
16375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16376 where
16377 S: serde::Serializer,
16378 {
16379 use serde::ser::SerializeStruct;
16380 let mut len = 0;
16381 if !self.param.is_empty() {
16382 len += 1;
16383 }
16384 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
16385 if !self.param.is_empty() {
16386 struct_ser.serialize_field("param", &self.param)?;
16387 }
16388 struct_ser.end()
16389 }
16390}
16391impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
16392 #[allow(deprecated)]
16393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16394 where
16395 D: serde::Deserializer<'de>,
16396 {
16397 const FIELDS: &[&str] = &[
16398 "param",
16399 ];
16400
16401 #[allow(clippy::enum_variant_names)]
16402 enum GeneratedField {
16403 Param,
16404 }
16405 impl<'de> serde::Deserialize<'de> for GeneratedField {
16406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16407 where
16408 D: serde::Deserializer<'de>,
16409 {
16410 struct GeneratedVisitor;
16411
16412 impl serde::de::Visitor<'_> for GeneratedVisitor {
16413 type Value = GeneratedField;
16414
16415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16416 write!(formatter, "expected one of: {:?}", &FIELDS)
16417 }
16418
16419 #[allow(unused_variables)]
16420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16421 where
16422 E: serde::de::Error,
16423 {
16424 match value {
16425 "param" => Ok(GeneratedField::Param),
16426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16427 }
16428 }
16429 }
16430 deserializer.deserialize_identifier(GeneratedVisitor)
16431 }
16432 }
16433 struct GeneratedVisitor;
16434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16435 type Value = SetSessionParamResponse;
16436
16437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16438 formatter.write_str("struct meta.SetSessionParamResponse")
16439 }
16440
16441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16442 where
16443 V: serde::de::MapAccess<'de>,
16444 {
16445 let mut param__ = None;
16446 while let Some(k) = map_.next_key()? {
16447 match k {
16448 GeneratedField::Param => {
16449 if param__.is_some() {
16450 return Err(serde::de::Error::duplicate_field("param"));
16451 }
16452 param__ = Some(map_.next_value()?);
16453 }
16454 }
16455 }
16456 Ok(SetSessionParamResponse {
16457 param: param__.unwrap_or_default(),
16458 })
16459 }
16460 }
16461 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16462 }
16463}
16464impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16465 #[allow(deprecated)]
16466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16467 where
16468 S: serde::Serializer,
16469 {
16470 use serde::ser::SerializeStruct;
16471 let mut len = 0;
16472 if self.job_id != 0 {
16473 len += 1;
16474 }
16475 if self.aligned {
16476 len += 1;
16477 }
16478 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16479 if self.job_id != 0 {
16480 struct_ser.serialize_field("jobId", &self.job_id)?;
16481 }
16482 if self.aligned {
16483 struct_ser.serialize_field("aligned", &self.aligned)?;
16484 }
16485 struct_ser.end()
16486 }
16487}
16488impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16489 #[allow(deprecated)]
16490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16491 where
16492 D: serde::Deserializer<'de>,
16493 {
16494 const FIELDS: &[&str] = &[
16495 "job_id",
16496 "jobId",
16497 "aligned",
16498 ];
16499
16500 #[allow(clippy::enum_variant_names)]
16501 enum GeneratedField {
16502 JobId,
16503 Aligned,
16504 }
16505 impl<'de> serde::Deserialize<'de> for GeneratedField {
16506 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16507 where
16508 D: serde::Deserializer<'de>,
16509 {
16510 struct GeneratedVisitor;
16511
16512 impl serde::de::Visitor<'_> for GeneratedVisitor {
16513 type Value = GeneratedField;
16514
16515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16516 write!(formatter, "expected one of: {:?}", &FIELDS)
16517 }
16518
16519 #[allow(unused_variables)]
16520 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16521 where
16522 E: serde::de::Error,
16523 {
16524 match value {
16525 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16526 "aligned" => Ok(GeneratedField::Aligned),
16527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16528 }
16529 }
16530 }
16531 deserializer.deserialize_identifier(GeneratedVisitor)
16532 }
16533 }
16534 struct GeneratedVisitor;
16535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16536 type Value = SetSyncLogStoreAlignedRequest;
16537
16538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16539 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16540 }
16541
16542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16543 where
16544 V: serde::de::MapAccess<'de>,
16545 {
16546 let mut job_id__ = None;
16547 let mut aligned__ = None;
16548 while let Some(k) = map_.next_key()? {
16549 match k {
16550 GeneratedField::JobId => {
16551 if job_id__.is_some() {
16552 return Err(serde::de::Error::duplicate_field("jobId"));
16553 }
16554 job_id__ =
16555 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16556 ;
16557 }
16558 GeneratedField::Aligned => {
16559 if aligned__.is_some() {
16560 return Err(serde::de::Error::duplicate_field("aligned"));
16561 }
16562 aligned__ = Some(map_.next_value()?);
16563 }
16564 }
16565 }
16566 Ok(SetSyncLogStoreAlignedRequest {
16567 job_id: job_id__.unwrap_or_default(),
16568 aligned: aligned__.unwrap_or_default(),
16569 })
16570 }
16571 }
16572 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16573 }
16574}
16575impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16576 #[allow(deprecated)]
16577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16578 where
16579 S: serde::Serializer,
16580 {
16581 use serde::ser::SerializeStruct;
16582 let len = 0;
16583 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16584 struct_ser.end()
16585 }
16586}
16587impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16588 #[allow(deprecated)]
16589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16590 where
16591 D: serde::Deserializer<'de>,
16592 {
16593 const FIELDS: &[&str] = &[
16594 ];
16595
16596 #[allow(clippy::enum_variant_names)]
16597 enum GeneratedField {
16598 }
16599 impl<'de> serde::Deserialize<'de> for GeneratedField {
16600 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16601 where
16602 D: serde::Deserializer<'de>,
16603 {
16604 struct GeneratedVisitor;
16605
16606 impl serde::de::Visitor<'_> for GeneratedVisitor {
16607 type Value = GeneratedField;
16608
16609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16610 write!(formatter, "expected one of: {:?}", &FIELDS)
16611 }
16612
16613 #[allow(unused_variables)]
16614 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16615 where
16616 E: serde::de::Error,
16617 {
16618 Err(serde::de::Error::unknown_field(value, FIELDS))
16619 }
16620 }
16621 deserializer.deserialize_identifier(GeneratedVisitor)
16622 }
16623 }
16624 struct GeneratedVisitor;
16625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16626 type Value = SetSyncLogStoreAlignedResponse;
16627
16628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16629 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
16630 }
16631
16632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
16633 where
16634 V: serde::de::MapAccess<'de>,
16635 {
16636 while map_.next_key::<GeneratedField>()?.is_some() {
16637 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16638 }
16639 Ok(SetSyncLogStoreAlignedResponse {
16640 })
16641 }
16642 }
16643 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
16644 }
16645}
16646impl serde::Serialize for SetSystemParamRequest {
16647 #[allow(deprecated)]
16648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16649 where
16650 S: serde::Serializer,
16651 {
16652 use serde::ser::SerializeStruct;
16653 let mut len = 0;
16654 if !self.param.is_empty() {
16655 len += 1;
16656 }
16657 if self.value.is_some() {
16658 len += 1;
16659 }
16660 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
16661 if !self.param.is_empty() {
16662 struct_ser.serialize_field("param", &self.param)?;
16663 }
16664 if let Some(v) = self.value.as_ref() {
16665 struct_ser.serialize_field("value", v)?;
16666 }
16667 struct_ser.end()
16668 }
16669}
16670impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
16671 #[allow(deprecated)]
16672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16673 where
16674 D: serde::Deserializer<'de>,
16675 {
16676 const FIELDS: &[&str] = &[
16677 "param",
16678 "value",
16679 ];
16680
16681 #[allow(clippy::enum_variant_names)]
16682 enum GeneratedField {
16683 Param,
16684 Value,
16685 }
16686 impl<'de> serde::Deserialize<'de> for GeneratedField {
16687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16688 where
16689 D: serde::Deserializer<'de>,
16690 {
16691 struct GeneratedVisitor;
16692
16693 impl serde::de::Visitor<'_> for GeneratedVisitor {
16694 type Value = GeneratedField;
16695
16696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16697 write!(formatter, "expected one of: {:?}", &FIELDS)
16698 }
16699
16700 #[allow(unused_variables)]
16701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16702 where
16703 E: serde::de::Error,
16704 {
16705 match value {
16706 "param" => Ok(GeneratedField::Param),
16707 "value" => Ok(GeneratedField::Value),
16708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16709 }
16710 }
16711 }
16712 deserializer.deserialize_identifier(GeneratedVisitor)
16713 }
16714 }
16715 struct GeneratedVisitor;
16716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16717 type Value = SetSystemParamRequest;
16718
16719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16720 formatter.write_str("struct meta.SetSystemParamRequest")
16721 }
16722
16723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
16724 where
16725 V: serde::de::MapAccess<'de>,
16726 {
16727 let mut param__ = None;
16728 let mut value__ = None;
16729 while let Some(k) = map_.next_key()? {
16730 match k {
16731 GeneratedField::Param => {
16732 if param__.is_some() {
16733 return Err(serde::de::Error::duplicate_field("param"));
16734 }
16735 param__ = Some(map_.next_value()?);
16736 }
16737 GeneratedField::Value => {
16738 if value__.is_some() {
16739 return Err(serde::de::Error::duplicate_field("value"));
16740 }
16741 value__ = map_.next_value()?;
16742 }
16743 }
16744 }
16745 Ok(SetSystemParamRequest {
16746 param: param__.unwrap_or_default(),
16747 value: value__,
16748 })
16749 }
16750 }
16751 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
16752 }
16753}
16754impl serde::Serialize for SetSystemParamResponse {
16755 #[allow(deprecated)]
16756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16757 where
16758 S: serde::Serializer,
16759 {
16760 use serde::ser::SerializeStruct;
16761 let mut len = 0;
16762 if self.params.is_some() {
16763 len += 1;
16764 }
16765 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
16766 if let Some(v) = self.params.as_ref() {
16767 struct_ser.serialize_field("params", v)?;
16768 }
16769 struct_ser.end()
16770 }
16771}
16772impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
16773 #[allow(deprecated)]
16774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16775 where
16776 D: serde::Deserializer<'de>,
16777 {
16778 const FIELDS: &[&str] = &[
16779 "params",
16780 ];
16781
16782 #[allow(clippy::enum_variant_names)]
16783 enum GeneratedField {
16784 Params,
16785 }
16786 impl<'de> serde::Deserialize<'de> for GeneratedField {
16787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16788 where
16789 D: serde::Deserializer<'de>,
16790 {
16791 struct GeneratedVisitor;
16792
16793 impl serde::de::Visitor<'_> for GeneratedVisitor {
16794 type Value = GeneratedField;
16795
16796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16797 write!(formatter, "expected one of: {:?}", &FIELDS)
16798 }
16799
16800 #[allow(unused_variables)]
16801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16802 where
16803 E: serde::de::Error,
16804 {
16805 match value {
16806 "params" => Ok(GeneratedField::Params),
16807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16808 }
16809 }
16810 }
16811 deserializer.deserialize_identifier(GeneratedVisitor)
16812 }
16813 }
16814 struct GeneratedVisitor;
16815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16816 type Value = SetSystemParamResponse;
16817
16818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16819 formatter.write_str("struct meta.SetSystemParamResponse")
16820 }
16821
16822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
16823 where
16824 V: serde::de::MapAccess<'de>,
16825 {
16826 let mut params__ = None;
16827 while let Some(k) = map_.next_key()? {
16828 match k {
16829 GeneratedField::Params => {
16830 if params__.is_some() {
16831 return Err(serde::de::Error::duplicate_field("params"));
16832 }
16833 params__ = map_.next_value()?;
16834 }
16835 }
16836 }
16837 Ok(SetSystemParamResponse {
16838 params: params__,
16839 })
16840 }
16841 }
16842 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
16843 }
16844}
16845impl serde::Serialize for SubscribeRequest {
16846 #[allow(deprecated)]
16847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16848 where
16849 S: serde::Serializer,
16850 {
16851 use serde::ser::SerializeStruct;
16852 let mut len = 0;
16853 if self.subscribe_type != 0 {
16854 len += 1;
16855 }
16856 if self.host.is_some() {
16857 len += 1;
16858 }
16859 if self.worker_id != 0 {
16860 len += 1;
16861 }
16862 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
16863 if self.subscribe_type != 0 {
16864 let v = SubscribeType::try_from(self.subscribe_type)
16865 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
16866 struct_ser.serialize_field("subscribeType", &v)?;
16867 }
16868 if let Some(v) = self.host.as_ref() {
16869 struct_ser.serialize_field("host", v)?;
16870 }
16871 if self.worker_id != 0 {
16872 struct_ser.serialize_field("workerId", &self.worker_id)?;
16873 }
16874 struct_ser.end()
16875 }
16876}
16877impl<'de> serde::Deserialize<'de> for SubscribeRequest {
16878 #[allow(deprecated)]
16879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16880 where
16881 D: serde::Deserializer<'de>,
16882 {
16883 const FIELDS: &[&str] = &[
16884 "subscribe_type",
16885 "subscribeType",
16886 "host",
16887 "worker_id",
16888 "workerId",
16889 ];
16890
16891 #[allow(clippy::enum_variant_names)]
16892 enum GeneratedField {
16893 SubscribeType,
16894 Host,
16895 WorkerId,
16896 }
16897 impl<'de> serde::Deserialize<'de> for GeneratedField {
16898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16899 where
16900 D: serde::Deserializer<'de>,
16901 {
16902 struct GeneratedVisitor;
16903
16904 impl serde::de::Visitor<'_> for GeneratedVisitor {
16905 type Value = GeneratedField;
16906
16907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16908 write!(formatter, "expected one of: {:?}", &FIELDS)
16909 }
16910
16911 #[allow(unused_variables)]
16912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16913 where
16914 E: serde::de::Error,
16915 {
16916 match value {
16917 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
16918 "host" => Ok(GeneratedField::Host),
16919 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
16920 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16921 }
16922 }
16923 }
16924 deserializer.deserialize_identifier(GeneratedVisitor)
16925 }
16926 }
16927 struct GeneratedVisitor;
16928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16929 type Value = SubscribeRequest;
16930
16931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16932 formatter.write_str("struct meta.SubscribeRequest")
16933 }
16934
16935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
16936 where
16937 V: serde::de::MapAccess<'de>,
16938 {
16939 let mut subscribe_type__ = None;
16940 let mut host__ = None;
16941 let mut worker_id__ = None;
16942 while let Some(k) = map_.next_key()? {
16943 match k {
16944 GeneratedField::SubscribeType => {
16945 if subscribe_type__.is_some() {
16946 return Err(serde::de::Error::duplicate_field("subscribeType"));
16947 }
16948 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
16949 }
16950 GeneratedField::Host => {
16951 if host__.is_some() {
16952 return Err(serde::de::Error::duplicate_field("host"));
16953 }
16954 host__ = map_.next_value()?;
16955 }
16956 GeneratedField::WorkerId => {
16957 if worker_id__.is_some() {
16958 return Err(serde::de::Error::duplicate_field("workerId"));
16959 }
16960 worker_id__ =
16961 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16962 ;
16963 }
16964 }
16965 }
16966 Ok(SubscribeRequest {
16967 subscribe_type: subscribe_type__.unwrap_or_default(),
16968 host: host__,
16969 worker_id: worker_id__.unwrap_or_default(),
16970 })
16971 }
16972 }
16973 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
16974 }
16975}
16976impl serde::Serialize for SubscribeResponse {
16977 #[allow(deprecated)]
16978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16979 where
16980 S: serde::Serializer,
16981 {
16982 use serde::ser::SerializeStruct;
16983 let mut len = 0;
16984 if self.status.is_some() {
16985 len += 1;
16986 }
16987 if self.operation != 0 {
16988 len += 1;
16989 }
16990 if self.version != 0 {
16991 len += 1;
16992 }
16993 if self.info.is_some() {
16994 len += 1;
16995 }
16996 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
16997 if let Some(v) = self.status.as_ref() {
16998 struct_ser.serialize_field("status", v)?;
16999 }
17000 if self.operation != 0 {
17001 let v = subscribe_response::Operation::try_from(self.operation)
17002 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
17003 struct_ser.serialize_field("operation", &v)?;
17004 }
17005 if self.version != 0 {
17006 #[allow(clippy::needless_borrow)]
17007 #[allow(clippy::needless_borrows_for_generic_args)]
17008 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
17009 }
17010 if let Some(v) = self.info.as_ref() {
17011 match v {
17012 subscribe_response::Info::Database(v) => {
17013 struct_ser.serialize_field("database", v)?;
17014 }
17015 subscribe_response::Info::Schema(v) => {
17016 struct_ser.serialize_field("schema", v)?;
17017 }
17018 subscribe_response::Info::Function(v) => {
17019 struct_ser.serialize_field("function", v)?;
17020 }
17021 subscribe_response::Info::User(v) => {
17022 struct_ser.serialize_field("user", v)?;
17023 }
17024 subscribe_response::Info::SessionParam(v) => {
17025 struct_ser.serialize_field("sessionParam", v)?;
17026 }
17027 subscribe_response::Info::Node(v) => {
17028 struct_ser.serialize_field("node", v)?;
17029 }
17030 subscribe_response::Info::HummockVersionDeltas(v) => {
17031 struct_ser.serialize_field("hummockVersionDeltas", v)?;
17032 }
17033 subscribe_response::Info::Snapshot(v) => {
17034 struct_ser.serialize_field("snapshot", v)?;
17035 }
17036 subscribe_response::Info::MetaBackupManifestId(v) => {
17037 struct_ser.serialize_field("metaBackupManifestId", v)?;
17038 }
17039 subscribe_response::Info::SystemParams(v) => {
17040 struct_ser.serialize_field("systemParams", v)?;
17041 }
17042 subscribe_response::Info::HummockWriteLimits(v) => {
17043 struct_ser.serialize_field("hummockWriteLimits", v)?;
17044 }
17045 subscribe_response::Info::ObjectGroup(v) => {
17046 struct_ser.serialize_field("objectGroup", v)?;
17047 }
17048 subscribe_response::Info::Connection(v) => {
17049 struct_ser.serialize_field("connection", v)?;
17050 }
17051 subscribe_response::Info::HummockStats(v) => {
17052 struct_ser.serialize_field("hummockStats", v)?;
17053 }
17054 subscribe_response::Info::Recovery(v) => {
17055 struct_ser.serialize_field("recovery", v)?;
17056 }
17057 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
17058 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
17059 }
17060 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
17061 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
17062 }
17063 subscribe_response::Info::Secret(v) => {
17064 struct_ser.serialize_field("secret", v)?;
17065 }
17066 subscribe_response::Info::ClusterResource(v) => {
17067 struct_ser.serialize_field("clusterResource", v)?;
17068 }
17069 }
17070 }
17071 struct_ser.end()
17072 }
17073}
17074impl<'de> serde::Deserialize<'de> for SubscribeResponse {
17075 #[allow(deprecated)]
17076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17077 where
17078 D: serde::Deserializer<'de>,
17079 {
17080 const FIELDS: &[&str] = &[
17081 "status",
17082 "operation",
17083 "version",
17084 "database",
17085 "schema",
17086 "function",
17087 "user",
17088 "session_param",
17089 "sessionParam",
17090 "node",
17091 "hummock_version_deltas",
17092 "hummockVersionDeltas",
17093 "snapshot",
17094 "meta_backup_manifest_id",
17095 "metaBackupManifestId",
17096 "system_params",
17097 "systemParams",
17098 "hummock_write_limits",
17099 "hummockWriteLimits",
17100 "object_group",
17101 "objectGroup",
17102 "connection",
17103 "hummock_stats",
17104 "hummockStats",
17105 "recovery",
17106 "streaming_worker_slot_mapping",
17107 "streamingWorkerSlotMapping",
17108 "serving_worker_slot_mappings",
17109 "servingWorkerSlotMappings",
17110 "secret",
17111 "cluster_resource",
17112 "clusterResource",
17113 ];
17114
17115 #[allow(clippy::enum_variant_names)]
17116 enum GeneratedField {
17117 Status,
17118 Operation,
17119 Version,
17120 Database,
17121 Schema,
17122 Function,
17123 User,
17124 SessionParam,
17125 Node,
17126 HummockVersionDeltas,
17127 Snapshot,
17128 MetaBackupManifestId,
17129 SystemParams,
17130 HummockWriteLimits,
17131 ObjectGroup,
17132 Connection,
17133 HummockStats,
17134 Recovery,
17135 StreamingWorkerSlotMapping,
17136 ServingWorkerSlotMappings,
17137 Secret,
17138 ClusterResource,
17139 }
17140 impl<'de> serde::Deserialize<'de> for GeneratedField {
17141 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17142 where
17143 D: serde::Deserializer<'de>,
17144 {
17145 struct GeneratedVisitor;
17146
17147 impl serde::de::Visitor<'_> for GeneratedVisitor {
17148 type Value = GeneratedField;
17149
17150 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17151 write!(formatter, "expected one of: {:?}", &FIELDS)
17152 }
17153
17154 #[allow(unused_variables)]
17155 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17156 where
17157 E: serde::de::Error,
17158 {
17159 match value {
17160 "status" => Ok(GeneratedField::Status),
17161 "operation" => Ok(GeneratedField::Operation),
17162 "version" => Ok(GeneratedField::Version),
17163 "database" => Ok(GeneratedField::Database),
17164 "schema" => Ok(GeneratedField::Schema),
17165 "function" => Ok(GeneratedField::Function),
17166 "user" => Ok(GeneratedField::User),
17167 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
17168 "node" => Ok(GeneratedField::Node),
17169 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
17170 "snapshot" => Ok(GeneratedField::Snapshot),
17171 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
17172 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
17173 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
17174 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
17175 "connection" => Ok(GeneratedField::Connection),
17176 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
17177 "recovery" => Ok(GeneratedField::Recovery),
17178 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
17179 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
17180 "secret" => Ok(GeneratedField::Secret),
17181 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
17182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17183 }
17184 }
17185 }
17186 deserializer.deserialize_identifier(GeneratedVisitor)
17187 }
17188 }
17189 struct GeneratedVisitor;
17190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17191 type Value = SubscribeResponse;
17192
17193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17194 formatter.write_str("struct meta.SubscribeResponse")
17195 }
17196
17197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
17198 where
17199 V: serde::de::MapAccess<'de>,
17200 {
17201 let mut status__ = None;
17202 let mut operation__ = None;
17203 let mut version__ = None;
17204 let mut info__ = None;
17205 while let Some(k) = map_.next_key()? {
17206 match k {
17207 GeneratedField::Status => {
17208 if status__.is_some() {
17209 return Err(serde::de::Error::duplicate_field("status"));
17210 }
17211 status__ = map_.next_value()?;
17212 }
17213 GeneratedField::Operation => {
17214 if operation__.is_some() {
17215 return Err(serde::de::Error::duplicate_field("operation"));
17216 }
17217 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
17218 }
17219 GeneratedField::Version => {
17220 if version__.is_some() {
17221 return Err(serde::de::Error::duplicate_field("version"));
17222 }
17223 version__ =
17224 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17225 ;
17226 }
17227 GeneratedField::Database => {
17228 if info__.is_some() {
17229 return Err(serde::de::Error::duplicate_field("database"));
17230 }
17231 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
17232;
17233 }
17234 GeneratedField::Schema => {
17235 if info__.is_some() {
17236 return Err(serde::de::Error::duplicate_field("schema"));
17237 }
17238 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
17239;
17240 }
17241 GeneratedField::Function => {
17242 if info__.is_some() {
17243 return Err(serde::de::Error::duplicate_field("function"));
17244 }
17245 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
17246;
17247 }
17248 GeneratedField::User => {
17249 if info__.is_some() {
17250 return Err(serde::de::Error::duplicate_field("user"));
17251 }
17252 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
17253;
17254 }
17255 GeneratedField::SessionParam => {
17256 if info__.is_some() {
17257 return Err(serde::de::Error::duplicate_field("sessionParam"));
17258 }
17259 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
17260;
17261 }
17262 GeneratedField::Node => {
17263 if info__.is_some() {
17264 return Err(serde::de::Error::duplicate_field("node"));
17265 }
17266 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
17267;
17268 }
17269 GeneratedField::HummockVersionDeltas => {
17270 if info__.is_some() {
17271 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
17272 }
17273 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
17274;
17275 }
17276 GeneratedField::Snapshot => {
17277 if info__.is_some() {
17278 return Err(serde::de::Error::duplicate_field("snapshot"));
17279 }
17280 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
17281;
17282 }
17283 GeneratedField::MetaBackupManifestId => {
17284 if info__.is_some() {
17285 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
17286 }
17287 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
17288;
17289 }
17290 GeneratedField::SystemParams => {
17291 if info__.is_some() {
17292 return Err(serde::de::Error::duplicate_field("systemParams"));
17293 }
17294 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
17295;
17296 }
17297 GeneratedField::HummockWriteLimits => {
17298 if info__.is_some() {
17299 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
17300 }
17301 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
17302;
17303 }
17304 GeneratedField::ObjectGroup => {
17305 if info__.is_some() {
17306 return Err(serde::de::Error::duplicate_field("objectGroup"));
17307 }
17308 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
17309;
17310 }
17311 GeneratedField::Connection => {
17312 if info__.is_some() {
17313 return Err(serde::de::Error::duplicate_field("connection"));
17314 }
17315 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
17316;
17317 }
17318 GeneratedField::HummockStats => {
17319 if info__.is_some() {
17320 return Err(serde::de::Error::duplicate_field("hummockStats"));
17321 }
17322 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
17323;
17324 }
17325 GeneratedField::Recovery => {
17326 if info__.is_some() {
17327 return Err(serde::de::Error::duplicate_field("recovery"));
17328 }
17329 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
17330;
17331 }
17332 GeneratedField::StreamingWorkerSlotMapping => {
17333 if info__.is_some() {
17334 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
17335 }
17336 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
17337;
17338 }
17339 GeneratedField::ServingWorkerSlotMappings => {
17340 if info__.is_some() {
17341 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
17342 }
17343 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
17344;
17345 }
17346 GeneratedField::Secret => {
17347 if info__.is_some() {
17348 return Err(serde::de::Error::duplicate_field("secret"));
17349 }
17350 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
17351;
17352 }
17353 GeneratedField::ClusterResource => {
17354 if info__.is_some() {
17355 return Err(serde::de::Error::duplicate_field("clusterResource"));
17356 }
17357 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
17358;
17359 }
17360 }
17361 }
17362 Ok(SubscribeResponse {
17363 status: status__,
17364 operation: operation__.unwrap_or_default(),
17365 version: version__.unwrap_or_default(),
17366 info: info__,
17367 })
17368 }
17369 }
17370 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
17371 }
17372}
17373impl serde::Serialize for subscribe_response::Operation {
17374 #[allow(deprecated)]
17375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17376 where
17377 S: serde::Serializer,
17378 {
17379 let variant = match self {
17380 Self::Unspecified => "UNSPECIFIED",
17381 Self::Add => "ADD",
17382 Self::Delete => "DELETE",
17383 Self::Update => "UPDATE",
17384 Self::Snapshot => "SNAPSHOT",
17385 };
17386 serializer.serialize_str(variant)
17387 }
17388}
17389impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
17390 #[allow(deprecated)]
17391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17392 where
17393 D: serde::Deserializer<'de>,
17394 {
17395 const FIELDS: &[&str] = &[
17396 "UNSPECIFIED",
17397 "ADD",
17398 "DELETE",
17399 "UPDATE",
17400 "SNAPSHOT",
17401 ];
17402
17403 struct GeneratedVisitor;
17404
17405 impl serde::de::Visitor<'_> for GeneratedVisitor {
17406 type Value = subscribe_response::Operation;
17407
17408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17409 write!(formatter, "expected one of: {:?}", &FIELDS)
17410 }
17411
17412 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17413 where
17414 E: serde::de::Error,
17415 {
17416 i32::try_from(v)
17417 .ok()
17418 .and_then(|x| x.try_into().ok())
17419 .ok_or_else(|| {
17420 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17421 })
17422 }
17423
17424 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17425 where
17426 E: serde::de::Error,
17427 {
17428 i32::try_from(v)
17429 .ok()
17430 .and_then(|x| x.try_into().ok())
17431 .ok_or_else(|| {
17432 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17433 })
17434 }
17435
17436 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17437 where
17438 E: serde::de::Error,
17439 {
17440 match value {
17441 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17442 "ADD" => Ok(subscribe_response::Operation::Add),
17443 "DELETE" => Ok(subscribe_response::Operation::Delete),
17444 "UPDATE" => Ok(subscribe_response::Operation::Update),
17445 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17446 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17447 }
17448 }
17449 }
17450 deserializer.deserialize_any(GeneratedVisitor)
17451 }
17452}
17453impl serde::Serialize for SubscribeType {
17454 #[allow(deprecated)]
17455 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17456 where
17457 S: serde::Serializer,
17458 {
17459 let variant = match self {
17460 Self::Unspecified => "UNSPECIFIED",
17461 Self::Frontend => "FRONTEND",
17462 Self::Hummock => "HUMMOCK",
17463 Self::Compactor => "COMPACTOR",
17464 Self::Compute => "COMPUTE",
17465 };
17466 serializer.serialize_str(variant)
17467 }
17468}
17469impl<'de> serde::Deserialize<'de> for SubscribeType {
17470 #[allow(deprecated)]
17471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17472 where
17473 D: serde::Deserializer<'de>,
17474 {
17475 const FIELDS: &[&str] = &[
17476 "UNSPECIFIED",
17477 "FRONTEND",
17478 "HUMMOCK",
17479 "COMPACTOR",
17480 "COMPUTE",
17481 ];
17482
17483 struct GeneratedVisitor;
17484
17485 impl serde::de::Visitor<'_> for GeneratedVisitor {
17486 type Value = SubscribeType;
17487
17488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17489 write!(formatter, "expected one of: {:?}", &FIELDS)
17490 }
17491
17492 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17493 where
17494 E: serde::de::Error,
17495 {
17496 i32::try_from(v)
17497 .ok()
17498 .and_then(|x| x.try_into().ok())
17499 .ok_or_else(|| {
17500 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17501 })
17502 }
17503
17504 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17505 where
17506 E: serde::de::Error,
17507 {
17508 i32::try_from(v)
17509 .ok()
17510 .and_then(|x| x.try_into().ok())
17511 .ok_or_else(|| {
17512 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17513 })
17514 }
17515
17516 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17517 where
17518 E: serde::de::Error,
17519 {
17520 match value {
17521 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17522 "FRONTEND" => Ok(SubscribeType::Frontend),
17523 "HUMMOCK" => Ok(SubscribeType::Hummock),
17524 "COMPACTOR" => Ok(SubscribeType::Compactor),
17525 "COMPUTE" => Ok(SubscribeType::Compute),
17526 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17527 }
17528 }
17529 }
17530 deserializer.deserialize_any(GeneratedVisitor)
17531 }
17532}
17533impl serde::Serialize for SystemParams {
17534 #[allow(deprecated)]
17535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17536 where
17537 S: serde::Serializer,
17538 {
17539 use serde::ser::SerializeStruct;
17540 let mut len = 0;
17541 if self.barrier_interval_ms.is_some() {
17542 len += 1;
17543 }
17544 if self.checkpoint_frequency.is_some() {
17545 len += 1;
17546 }
17547 if self.sstable_size_mb.is_some() {
17548 len += 1;
17549 }
17550 if self.block_size_kb.is_some() {
17551 len += 1;
17552 }
17553 if self.bloom_false_positive.is_some() {
17554 len += 1;
17555 }
17556 if self.state_store.is_some() {
17557 len += 1;
17558 }
17559 if self.data_directory.is_some() {
17560 len += 1;
17561 }
17562 if self.backup_storage_url.is_some() {
17563 len += 1;
17564 }
17565 if self.backup_storage_directory.is_some() {
17566 len += 1;
17567 }
17568 if self.telemetry_enabled.is_some() {
17569 len += 1;
17570 }
17571 if self.parallel_compact_size_mb.is_some() {
17572 len += 1;
17573 }
17574 if self.max_concurrent_creating_streaming_jobs.is_some() {
17575 len += 1;
17576 }
17577 if self.pause_on_next_bootstrap.is_some() {
17578 len += 1;
17579 }
17580 if self.wasm_storage_url.is_some() {
17581 len += 1;
17582 }
17583 if self.enable_tracing.is_some() {
17584 len += 1;
17585 }
17586 if self.use_new_object_prefix_strategy.is_some() {
17587 len += 1;
17588 }
17589 if self.license_key.is_some() {
17590 len += 1;
17591 }
17592 if self.time_travel_retention_ms.is_some() {
17593 len += 1;
17594 }
17595 if self.adaptive_parallelism_strategy.is_some() {
17596 len += 1;
17597 }
17598 if self.per_database_isolation.is_some() {
17599 len += 1;
17600 }
17601 if self.enforce_secret.is_some() {
17602 len += 1;
17603 }
17604 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
17605 if let Some(v) = self.barrier_interval_ms.as_ref() {
17606 struct_ser.serialize_field("barrierIntervalMs", v)?;
17607 }
17608 if let Some(v) = self.checkpoint_frequency.as_ref() {
17609 #[allow(clippy::needless_borrow)]
17610 #[allow(clippy::needless_borrows_for_generic_args)]
17611 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
17612 }
17613 if let Some(v) = self.sstable_size_mb.as_ref() {
17614 struct_ser.serialize_field("sstableSizeMb", v)?;
17615 }
17616 if let Some(v) = self.block_size_kb.as_ref() {
17617 struct_ser.serialize_field("blockSizeKb", v)?;
17618 }
17619 if let Some(v) = self.bloom_false_positive.as_ref() {
17620 struct_ser.serialize_field("bloomFalsePositive", v)?;
17621 }
17622 if let Some(v) = self.state_store.as_ref() {
17623 struct_ser.serialize_field("stateStore", v)?;
17624 }
17625 if let Some(v) = self.data_directory.as_ref() {
17626 struct_ser.serialize_field("dataDirectory", v)?;
17627 }
17628 if let Some(v) = self.backup_storage_url.as_ref() {
17629 struct_ser.serialize_field("backupStorageUrl", v)?;
17630 }
17631 if let Some(v) = self.backup_storage_directory.as_ref() {
17632 struct_ser.serialize_field("backupStorageDirectory", v)?;
17633 }
17634 if let Some(v) = self.telemetry_enabled.as_ref() {
17635 struct_ser.serialize_field("telemetryEnabled", v)?;
17636 }
17637 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
17638 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
17639 }
17640 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
17641 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
17642 }
17643 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
17644 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
17645 }
17646 if let Some(v) = self.wasm_storage_url.as_ref() {
17647 struct_ser.serialize_field("wasmStorageUrl", v)?;
17648 }
17649 if let Some(v) = self.enable_tracing.as_ref() {
17650 struct_ser.serialize_field("enableTracing", v)?;
17651 }
17652 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
17653 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
17654 }
17655 if let Some(v) = self.license_key.as_ref() {
17656 struct_ser.serialize_field("licenseKey", v)?;
17657 }
17658 if let Some(v) = self.time_travel_retention_ms.as_ref() {
17659 #[allow(clippy::needless_borrow)]
17660 #[allow(clippy::needless_borrows_for_generic_args)]
17661 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
17662 }
17663 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
17664 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
17665 }
17666 if let Some(v) = self.per_database_isolation.as_ref() {
17667 struct_ser.serialize_field("perDatabaseIsolation", v)?;
17668 }
17669 if let Some(v) = self.enforce_secret.as_ref() {
17670 struct_ser.serialize_field("enforceSecret", v)?;
17671 }
17672 struct_ser.end()
17673 }
17674}
17675impl<'de> serde::Deserialize<'de> for SystemParams {
17676 #[allow(deprecated)]
17677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17678 where
17679 D: serde::Deserializer<'de>,
17680 {
17681 const FIELDS: &[&str] = &[
17682 "barrier_interval_ms",
17683 "barrierIntervalMs",
17684 "checkpoint_frequency",
17685 "checkpointFrequency",
17686 "sstable_size_mb",
17687 "sstableSizeMb",
17688 "block_size_kb",
17689 "blockSizeKb",
17690 "bloom_false_positive",
17691 "bloomFalsePositive",
17692 "state_store",
17693 "stateStore",
17694 "data_directory",
17695 "dataDirectory",
17696 "backup_storage_url",
17697 "backupStorageUrl",
17698 "backup_storage_directory",
17699 "backupStorageDirectory",
17700 "telemetry_enabled",
17701 "telemetryEnabled",
17702 "parallel_compact_size_mb",
17703 "parallelCompactSizeMb",
17704 "max_concurrent_creating_streaming_jobs",
17705 "maxConcurrentCreatingStreamingJobs",
17706 "pause_on_next_bootstrap",
17707 "pauseOnNextBootstrap",
17708 "wasm_storage_url",
17709 "wasmStorageUrl",
17710 "enable_tracing",
17711 "enableTracing",
17712 "use_new_object_prefix_strategy",
17713 "useNewObjectPrefixStrategy",
17714 "license_key",
17715 "licenseKey",
17716 "time_travel_retention_ms",
17717 "timeTravelRetentionMs",
17718 "adaptive_parallelism_strategy",
17719 "adaptiveParallelismStrategy",
17720 "per_database_isolation",
17721 "perDatabaseIsolation",
17722 "enforce_secret",
17723 "enforceSecret",
17724 ];
17725
17726 #[allow(clippy::enum_variant_names)]
17727 enum GeneratedField {
17728 BarrierIntervalMs,
17729 CheckpointFrequency,
17730 SstableSizeMb,
17731 BlockSizeKb,
17732 BloomFalsePositive,
17733 StateStore,
17734 DataDirectory,
17735 BackupStorageUrl,
17736 BackupStorageDirectory,
17737 TelemetryEnabled,
17738 ParallelCompactSizeMb,
17739 MaxConcurrentCreatingStreamingJobs,
17740 PauseOnNextBootstrap,
17741 WasmStorageUrl,
17742 EnableTracing,
17743 UseNewObjectPrefixStrategy,
17744 LicenseKey,
17745 TimeTravelRetentionMs,
17746 AdaptiveParallelismStrategy,
17747 PerDatabaseIsolation,
17748 EnforceSecret,
17749 }
17750 impl<'de> serde::Deserialize<'de> for GeneratedField {
17751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17752 where
17753 D: serde::Deserializer<'de>,
17754 {
17755 struct GeneratedVisitor;
17756
17757 impl serde::de::Visitor<'_> for GeneratedVisitor {
17758 type Value = GeneratedField;
17759
17760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17761 write!(formatter, "expected one of: {:?}", &FIELDS)
17762 }
17763
17764 #[allow(unused_variables)]
17765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17766 where
17767 E: serde::de::Error,
17768 {
17769 match value {
17770 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
17771 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
17772 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
17773 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
17774 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
17775 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
17776 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
17777 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
17778 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
17779 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
17780 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
17781 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
17782 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
17783 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
17784 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
17785 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
17786 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
17787 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
17788 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
17789 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
17790 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
17791 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17792 }
17793 }
17794 }
17795 deserializer.deserialize_identifier(GeneratedVisitor)
17796 }
17797 }
17798 struct GeneratedVisitor;
17799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17800 type Value = SystemParams;
17801
17802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17803 formatter.write_str("struct meta.SystemParams")
17804 }
17805
17806 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
17807 where
17808 V: serde::de::MapAccess<'de>,
17809 {
17810 let mut barrier_interval_ms__ = None;
17811 let mut checkpoint_frequency__ = None;
17812 let mut sstable_size_mb__ = None;
17813 let mut block_size_kb__ = None;
17814 let mut bloom_false_positive__ = None;
17815 let mut state_store__ = None;
17816 let mut data_directory__ = None;
17817 let mut backup_storage_url__ = None;
17818 let mut backup_storage_directory__ = None;
17819 let mut telemetry_enabled__ = None;
17820 let mut parallel_compact_size_mb__ = None;
17821 let mut max_concurrent_creating_streaming_jobs__ = None;
17822 let mut pause_on_next_bootstrap__ = None;
17823 let mut wasm_storage_url__ = None;
17824 let mut enable_tracing__ = None;
17825 let mut use_new_object_prefix_strategy__ = None;
17826 let mut license_key__ = None;
17827 let mut time_travel_retention_ms__ = None;
17828 let mut adaptive_parallelism_strategy__ = None;
17829 let mut per_database_isolation__ = None;
17830 let mut enforce_secret__ = None;
17831 while let Some(k) = map_.next_key()? {
17832 match k {
17833 GeneratedField::BarrierIntervalMs => {
17834 if barrier_interval_ms__.is_some() {
17835 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
17836 }
17837 barrier_interval_ms__ =
17838 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17839 ;
17840 }
17841 GeneratedField::CheckpointFrequency => {
17842 if checkpoint_frequency__.is_some() {
17843 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
17844 }
17845 checkpoint_frequency__ =
17846 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17847 ;
17848 }
17849 GeneratedField::SstableSizeMb => {
17850 if sstable_size_mb__.is_some() {
17851 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
17852 }
17853 sstable_size_mb__ =
17854 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17855 ;
17856 }
17857 GeneratedField::BlockSizeKb => {
17858 if block_size_kb__.is_some() {
17859 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
17860 }
17861 block_size_kb__ =
17862 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17863 ;
17864 }
17865 GeneratedField::BloomFalsePositive => {
17866 if bloom_false_positive__.is_some() {
17867 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
17868 }
17869 bloom_false_positive__ =
17870 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17871 ;
17872 }
17873 GeneratedField::StateStore => {
17874 if state_store__.is_some() {
17875 return Err(serde::de::Error::duplicate_field("stateStore"));
17876 }
17877 state_store__ = map_.next_value()?;
17878 }
17879 GeneratedField::DataDirectory => {
17880 if data_directory__.is_some() {
17881 return Err(serde::de::Error::duplicate_field("dataDirectory"));
17882 }
17883 data_directory__ = map_.next_value()?;
17884 }
17885 GeneratedField::BackupStorageUrl => {
17886 if backup_storage_url__.is_some() {
17887 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
17888 }
17889 backup_storage_url__ = map_.next_value()?;
17890 }
17891 GeneratedField::BackupStorageDirectory => {
17892 if backup_storage_directory__.is_some() {
17893 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
17894 }
17895 backup_storage_directory__ = map_.next_value()?;
17896 }
17897 GeneratedField::TelemetryEnabled => {
17898 if telemetry_enabled__.is_some() {
17899 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
17900 }
17901 telemetry_enabled__ = map_.next_value()?;
17902 }
17903 GeneratedField::ParallelCompactSizeMb => {
17904 if parallel_compact_size_mb__.is_some() {
17905 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
17906 }
17907 parallel_compact_size_mb__ =
17908 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17909 ;
17910 }
17911 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
17912 if max_concurrent_creating_streaming_jobs__.is_some() {
17913 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
17914 }
17915 max_concurrent_creating_streaming_jobs__ =
17916 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17917 ;
17918 }
17919 GeneratedField::PauseOnNextBootstrap => {
17920 if pause_on_next_bootstrap__.is_some() {
17921 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
17922 }
17923 pause_on_next_bootstrap__ = map_.next_value()?;
17924 }
17925 GeneratedField::WasmStorageUrl => {
17926 if wasm_storage_url__.is_some() {
17927 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
17928 }
17929 wasm_storage_url__ = map_.next_value()?;
17930 }
17931 GeneratedField::EnableTracing => {
17932 if enable_tracing__.is_some() {
17933 return Err(serde::de::Error::duplicate_field("enableTracing"));
17934 }
17935 enable_tracing__ = map_.next_value()?;
17936 }
17937 GeneratedField::UseNewObjectPrefixStrategy => {
17938 if use_new_object_prefix_strategy__.is_some() {
17939 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
17940 }
17941 use_new_object_prefix_strategy__ = map_.next_value()?;
17942 }
17943 GeneratedField::LicenseKey => {
17944 if license_key__.is_some() {
17945 return Err(serde::de::Error::duplicate_field("licenseKey"));
17946 }
17947 license_key__ = map_.next_value()?;
17948 }
17949 GeneratedField::TimeTravelRetentionMs => {
17950 if time_travel_retention_ms__.is_some() {
17951 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
17952 }
17953 time_travel_retention_ms__ =
17954 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17955 ;
17956 }
17957 GeneratedField::AdaptiveParallelismStrategy => {
17958 if adaptive_parallelism_strategy__.is_some() {
17959 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
17960 }
17961 adaptive_parallelism_strategy__ = map_.next_value()?;
17962 }
17963 GeneratedField::PerDatabaseIsolation => {
17964 if per_database_isolation__.is_some() {
17965 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
17966 }
17967 per_database_isolation__ = map_.next_value()?;
17968 }
17969 GeneratedField::EnforceSecret => {
17970 if enforce_secret__.is_some() {
17971 return Err(serde::de::Error::duplicate_field("enforceSecret"));
17972 }
17973 enforce_secret__ = map_.next_value()?;
17974 }
17975 }
17976 }
17977 Ok(SystemParams {
17978 barrier_interval_ms: barrier_interval_ms__,
17979 checkpoint_frequency: checkpoint_frequency__,
17980 sstable_size_mb: sstable_size_mb__,
17981 block_size_kb: block_size_kb__,
17982 bloom_false_positive: bloom_false_positive__,
17983 state_store: state_store__,
17984 data_directory: data_directory__,
17985 backup_storage_url: backup_storage_url__,
17986 backup_storage_directory: backup_storage_directory__,
17987 telemetry_enabled: telemetry_enabled__,
17988 parallel_compact_size_mb: parallel_compact_size_mb__,
17989 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
17990 pause_on_next_bootstrap: pause_on_next_bootstrap__,
17991 wasm_storage_url: wasm_storage_url__,
17992 enable_tracing: enable_tracing__,
17993 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
17994 license_key: license_key__,
17995 time_travel_retention_ms: time_travel_retention_ms__,
17996 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
17997 per_database_isolation: per_database_isolation__,
17998 enforce_secret: enforce_secret__,
17999 })
18000 }
18001 }
18002 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
18003 }
18004}
18005impl serde::Serialize for TableFragments {
18006 #[allow(deprecated)]
18007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18008 where
18009 S: serde::Serializer,
18010 {
18011 use serde::ser::SerializeStruct;
18012 let mut len = 0;
18013 if self.table_id != 0 {
18014 len += 1;
18015 }
18016 if self.state != 0 {
18017 len += 1;
18018 }
18019 if !self.fragments.is_empty() {
18020 len += 1;
18021 }
18022 if !self.actor_status.is_empty() {
18023 len += 1;
18024 }
18025 if self.ctx.is_some() {
18026 len += 1;
18027 }
18028 if self.max_parallelism.is_some() {
18029 len += 1;
18030 }
18031 if !self.node_label.is_empty() {
18032 len += 1;
18033 }
18034 if self.backfill_done {
18035 len += 1;
18036 }
18037 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
18038 if self.table_id != 0 {
18039 struct_ser.serialize_field("tableId", &self.table_id)?;
18040 }
18041 if self.state != 0 {
18042 let v = table_fragments::State::try_from(self.state)
18043 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
18044 struct_ser.serialize_field("state", &v)?;
18045 }
18046 if !self.fragments.is_empty() {
18047 struct_ser.serialize_field("fragments", &self.fragments)?;
18048 }
18049 if !self.actor_status.is_empty() {
18050 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
18051 }
18052 if let Some(v) = self.ctx.as_ref() {
18053 struct_ser.serialize_field("ctx", v)?;
18054 }
18055 if let Some(v) = self.max_parallelism.as_ref() {
18056 struct_ser.serialize_field("maxParallelism", v)?;
18057 }
18058 if !self.node_label.is_empty() {
18059 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18060 }
18061 if self.backfill_done {
18062 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
18063 }
18064 struct_ser.end()
18065 }
18066}
18067impl<'de> serde::Deserialize<'de> for TableFragments {
18068 #[allow(deprecated)]
18069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18070 where
18071 D: serde::Deserializer<'de>,
18072 {
18073 const FIELDS: &[&str] = &[
18074 "table_id",
18075 "tableId",
18076 "state",
18077 "fragments",
18078 "actor_status",
18079 "actorStatus",
18080 "ctx",
18081 "max_parallelism",
18082 "maxParallelism",
18083 "node_label",
18084 "nodeLabel",
18085 "backfill_done",
18086 "backfillDone",
18087 ];
18088
18089 #[allow(clippy::enum_variant_names)]
18090 enum GeneratedField {
18091 TableId,
18092 State,
18093 Fragments,
18094 ActorStatus,
18095 Ctx,
18096 MaxParallelism,
18097 NodeLabel,
18098 BackfillDone,
18099 }
18100 impl<'de> serde::Deserialize<'de> for GeneratedField {
18101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18102 where
18103 D: serde::Deserializer<'de>,
18104 {
18105 struct GeneratedVisitor;
18106
18107 impl serde::de::Visitor<'_> for GeneratedVisitor {
18108 type Value = GeneratedField;
18109
18110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18111 write!(formatter, "expected one of: {:?}", &FIELDS)
18112 }
18113
18114 #[allow(unused_variables)]
18115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18116 where
18117 E: serde::de::Error,
18118 {
18119 match value {
18120 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18121 "state" => Ok(GeneratedField::State),
18122 "fragments" => Ok(GeneratedField::Fragments),
18123 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
18124 "ctx" => Ok(GeneratedField::Ctx),
18125 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
18126 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18127 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
18128 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18129 }
18130 }
18131 }
18132 deserializer.deserialize_identifier(GeneratedVisitor)
18133 }
18134 }
18135 struct GeneratedVisitor;
18136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18137 type Value = TableFragments;
18138
18139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18140 formatter.write_str("struct meta.TableFragments")
18141 }
18142
18143 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
18144 where
18145 V: serde::de::MapAccess<'de>,
18146 {
18147 let mut table_id__ = None;
18148 let mut state__ = None;
18149 let mut fragments__ = None;
18150 let mut actor_status__ = None;
18151 let mut ctx__ = None;
18152 let mut max_parallelism__ = None;
18153 let mut node_label__ = None;
18154 let mut backfill_done__ = None;
18155 while let Some(k) = map_.next_key()? {
18156 match k {
18157 GeneratedField::TableId => {
18158 if table_id__.is_some() {
18159 return Err(serde::de::Error::duplicate_field("tableId"));
18160 }
18161 table_id__ =
18162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18163 ;
18164 }
18165 GeneratedField::State => {
18166 if state__.is_some() {
18167 return Err(serde::de::Error::duplicate_field("state"));
18168 }
18169 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
18170 }
18171 GeneratedField::Fragments => {
18172 if fragments__.is_some() {
18173 return Err(serde::de::Error::duplicate_field("fragments"));
18174 }
18175 fragments__ = Some(
18176 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18177 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18178 );
18179 }
18180 GeneratedField::ActorStatus => {
18181 if actor_status__.is_some() {
18182 return Err(serde::de::Error::duplicate_field("actorStatus"));
18183 }
18184 actor_status__ = 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::Ctx => {
18190 if ctx__.is_some() {
18191 return Err(serde::de::Error::duplicate_field("ctx"));
18192 }
18193 ctx__ = map_.next_value()?;
18194 }
18195 GeneratedField::MaxParallelism => {
18196 if max_parallelism__.is_some() {
18197 return Err(serde::de::Error::duplicate_field("maxParallelism"));
18198 }
18199 max_parallelism__ =
18200 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18201 ;
18202 }
18203 GeneratedField::NodeLabel => {
18204 if node_label__.is_some() {
18205 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18206 }
18207 node_label__ = Some(map_.next_value()?);
18208 }
18209 GeneratedField::BackfillDone => {
18210 if backfill_done__.is_some() {
18211 return Err(serde::de::Error::duplicate_field("backfillDone"));
18212 }
18213 backfill_done__ = Some(map_.next_value()?);
18214 }
18215 }
18216 }
18217 Ok(TableFragments {
18218 table_id: table_id__.unwrap_or_default(),
18219 state: state__.unwrap_or_default(),
18220 fragments: fragments__.unwrap_or_default(),
18221 actor_status: actor_status__.unwrap_or_default(),
18222 ctx: ctx__,
18223 max_parallelism: max_parallelism__,
18224 node_label: node_label__.unwrap_or_default(),
18225 backfill_done: backfill_done__.unwrap_or_default(),
18226 })
18227 }
18228 }
18229 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
18230 }
18231}
18232impl serde::Serialize for table_fragments::ActorStatus {
18233 #[allow(deprecated)]
18234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18235 where
18236 S: serde::Serializer,
18237 {
18238 use serde::ser::SerializeStruct;
18239 let mut len = 0;
18240 if self.location.is_some() {
18241 len += 1;
18242 }
18243 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
18244 if let Some(v) = self.location.as_ref() {
18245 struct_ser.serialize_field("location", v)?;
18246 }
18247 struct_ser.end()
18248 }
18249}
18250impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
18251 #[allow(deprecated)]
18252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18253 where
18254 D: serde::Deserializer<'de>,
18255 {
18256 const FIELDS: &[&str] = &[
18257 "location",
18258 ];
18259
18260 #[allow(clippy::enum_variant_names)]
18261 enum GeneratedField {
18262 Location,
18263 }
18264 impl<'de> serde::Deserialize<'de> for GeneratedField {
18265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18266 where
18267 D: serde::Deserializer<'de>,
18268 {
18269 struct GeneratedVisitor;
18270
18271 impl serde::de::Visitor<'_> for GeneratedVisitor {
18272 type Value = GeneratedField;
18273
18274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18275 write!(formatter, "expected one of: {:?}", &FIELDS)
18276 }
18277
18278 #[allow(unused_variables)]
18279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18280 where
18281 E: serde::de::Error,
18282 {
18283 match value {
18284 "location" => Ok(GeneratedField::Location),
18285 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18286 }
18287 }
18288 }
18289 deserializer.deserialize_identifier(GeneratedVisitor)
18290 }
18291 }
18292 struct GeneratedVisitor;
18293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18294 type Value = table_fragments::ActorStatus;
18295
18296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18297 formatter.write_str("struct meta.TableFragments.ActorStatus")
18298 }
18299
18300 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
18301 where
18302 V: serde::de::MapAccess<'de>,
18303 {
18304 let mut location__ = None;
18305 while let Some(k) = map_.next_key()? {
18306 match k {
18307 GeneratedField::Location => {
18308 if location__.is_some() {
18309 return Err(serde::de::Error::duplicate_field("location"));
18310 }
18311 location__ = map_.next_value()?;
18312 }
18313 }
18314 }
18315 Ok(table_fragments::ActorStatus {
18316 location: location__,
18317 })
18318 }
18319 }
18320 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
18321 }
18322}
18323impl serde::Serialize for table_fragments::Fragment {
18324 #[allow(deprecated)]
18325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18326 where
18327 S: serde::Serializer,
18328 {
18329 use serde::ser::SerializeStruct;
18330 let mut len = 0;
18331 if self.fragment_id != 0 {
18332 len += 1;
18333 }
18334 if self.fragment_type_mask != 0 {
18335 len += 1;
18336 }
18337 if self.distribution_type != 0 {
18338 len += 1;
18339 }
18340 if !self.actors.is_empty() {
18341 len += 1;
18342 }
18343 if !self.state_table_ids.is_empty() {
18344 len += 1;
18345 }
18346 if !self.upstream_fragment_ids.is_empty() {
18347 len += 1;
18348 }
18349 if self.maybe_vnode_count.is_some() {
18350 len += 1;
18351 }
18352 if self.nodes.is_some() {
18353 len += 1;
18354 }
18355 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
18356 if self.fragment_id != 0 {
18357 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
18358 }
18359 if self.fragment_type_mask != 0 {
18360 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
18361 }
18362 if self.distribution_type != 0 {
18363 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
18364 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
18365 struct_ser.serialize_field("distributionType", &v)?;
18366 }
18367 if !self.actors.is_empty() {
18368 struct_ser.serialize_field("actors", &self.actors)?;
18369 }
18370 if !self.state_table_ids.is_empty() {
18371 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
18372 }
18373 if !self.upstream_fragment_ids.is_empty() {
18374 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
18375 }
18376 if let Some(v) = self.maybe_vnode_count.as_ref() {
18377 struct_ser.serialize_field("maybeVnodeCount", v)?;
18378 }
18379 if let Some(v) = self.nodes.as_ref() {
18380 struct_ser.serialize_field("nodes", v)?;
18381 }
18382 struct_ser.end()
18383 }
18384}
18385impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
18386 #[allow(deprecated)]
18387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18388 where
18389 D: serde::Deserializer<'de>,
18390 {
18391 const FIELDS: &[&str] = &[
18392 "fragment_id",
18393 "fragmentId",
18394 "fragment_type_mask",
18395 "fragmentTypeMask",
18396 "distribution_type",
18397 "distributionType",
18398 "actors",
18399 "state_table_ids",
18400 "stateTableIds",
18401 "upstream_fragment_ids",
18402 "upstreamFragmentIds",
18403 "maybe_vnode_count",
18404 "maybeVnodeCount",
18405 "nodes",
18406 ];
18407
18408 #[allow(clippy::enum_variant_names)]
18409 enum GeneratedField {
18410 FragmentId,
18411 FragmentTypeMask,
18412 DistributionType,
18413 Actors,
18414 StateTableIds,
18415 UpstreamFragmentIds,
18416 MaybeVnodeCount,
18417 Nodes,
18418 }
18419 impl<'de> serde::Deserialize<'de> for GeneratedField {
18420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18421 where
18422 D: serde::Deserializer<'de>,
18423 {
18424 struct GeneratedVisitor;
18425
18426 impl serde::de::Visitor<'_> for GeneratedVisitor {
18427 type Value = GeneratedField;
18428
18429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18430 write!(formatter, "expected one of: {:?}", &FIELDS)
18431 }
18432
18433 #[allow(unused_variables)]
18434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18435 where
18436 E: serde::de::Error,
18437 {
18438 match value {
18439 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
18440 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
18441 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
18442 "actors" => Ok(GeneratedField::Actors),
18443 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
18444 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
18445 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
18446 "nodes" => Ok(GeneratedField::Nodes),
18447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18448 }
18449 }
18450 }
18451 deserializer.deserialize_identifier(GeneratedVisitor)
18452 }
18453 }
18454 struct GeneratedVisitor;
18455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18456 type Value = table_fragments::Fragment;
18457
18458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18459 formatter.write_str("struct meta.TableFragments.Fragment")
18460 }
18461
18462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
18463 where
18464 V: serde::de::MapAccess<'de>,
18465 {
18466 let mut fragment_id__ = None;
18467 let mut fragment_type_mask__ = None;
18468 let mut distribution_type__ = None;
18469 let mut actors__ = None;
18470 let mut state_table_ids__ = None;
18471 let mut upstream_fragment_ids__ = None;
18472 let mut maybe_vnode_count__ = None;
18473 let mut nodes__ = None;
18474 while let Some(k) = map_.next_key()? {
18475 match k {
18476 GeneratedField::FragmentId => {
18477 if fragment_id__.is_some() {
18478 return Err(serde::de::Error::duplicate_field("fragmentId"));
18479 }
18480 fragment_id__ =
18481 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18482 ;
18483 }
18484 GeneratedField::FragmentTypeMask => {
18485 if fragment_type_mask__.is_some() {
18486 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
18487 }
18488 fragment_type_mask__ =
18489 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18490 ;
18491 }
18492 GeneratedField::DistributionType => {
18493 if distribution_type__.is_some() {
18494 return Err(serde::de::Error::duplicate_field("distributionType"));
18495 }
18496 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
18497 }
18498 GeneratedField::Actors => {
18499 if actors__.is_some() {
18500 return Err(serde::de::Error::duplicate_field("actors"));
18501 }
18502 actors__ = Some(map_.next_value()?);
18503 }
18504 GeneratedField::StateTableIds => {
18505 if state_table_ids__.is_some() {
18506 return Err(serde::de::Error::duplicate_field("stateTableIds"));
18507 }
18508 state_table_ids__ =
18509 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18510 .into_iter().map(|x| x.0).collect())
18511 ;
18512 }
18513 GeneratedField::UpstreamFragmentIds => {
18514 if upstream_fragment_ids__.is_some() {
18515 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
18516 }
18517 upstream_fragment_ids__ =
18518 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18519 .into_iter().map(|x| x.0).collect())
18520 ;
18521 }
18522 GeneratedField::MaybeVnodeCount => {
18523 if maybe_vnode_count__.is_some() {
18524 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
18525 }
18526 maybe_vnode_count__ =
18527 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18528 ;
18529 }
18530 GeneratedField::Nodes => {
18531 if nodes__.is_some() {
18532 return Err(serde::de::Error::duplicate_field("nodes"));
18533 }
18534 nodes__ = map_.next_value()?;
18535 }
18536 }
18537 }
18538 Ok(table_fragments::Fragment {
18539 fragment_id: fragment_id__.unwrap_or_default(),
18540 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
18541 distribution_type: distribution_type__.unwrap_or_default(),
18542 actors: actors__.unwrap_or_default(),
18543 state_table_ids: state_table_ids__.unwrap_or_default(),
18544 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
18545 maybe_vnode_count: maybe_vnode_count__,
18546 nodes: nodes__,
18547 })
18548 }
18549 }
18550 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
18551 }
18552}
18553impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
18554 #[allow(deprecated)]
18555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18556 where
18557 S: serde::Serializer,
18558 {
18559 let variant = match self {
18560 Self::Unspecified => "UNSPECIFIED",
18561 Self::Single => "SINGLE",
18562 Self::Hash => "HASH",
18563 };
18564 serializer.serialize_str(variant)
18565 }
18566}
18567impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
18568 #[allow(deprecated)]
18569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18570 where
18571 D: serde::Deserializer<'de>,
18572 {
18573 const FIELDS: &[&str] = &[
18574 "UNSPECIFIED",
18575 "SINGLE",
18576 "HASH",
18577 ];
18578
18579 struct GeneratedVisitor;
18580
18581 impl serde::de::Visitor<'_> for GeneratedVisitor {
18582 type Value = table_fragments::fragment::FragmentDistributionType;
18583
18584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18585 write!(formatter, "expected one of: {:?}", &FIELDS)
18586 }
18587
18588 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18589 where
18590 E: serde::de::Error,
18591 {
18592 i32::try_from(v)
18593 .ok()
18594 .and_then(|x| x.try_into().ok())
18595 .ok_or_else(|| {
18596 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18597 })
18598 }
18599
18600 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18601 where
18602 E: serde::de::Error,
18603 {
18604 i32::try_from(v)
18605 .ok()
18606 .and_then(|x| x.try_into().ok())
18607 .ok_or_else(|| {
18608 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18609 })
18610 }
18611
18612 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18613 where
18614 E: serde::de::Error,
18615 {
18616 match value {
18617 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
18618 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
18619 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
18620 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18621 }
18622 }
18623 }
18624 deserializer.deserialize_any(GeneratedVisitor)
18625 }
18626}
18627impl serde::Serialize for table_fragments::State {
18628 #[allow(deprecated)]
18629 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18630 where
18631 S: serde::Serializer,
18632 {
18633 let variant = match self {
18634 Self::Unspecified => "UNSPECIFIED",
18635 Self::Initial => "INITIAL",
18636 Self::Creating => "CREATING",
18637 Self::Created => "CREATED",
18638 };
18639 serializer.serialize_str(variant)
18640 }
18641}
18642impl<'de> serde::Deserialize<'de> for table_fragments::State {
18643 #[allow(deprecated)]
18644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18645 where
18646 D: serde::Deserializer<'de>,
18647 {
18648 const FIELDS: &[&str] = &[
18649 "UNSPECIFIED",
18650 "INITIAL",
18651 "CREATING",
18652 "CREATED",
18653 ];
18654
18655 struct GeneratedVisitor;
18656
18657 impl serde::de::Visitor<'_> for GeneratedVisitor {
18658 type Value = table_fragments::State;
18659
18660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18661 write!(formatter, "expected one of: {:?}", &FIELDS)
18662 }
18663
18664 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18665 where
18666 E: serde::de::Error,
18667 {
18668 i32::try_from(v)
18669 .ok()
18670 .and_then(|x| x.try_into().ok())
18671 .ok_or_else(|| {
18672 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18673 })
18674 }
18675
18676 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18677 where
18678 E: serde::de::Error,
18679 {
18680 i32::try_from(v)
18681 .ok()
18682 .and_then(|x| x.try_into().ok())
18683 .ok_or_else(|| {
18684 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18685 })
18686 }
18687
18688 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18689 where
18690 E: serde::de::Error,
18691 {
18692 match value {
18693 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
18694 "INITIAL" => Ok(table_fragments::State::Initial),
18695 "CREATING" => Ok(table_fragments::State::Creating),
18696 "CREATED" => Ok(table_fragments::State::Created),
18697 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18698 }
18699 }
18700 }
18701 deserializer.deserialize_any(GeneratedVisitor)
18702 }
18703}
18704impl serde::Serialize for TableParallelism {
18705 #[allow(deprecated)]
18706 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18707 where
18708 S: serde::Serializer,
18709 {
18710 use serde::ser::SerializeStruct;
18711 let mut len = 0;
18712 if self.parallelism.is_some() {
18713 len += 1;
18714 }
18715 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
18716 if let Some(v) = self.parallelism.as_ref() {
18717 match v {
18718 table_parallelism::Parallelism::Fixed(v) => {
18719 struct_ser.serialize_field("fixed", v)?;
18720 }
18721 table_parallelism::Parallelism::Auto(v) => {
18722 struct_ser.serialize_field("auto", v)?;
18723 }
18724 table_parallelism::Parallelism::Custom(v) => {
18725 struct_ser.serialize_field("custom", v)?;
18726 }
18727 table_parallelism::Parallelism::Adaptive(v) => {
18728 struct_ser.serialize_field("adaptive", v)?;
18729 }
18730 }
18731 }
18732 struct_ser.end()
18733 }
18734}
18735impl<'de> serde::Deserialize<'de> for TableParallelism {
18736 #[allow(deprecated)]
18737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18738 where
18739 D: serde::Deserializer<'de>,
18740 {
18741 const FIELDS: &[&str] = &[
18742 "fixed",
18743 "auto",
18744 "custom",
18745 "adaptive",
18746 ];
18747
18748 #[allow(clippy::enum_variant_names)]
18749 enum GeneratedField {
18750 Fixed,
18751 Auto,
18752 Custom,
18753 Adaptive,
18754 }
18755 impl<'de> serde::Deserialize<'de> for GeneratedField {
18756 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18757 where
18758 D: serde::Deserializer<'de>,
18759 {
18760 struct GeneratedVisitor;
18761
18762 impl serde::de::Visitor<'_> for GeneratedVisitor {
18763 type Value = GeneratedField;
18764
18765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18766 write!(formatter, "expected one of: {:?}", &FIELDS)
18767 }
18768
18769 #[allow(unused_variables)]
18770 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18771 where
18772 E: serde::de::Error,
18773 {
18774 match value {
18775 "fixed" => Ok(GeneratedField::Fixed),
18776 "auto" => Ok(GeneratedField::Auto),
18777 "custom" => Ok(GeneratedField::Custom),
18778 "adaptive" => Ok(GeneratedField::Adaptive),
18779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18780 }
18781 }
18782 }
18783 deserializer.deserialize_identifier(GeneratedVisitor)
18784 }
18785 }
18786 struct GeneratedVisitor;
18787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18788 type Value = TableParallelism;
18789
18790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18791 formatter.write_str("struct meta.TableParallelism")
18792 }
18793
18794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
18795 where
18796 V: serde::de::MapAccess<'de>,
18797 {
18798 let mut parallelism__ = None;
18799 while let Some(k) = map_.next_key()? {
18800 match k {
18801 GeneratedField::Fixed => {
18802 if parallelism__.is_some() {
18803 return Err(serde::de::Error::duplicate_field("fixed"));
18804 }
18805 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
18806;
18807 }
18808 GeneratedField::Auto => {
18809 if parallelism__.is_some() {
18810 return Err(serde::de::Error::duplicate_field("auto"));
18811 }
18812 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
18813;
18814 }
18815 GeneratedField::Custom => {
18816 if parallelism__.is_some() {
18817 return Err(serde::de::Error::duplicate_field("custom"));
18818 }
18819 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
18820;
18821 }
18822 GeneratedField::Adaptive => {
18823 if parallelism__.is_some() {
18824 return Err(serde::de::Error::duplicate_field("adaptive"));
18825 }
18826 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
18827;
18828 }
18829 }
18830 }
18831 Ok(TableParallelism {
18832 parallelism: parallelism__,
18833 })
18834 }
18835 }
18836 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
18837 }
18838}
18839impl serde::Serialize for table_parallelism::AdaptiveParallelism {
18840 #[allow(deprecated)]
18841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18842 where
18843 S: serde::Serializer,
18844 {
18845 use serde::ser::SerializeStruct;
18846 let len = 0;
18847 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
18848 struct_ser.end()
18849 }
18850}
18851impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
18852 #[allow(deprecated)]
18853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18854 where
18855 D: serde::Deserializer<'de>,
18856 {
18857 const FIELDS: &[&str] = &[
18858 ];
18859
18860 #[allow(clippy::enum_variant_names)]
18861 enum GeneratedField {
18862 }
18863 impl<'de> serde::Deserialize<'de> for GeneratedField {
18864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18865 where
18866 D: serde::Deserializer<'de>,
18867 {
18868 struct GeneratedVisitor;
18869
18870 impl serde::de::Visitor<'_> for GeneratedVisitor {
18871 type Value = GeneratedField;
18872
18873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18874 write!(formatter, "expected one of: {:?}", &FIELDS)
18875 }
18876
18877 #[allow(unused_variables)]
18878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18879 where
18880 E: serde::de::Error,
18881 {
18882 Err(serde::de::Error::unknown_field(value, FIELDS))
18883 }
18884 }
18885 deserializer.deserialize_identifier(GeneratedVisitor)
18886 }
18887 }
18888 struct GeneratedVisitor;
18889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18890 type Value = table_parallelism::AdaptiveParallelism;
18891
18892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18893 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
18894 }
18895
18896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
18897 where
18898 V: serde::de::MapAccess<'de>,
18899 {
18900 while map_.next_key::<GeneratedField>()?.is_some() {
18901 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18902 }
18903 Ok(table_parallelism::AdaptiveParallelism {
18904 })
18905 }
18906 }
18907 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
18908 }
18909}
18910impl serde::Serialize for table_parallelism::AutoParallelism {
18911 #[allow(deprecated)]
18912 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18913 where
18914 S: serde::Serializer,
18915 {
18916 use serde::ser::SerializeStruct;
18917 let len = 0;
18918 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
18919 struct_ser.end()
18920 }
18921}
18922impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
18923 #[allow(deprecated)]
18924 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18925 where
18926 D: serde::Deserializer<'de>,
18927 {
18928 const FIELDS: &[&str] = &[
18929 ];
18930
18931 #[allow(clippy::enum_variant_names)]
18932 enum GeneratedField {
18933 }
18934 impl<'de> serde::Deserialize<'de> for GeneratedField {
18935 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18936 where
18937 D: serde::Deserializer<'de>,
18938 {
18939 struct GeneratedVisitor;
18940
18941 impl serde::de::Visitor<'_> for GeneratedVisitor {
18942 type Value = GeneratedField;
18943
18944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18945 write!(formatter, "expected one of: {:?}", &FIELDS)
18946 }
18947
18948 #[allow(unused_variables)]
18949 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18950 where
18951 E: serde::de::Error,
18952 {
18953 Err(serde::de::Error::unknown_field(value, FIELDS))
18954 }
18955 }
18956 deserializer.deserialize_identifier(GeneratedVisitor)
18957 }
18958 }
18959 struct GeneratedVisitor;
18960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18961 type Value = table_parallelism::AutoParallelism;
18962
18963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18964 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
18965 }
18966
18967 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
18968 where
18969 V: serde::de::MapAccess<'de>,
18970 {
18971 while map_.next_key::<GeneratedField>()?.is_some() {
18972 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18973 }
18974 Ok(table_parallelism::AutoParallelism {
18975 })
18976 }
18977 }
18978 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
18979 }
18980}
18981impl serde::Serialize for table_parallelism::CustomParallelism {
18982 #[allow(deprecated)]
18983 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18984 where
18985 S: serde::Serializer,
18986 {
18987 use serde::ser::SerializeStruct;
18988 let len = 0;
18989 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
18990 struct_ser.end()
18991 }
18992}
18993impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
18994 #[allow(deprecated)]
18995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18996 where
18997 D: serde::Deserializer<'de>,
18998 {
18999 const FIELDS: &[&str] = &[
19000 ];
19001
19002 #[allow(clippy::enum_variant_names)]
19003 enum GeneratedField {
19004 }
19005 impl<'de> serde::Deserialize<'de> for GeneratedField {
19006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19007 where
19008 D: serde::Deserializer<'de>,
19009 {
19010 struct GeneratedVisitor;
19011
19012 impl serde::de::Visitor<'_> for GeneratedVisitor {
19013 type Value = GeneratedField;
19014
19015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19016 write!(formatter, "expected one of: {:?}", &FIELDS)
19017 }
19018
19019 #[allow(unused_variables)]
19020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19021 where
19022 E: serde::de::Error,
19023 {
19024 Err(serde::de::Error::unknown_field(value, FIELDS))
19025 }
19026 }
19027 deserializer.deserialize_identifier(GeneratedVisitor)
19028 }
19029 }
19030 struct GeneratedVisitor;
19031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19032 type Value = table_parallelism::CustomParallelism;
19033
19034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19035 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
19036 }
19037
19038 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
19039 where
19040 V: serde::de::MapAccess<'de>,
19041 {
19042 while map_.next_key::<GeneratedField>()?.is_some() {
19043 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19044 }
19045 Ok(table_parallelism::CustomParallelism {
19046 })
19047 }
19048 }
19049 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
19050 }
19051}
19052impl serde::Serialize for table_parallelism::FixedParallelism {
19053 #[allow(deprecated)]
19054 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19055 where
19056 S: serde::Serializer,
19057 {
19058 use serde::ser::SerializeStruct;
19059 let mut len = 0;
19060 if self.parallelism != 0 {
19061 len += 1;
19062 }
19063 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
19064 if self.parallelism != 0 {
19065 struct_ser.serialize_field("parallelism", &self.parallelism)?;
19066 }
19067 struct_ser.end()
19068 }
19069}
19070impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
19071 #[allow(deprecated)]
19072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19073 where
19074 D: serde::Deserializer<'de>,
19075 {
19076 const FIELDS: &[&str] = &[
19077 "parallelism",
19078 ];
19079
19080 #[allow(clippy::enum_variant_names)]
19081 enum GeneratedField {
19082 Parallelism,
19083 }
19084 impl<'de> serde::Deserialize<'de> for GeneratedField {
19085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19086 where
19087 D: serde::Deserializer<'de>,
19088 {
19089 struct GeneratedVisitor;
19090
19091 impl serde::de::Visitor<'_> for GeneratedVisitor {
19092 type Value = GeneratedField;
19093
19094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19095 write!(formatter, "expected one of: {:?}", &FIELDS)
19096 }
19097
19098 #[allow(unused_variables)]
19099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19100 where
19101 E: serde::de::Error,
19102 {
19103 match value {
19104 "parallelism" => Ok(GeneratedField::Parallelism),
19105 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19106 }
19107 }
19108 }
19109 deserializer.deserialize_identifier(GeneratedVisitor)
19110 }
19111 }
19112 struct GeneratedVisitor;
19113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19114 type Value = table_parallelism::FixedParallelism;
19115
19116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19117 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
19118 }
19119
19120 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
19121 where
19122 V: serde::de::MapAccess<'de>,
19123 {
19124 let mut parallelism__ = None;
19125 while let Some(k) = map_.next_key()? {
19126 match k {
19127 GeneratedField::Parallelism => {
19128 if parallelism__.is_some() {
19129 return Err(serde::de::Error::duplicate_field("parallelism"));
19130 }
19131 parallelism__ =
19132 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19133 ;
19134 }
19135 }
19136 }
19137 Ok(table_parallelism::FixedParallelism {
19138 parallelism: parallelism__.unwrap_or_default(),
19139 })
19140 }
19141 }
19142 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
19143 }
19144}
19145impl serde::Serialize for TelemetryInfoResponse {
19146 #[allow(deprecated)]
19147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19148 where
19149 S: serde::Serializer,
19150 {
19151 use serde::ser::SerializeStruct;
19152 let mut len = 0;
19153 if self.tracking_id.is_some() {
19154 len += 1;
19155 }
19156 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
19157 if let Some(v) = self.tracking_id.as_ref() {
19158 struct_ser.serialize_field("trackingId", v)?;
19159 }
19160 struct_ser.end()
19161 }
19162}
19163impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
19164 #[allow(deprecated)]
19165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19166 where
19167 D: serde::Deserializer<'de>,
19168 {
19169 const FIELDS: &[&str] = &[
19170 "tracking_id",
19171 "trackingId",
19172 ];
19173
19174 #[allow(clippy::enum_variant_names)]
19175 enum GeneratedField {
19176 TrackingId,
19177 }
19178 impl<'de> serde::Deserialize<'de> for GeneratedField {
19179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19180 where
19181 D: serde::Deserializer<'de>,
19182 {
19183 struct GeneratedVisitor;
19184
19185 impl serde::de::Visitor<'_> for GeneratedVisitor {
19186 type Value = GeneratedField;
19187
19188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19189 write!(formatter, "expected one of: {:?}", &FIELDS)
19190 }
19191
19192 #[allow(unused_variables)]
19193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19194 where
19195 E: serde::de::Error,
19196 {
19197 match value {
19198 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
19199 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19200 }
19201 }
19202 }
19203 deserializer.deserialize_identifier(GeneratedVisitor)
19204 }
19205 }
19206 struct GeneratedVisitor;
19207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19208 type Value = TelemetryInfoResponse;
19209
19210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19211 formatter.write_str("struct meta.TelemetryInfoResponse")
19212 }
19213
19214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
19215 where
19216 V: serde::de::MapAccess<'de>,
19217 {
19218 let mut tracking_id__ = None;
19219 while let Some(k) = map_.next_key()? {
19220 match k {
19221 GeneratedField::TrackingId => {
19222 if tracking_id__.is_some() {
19223 return Err(serde::de::Error::duplicate_field("trackingId"));
19224 }
19225 tracking_id__ = map_.next_value()?;
19226 }
19227 }
19228 }
19229 Ok(TelemetryInfoResponse {
19230 tracking_id: tracking_id__,
19231 })
19232 }
19233 }
19234 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
19235 }
19236}
19237impl serde::Serialize for ThrottleTarget {
19238 #[allow(deprecated)]
19239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19240 where
19241 S: serde::Serializer,
19242 {
19243 let variant = match self {
19244 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
19245 Self::Source => "SOURCE",
19246 Self::Mv => "MV",
19247 Self::Table => "TABLE",
19248 Self::Sink => "SINK",
19249 Self::Fragment => "FRAGMENT",
19250 };
19251 serializer.serialize_str(variant)
19252 }
19253}
19254impl<'de> serde::Deserialize<'de> for ThrottleTarget {
19255 #[allow(deprecated)]
19256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19257 where
19258 D: serde::Deserializer<'de>,
19259 {
19260 const FIELDS: &[&str] = &[
19261 "THROTTLE_TARGET_UNSPECIFIED",
19262 "SOURCE",
19263 "MV",
19264 "TABLE",
19265 "SINK",
19266 "FRAGMENT",
19267 ];
19268
19269 struct GeneratedVisitor;
19270
19271 impl serde::de::Visitor<'_> for GeneratedVisitor {
19272 type Value = ThrottleTarget;
19273
19274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19275 write!(formatter, "expected one of: {:?}", &FIELDS)
19276 }
19277
19278 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19279 where
19280 E: serde::de::Error,
19281 {
19282 i32::try_from(v)
19283 .ok()
19284 .and_then(|x| x.try_into().ok())
19285 .ok_or_else(|| {
19286 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19287 })
19288 }
19289
19290 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19291 where
19292 E: serde::de::Error,
19293 {
19294 i32::try_from(v)
19295 .ok()
19296 .and_then(|x| x.try_into().ok())
19297 .ok_or_else(|| {
19298 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19299 })
19300 }
19301
19302 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19303 where
19304 E: serde::de::Error,
19305 {
19306 match value {
19307 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
19308 "SOURCE" => Ok(ThrottleTarget::Source),
19309 "MV" => Ok(ThrottleTarget::Mv),
19310 "TABLE" => Ok(ThrottleTarget::Table),
19311 "SINK" => Ok(ThrottleTarget::Sink),
19312 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
19313 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19314 }
19315 }
19316 }
19317 deserializer.deserialize_any(GeneratedVisitor)
19318 }
19319}
19320impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
19321 #[allow(deprecated)]
19322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19323 where
19324 S: serde::Serializer,
19325 {
19326 use serde::ser::SerializeStruct;
19327 let mut len = 0;
19328 if self.id != 0 {
19329 len += 1;
19330 }
19331 if !self.node_label.is_empty() {
19332 len += 1;
19333 }
19334 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
19335 if self.id != 0 {
19336 struct_ser.serialize_field("id", &self.id)?;
19337 }
19338 if !self.node_label.is_empty() {
19339 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
19340 }
19341 struct_ser.end()
19342 }
19343}
19344impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
19345 #[allow(deprecated)]
19346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19347 where
19348 D: serde::Deserializer<'de>,
19349 {
19350 const FIELDS: &[&str] = &[
19351 "id",
19352 "node_label",
19353 "nodeLabel",
19354 ];
19355
19356 #[allow(clippy::enum_variant_names)]
19357 enum GeneratedField {
19358 Id,
19359 NodeLabel,
19360 }
19361 impl<'de> serde::Deserialize<'de> for GeneratedField {
19362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19363 where
19364 D: serde::Deserializer<'de>,
19365 {
19366 struct GeneratedVisitor;
19367
19368 impl serde::de::Visitor<'_> for GeneratedVisitor {
19369 type Value = GeneratedField;
19370
19371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19372 write!(formatter, "expected one of: {:?}", &FIELDS)
19373 }
19374
19375 #[allow(unused_variables)]
19376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19377 where
19378 E: serde::de::Error,
19379 {
19380 match value {
19381 "id" => Ok(GeneratedField::Id),
19382 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
19383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19384 }
19385 }
19386 }
19387 deserializer.deserialize_identifier(GeneratedVisitor)
19388 }
19389 }
19390 struct GeneratedVisitor;
19391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19392 type Value = UpdateStreamingJobNodeLabelsRequest;
19393
19394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19395 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
19396 }
19397
19398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
19399 where
19400 V: serde::de::MapAccess<'de>,
19401 {
19402 let mut id__ = None;
19403 let mut node_label__ = None;
19404 while let Some(k) = map_.next_key()? {
19405 match k {
19406 GeneratedField::Id => {
19407 if id__.is_some() {
19408 return Err(serde::de::Error::duplicate_field("id"));
19409 }
19410 id__ =
19411 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19412 ;
19413 }
19414 GeneratedField::NodeLabel => {
19415 if node_label__.is_some() {
19416 return Err(serde::de::Error::duplicate_field("nodeLabel"));
19417 }
19418 node_label__ = Some(map_.next_value()?);
19419 }
19420 }
19421 }
19422 Ok(UpdateStreamingJobNodeLabelsRequest {
19423 id: id__.unwrap_or_default(),
19424 node_label: node_label__.unwrap_or_default(),
19425 })
19426 }
19427 }
19428 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
19429 }
19430}
19431impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
19432 #[allow(deprecated)]
19433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19434 where
19435 S: serde::Serializer,
19436 {
19437 use serde::ser::SerializeStruct;
19438 let len = 0;
19439 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
19440 struct_ser.end()
19441 }
19442}
19443impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
19444 #[allow(deprecated)]
19445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19446 where
19447 D: serde::Deserializer<'de>,
19448 {
19449 const FIELDS: &[&str] = &[
19450 ];
19451
19452 #[allow(clippy::enum_variant_names)]
19453 enum GeneratedField {
19454 }
19455 impl<'de> serde::Deserialize<'de> for GeneratedField {
19456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19457 where
19458 D: serde::Deserializer<'de>,
19459 {
19460 struct GeneratedVisitor;
19461
19462 impl serde::de::Visitor<'_> for GeneratedVisitor {
19463 type Value = GeneratedField;
19464
19465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19466 write!(formatter, "expected one of: {:?}", &FIELDS)
19467 }
19468
19469 #[allow(unused_variables)]
19470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19471 where
19472 E: serde::de::Error,
19473 {
19474 Err(serde::de::Error::unknown_field(value, FIELDS))
19475 }
19476 }
19477 deserializer.deserialize_identifier(GeneratedVisitor)
19478 }
19479 }
19480 struct GeneratedVisitor;
19481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19482 type Value = UpdateStreamingJobNodeLabelsResponse;
19483
19484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19485 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
19486 }
19487
19488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
19489 where
19490 V: serde::de::MapAccess<'de>,
19491 {
19492 while map_.next_key::<GeneratedField>()?.is_some() {
19493 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19494 }
19495 Ok(UpdateStreamingJobNodeLabelsResponse {
19496 })
19497 }
19498 }
19499 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
19500 }
19501}
19502impl serde::Serialize for WorkerReschedule {
19503 #[allow(deprecated)]
19504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19505 where
19506 S: serde::Serializer,
19507 {
19508 use serde::ser::SerializeStruct;
19509 let mut len = 0;
19510 if !self.worker_actor_diff.is_empty() {
19511 len += 1;
19512 }
19513 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
19514 if !self.worker_actor_diff.is_empty() {
19515 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
19516 }
19517 struct_ser.end()
19518 }
19519}
19520impl<'de> serde::Deserialize<'de> for WorkerReschedule {
19521 #[allow(deprecated)]
19522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19523 where
19524 D: serde::Deserializer<'de>,
19525 {
19526 const FIELDS: &[&str] = &[
19527 "worker_actor_diff",
19528 "workerActorDiff",
19529 ];
19530
19531 #[allow(clippy::enum_variant_names)]
19532 enum GeneratedField {
19533 WorkerActorDiff,
19534 }
19535 impl<'de> serde::Deserialize<'de> for GeneratedField {
19536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19537 where
19538 D: serde::Deserializer<'de>,
19539 {
19540 struct GeneratedVisitor;
19541
19542 impl serde::de::Visitor<'_> for GeneratedVisitor {
19543 type Value = GeneratedField;
19544
19545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19546 write!(formatter, "expected one of: {:?}", &FIELDS)
19547 }
19548
19549 #[allow(unused_variables)]
19550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19551 where
19552 E: serde::de::Error,
19553 {
19554 match value {
19555 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
19556 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19557 }
19558 }
19559 }
19560 deserializer.deserialize_identifier(GeneratedVisitor)
19561 }
19562 }
19563 struct GeneratedVisitor;
19564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19565 type Value = WorkerReschedule;
19566
19567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19568 formatter.write_str("struct meta.WorkerReschedule")
19569 }
19570
19571 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
19572 where
19573 V: serde::de::MapAccess<'de>,
19574 {
19575 let mut worker_actor_diff__ = None;
19576 while let Some(k) = map_.next_key()? {
19577 match k {
19578 GeneratedField::WorkerActorDiff => {
19579 if worker_actor_diff__.is_some() {
19580 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
19581 }
19582 worker_actor_diff__ = Some(
19583 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
19584 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
19585 );
19586 }
19587 }
19588 }
19589 Ok(WorkerReschedule {
19590 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
19591 })
19592 }
19593 }
19594 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
19595 }
19596}