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 ClearFileCacheRequest {
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.clear_meta_cache {
2591 len += 1;
2592 }
2593 if self.clear_data_cache {
2594 len += 1;
2595 }
2596 let mut struct_ser = serializer.serialize_struct("meta.ClearFileCacheRequest", len)?;
2597 if self.clear_meta_cache {
2598 struct_ser.serialize_field("clearMetaCache", &self.clear_meta_cache)?;
2599 }
2600 if self.clear_data_cache {
2601 struct_ser.serialize_field("clearDataCache", &self.clear_data_cache)?;
2602 }
2603 struct_ser.end()
2604 }
2605}
2606impl<'de> serde::Deserialize<'de> for ClearFileCacheRequest {
2607 #[allow(deprecated)]
2608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2609 where
2610 D: serde::Deserializer<'de>,
2611 {
2612 const FIELDS: &[&str] = &[
2613 "clear_meta_cache",
2614 "clearMetaCache",
2615 "clear_data_cache",
2616 "clearDataCache",
2617 ];
2618
2619 #[allow(clippy::enum_variant_names)]
2620 enum GeneratedField {
2621 ClearMetaCache,
2622 ClearDataCache,
2623 }
2624 impl<'de> serde::Deserialize<'de> for GeneratedField {
2625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2626 where
2627 D: serde::Deserializer<'de>,
2628 {
2629 struct GeneratedVisitor;
2630
2631 impl serde::de::Visitor<'_> for GeneratedVisitor {
2632 type Value = GeneratedField;
2633
2634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2635 write!(formatter, "expected one of: {:?}", &FIELDS)
2636 }
2637
2638 #[allow(unused_variables)]
2639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2640 where
2641 E: serde::de::Error,
2642 {
2643 match value {
2644 "clearMetaCache" | "clear_meta_cache" => Ok(GeneratedField::ClearMetaCache),
2645 "clearDataCache" | "clear_data_cache" => Ok(GeneratedField::ClearDataCache),
2646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2647 }
2648 }
2649 }
2650 deserializer.deserialize_identifier(GeneratedVisitor)
2651 }
2652 }
2653 struct GeneratedVisitor;
2654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2655 type Value = ClearFileCacheRequest;
2656
2657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2658 formatter.write_str("struct meta.ClearFileCacheRequest")
2659 }
2660
2661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClearFileCacheRequest, V::Error>
2662 where
2663 V: serde::de::MapAccess<'de>,
2664 {
2665 let mut clear_meta_cache__ = None;
2666 let mut clear_data_cache__ = None;
2667 while let Some(k) = map_.next_key()? {
2668 match k {
2669 GeneratedField::ClearMetaCache => {
2670 if clear_meta_cache__.is_some() {
2671 return Err(serde::de::Error::duplicate_field("clearMetaCache"));
2672 }
2673 clear_meta_cache__ = Some(map_.next_value()?);
2674 }
2675 GeneratedField::ClearDataCache => {
2676 if clear_data_cache__.is_some() {
2677 return Err(serde::de::Error::duplicate_field("clearDataCache"));
2678 }
2679 clear_data_cache__ = Some(map_.next_value()?);
2680 }
2681 }
2682 }
2683 Ok(ClearFileCacheRequest {
2684 clear_meta_cache: clear_meta_cache__.unwrap_or_default(),
2685 clear_data_cache: clear_data_cache__.unwrap_or_default(),
2686 })
2687 }
2688 }
2689 deserializer.deserialize_struct("meta.ClearFileCacheRequest", FIELDS, GeneratedVisitor)
2690 }
2691}
2692impl serde::Serialize for ClearFileCacheResponse {
2693 #[allow(deprecated)]
2694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2695 where
2696 S: serde::Serializer,
2697 {
2698 use serde::ser::SerializeStruct;
2699 let len = 0;
2700 let struct_ser = serializer.serialize_struct("meta.ClearFileCacheResponse", len)?;
2701 struct_ser.end()
2702 }
2703}
2704impl<'de> serde::Deserialize<'de> for ClearFileCacheResponse {
2705 #[allow(deprecated)]
2706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2707 where
2708 D: serde::Deserializer<'de>,
2709 {
2710 const FIELDS: &[&str] = &[
2711 ];
2712
2713 #[allow(clippy::enum_variant_names)]
2714 enum GeneratedField {
2715 }
2716 impl<'de> serde::Deserialize<'de> for GeneratedField {
2717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2718 where
2719 D: serde::Deserializer<'de>,
2720 {
2721 struct GeneratedVisitor;
2722
2723 impl serde::de::Visitor<'_> for GeneratedVisitor {
2724 type Value = GeneratedField;
2725
2726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2727 write!(formatter, "expected one of: {:?}", &FIELDS)
2728 }
2729
2730 #[allow(unused_variables)]
2731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2732 where
2733 E: serde::de::Error,
2734 {
2735 Err(serde::de::Error::unknown_field(value, FIELDS))
2736 }
2737 }
2738 deserializer.deserialize_identifier(GeneratedVisitor)
2739 }
2740 }
2741 struct GeneratedVisitor;
2742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2743 type Value = ClearFileCacheResponse;
2744
2745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2746 formatter.write_str("struct meta.ClearFileCacheResponse")
2747 }
2748
2749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClearFileCacheResponse, V::Error>
2750 where
2751 V: serde::de::MapAccess<'de>,
2752 {
2753 while map_.next_key::<GeneratedField>()?.is_some() {
2754 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2755 }
2756 Ok(ClearFileCacheResponse {
2757 })
2758 }
2759 }
2760 deserializer.deserialize_struct("meta.ClearFileCacheResponse", FIELDS, GeneratedVisitor)
2761 }
2762}
2763impl serde::Serialize for ClusterLimit {
2764 #[allow(deprecated)]
2765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2766 where
2767 S: serde::Serializer,
2768 {
2769 use serde::ser::SerializeStruct;
2770 let mut len = 0;
2771 if self.limit.is_some() {
2772 len += 1;
2773 }
2774 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2775 if let Some(v) = self.limit.as_ref() {
2776 match v {
2777 cluster_limit::Limit::ActorCount(v) => {
2778 struct_ser.serialize_field("actorCount", v)?;
2779 }
2780 }
2781 }
2782 struct_ser.end()
2783 }
2784}
2785impl<'de> serde::Deserialize<'de> for ClusterLimit {
2786 #[allow(deprecated)]
2787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2788 where
2789 D: serde::Deserializer<'de>,
2790 {
2791 const FIELDS: &[&str] = &[
2792 "actor_count",
2793 "actorCount",
2794 ];
2795
2796 #[allow(clippy::enum_variant_names)]
2797 enum GeneratedField {
2798 ActorCount,
2799 }
2800 impl<'de> serde::Deserialize<'de> for GeneratedField {
2801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2802 where
2803 D: serde::Deserializer<'de>,
2804 {
2805 struct GeneratedVisitor;
2806
2807 impl serde::de::Visitor<'_> for GeneratedVisitor {
2808 type Value = GeneratedField;
2809
2810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2811 write!(formatter, "expected one of: {:?}", &FIELDS)
2812 }
2813
2814 #[allow(unused_variables)]
2815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2816 where
2817 E: serde::de::Error,
2818 {
2819 match value {
2820 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2822 }
2823 }
2824 }
2825 deserializer.deserialize_identifier(GeneratedVisitor)
2826 }
2827 }
2828 struct GeneratedVisitor;
2829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2830 type Value = ClusterLimit;
2831
2832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2833 formatter.write_str("struct meta.ClusterLimit")
2834 }
2835
2836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2837 where
2838 V: serde::de::MapAccess<'de>,
2839 {
2840 let mut limit__ = None;
2841 while let Some(k) = map_.next_key()? {
2842 match k {
2843 GeneratedField::ActorCount => {
2844 if limit__.is_some() {
2845 return Err(serde::de::Error::duplicate_field("actorCount"));
2846 }
2847 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2848;
2849 }
2850 }
2851 }
2852 Ok(ClusterLimit {
2853 limit: limit__,
2854 })
2855 }
2856 }
2857 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2858 }
2859}
2860impl serde::Serialize for DeleteWorkerNodeRequest {
2861 #[allow(deprecated)]
2862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2863 where
2864 S: serde::Serializer,
2865 {
2866 use serde::ser::SerializeStruct;
2867 let mut len = 0;
2868 if self.host.is_some() {
2869 len += 1;
2870 }
2871 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2872 if let Some(v) = self.host.as_ref() {
2873 struct_ser.serialize_field("host", v)?;
2874 }
2875 struct_ser.end()
2876 }
2877}
2878impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2879 #[allow(deprecated)]
2880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2881 where
2882 D: serde::Deserializer<'de>,
2883 {
2884 const FIELDS: &[&str] = &[
2885 "host",
2886 ];
2887
2888 #[allow(clippy::enum_variant_names)]
2889 enum GeneratedField {
2890 Host,
2891 }
2892 impl<'de> serde::Deserialize<'de> for GeneratedField {
2893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2894 where
2895 D: serde::Deserializer<'de>,
2896 {
2897 struct GeneratedVisitor;
2898
2899 impl serde::de::Visitor<'_> for GeneratedVisitor {
2900 type Value = GeneratedField;
2901
2902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2903 write!(formatter, "expected one of: {:?}", &FIELDS)
2904 }
2905
2906 #[allow(unused_variables)]
2907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2908 where
2909 E: serde::de::Error,
2910 {
2911 match value {
2912 "host" => Ok(GeneratedField::Host),
2913 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2914 }
2915 }
2916 }
2917 deserializer.deserialize_identifier(GeneratedVisitor)
2918 }
2919 }
2920 struct GeneratedVisitor;
2921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2922 type Value = DeleteWorkerNodeRequest;
2923
2924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2925 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2926 }
2927
2928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2929 where
2930 V: serde::de::MapAccess<'de>,
2931 {
2932 let mut host__ = None;
2933 while let Some(k) = map_.next_key()? {
2934 match k {
2935 GeneratedField::Host => {
2936 if host__.is_some() {
2937 return Err(serde::de::Error::duplicate_field("host"));
2938 }
2939 host__ = map_.next_value()?;
2940 }
2941 }
2942 }
2943 Ok(DeleteWorkerNodeRequest {
2944 host: host__,
2945 })
2946 }
2947 }
2948 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2949 }
2950}
2951impl serde::Serialize for DeleteWorkerNodeResponse {
2952 #[allow(deprecated)]
2953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2954 where
2955 S: serde::Serializer,
2956 {
2957 use serde::ser::SerializeStruct;
2958 let mut len = 0;
2959 if self.status.is_some() {
2960 len += 1;
2961 }
2962 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2963 if let Some(v) = self.status.as_ref() {
2964 struct_ser.serialize_field("status", v)?;
2965 }
2966 struct_ser.end()
2967 }
2968}
2969impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2970 #[allow(deprecated)]
2971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2972 where
2973 D: serde::Deserializer<'de>,
2974 {
2975 const FIELDS: &[&str] = &[
2976 "status",
2977 ];
2978
2979 #[allow(clippy::enum_variant_names)]
2980 enum GeneratedField {
2981 Status,
2982 }
2983 impl<'de> serde::Deserialize<'de> for GeneratedField {
2984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2985 where
2986 D: serde::Deserializer<'de>,
2987 {
2988 struct GeneratedVisitor;
2989
2990 impl serde::de::Visitor<'_> for GeneratedVisitor {
2991 type Value = GeneratedField;
2992
2993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2994 write!(formatter, "expected one of: {:?}", &FIELDS)
2995 }
2996
2997 #[allow(unused_variables)]
2998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2999 where
3000 E: serde::de::Error,
3001 {
3002 match value {
3003 "status" => Ok(GeneratedField::Status),
3004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3005 }
3006 }
3007 }
3008 deserializer.deserialize_identifier(GeneratedVisitor)
3009 }
3010 }
3011 struct GeneratedVisitor;
3012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3013 type Value = DeleteWorkerNodeResponse;
3014
3015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3016 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
3017 }
3018
3019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
3020 where
3021 V: serde::de::MapAccess<'de>,
3022 {
3023 let mut status__ = None;
3024 while let Some(k) = map_.next_key()? {
3025 match k {
3026 GeneratedField::Status => {
3027 if status__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("status"));
3029 }
3030 status__ = map_.next_value()?;
3031 }
3032 }
3033 }
3034 Ok(DeleteWorkerNodeResponse {
3035 status: status__,
3036 })
3037 }
3038 }
3039 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
3040 }
3041}
3042impl serde::Serialize for EventLog {
3043 #[allow(deprecated)]
3044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3045 where
3046 S: serde::Serializer,
3047 {
3048 use serde::ser::SerializeStruct;
3049 let mut len = 0;
3050 if self.unique_id.is_some() {
3051 len += 1;
3052 }
3053 if self.timestamp.is_some() {
3054 len += 1;
3055 }
3056 if self.event.is_some() {
3057 len += 1;
3058 }
3059 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
3060 if let Some(v) = self.unique_id.as_ref() {
3061 struct_ser.serialize_field("uniqueId", v)?;
3062 }
3063 if let Some(v) = self.timestamp.as_ref() {
3064 #[allow(clippy::needless_borrow)]
3065 #[allow(clippy::needless_borrows_for_generic_args)]
3066 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
3067 }
3068 if let Some(v) = self.event.as_ref() {
3069 match v {
3070 event_log::Event::CreateStreamJobFail(v) => {
3071 struct_ser.serialize_field("createStreamJobFail", v)?;
3072 }
3073 event_log::Event::DirtyStreamJobClear(v) => {
3074 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
3075 }
3076 event_log::Event::MetaNodeStart(v) => {
3077 struct_ser.serialize_field("metaNodeStart", v)?;
3078 }
3079 event_log::Event::BarrierComplete(v) => {
3080 struct_ser.serialize_field("barrierComplete", v)?;
3081 }
3082 event_log::Event::InjectBarrierFail(v) => {
3083 struct_ser.serialize_field("injectBarrierFail", v)?;
3084 }
3085 event_log::Event::CollectBarrierFail(v) => {
3086 struct_ser.serialize_field("collectBarrierFail", v)?;
3087 }
3088 event_log::Event::WorkerNodePanic(v) => {
3089 struct_ser.serialize_field("workerNodePanic", v)?;
3090 }
3091 event_log::Event::AutoSchemaChangeFail(v) => {
3092 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
3093 }
3094 event_log::Event::SinkFail(v) => {
3095 struct_ser.serialize_field("sinkFail", v)?;
3096 }
3097 event_log::Event::Recovery(v) => {
3098 struct_ser.serialize_field("recovery", v)?;
3099 }
3100 }
3101 }
3102 struct_ser.end()
3103 }
3104}
3105impl<'de> serde::Deserialize<'de> for EventLog {
3106 #[allow(deprecated)]
3107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3108 where
3109 D: serde::Deserializer<'de>,
3110 {
3111 const FIELDS: &[&str] = &[
3112 "unique_id",
3113 "uniqueId",
3114 "timestamp",
3115 "create_stream_job_fail",
3116 "createStreamJobFail",
3117 "dirty_stream_job_clear",
3118 "dirtyStreamJobClear",
3119 "meta_node_start",
3120 "metaNodeStart",
3121 "barrier_complete",
3122 "barrierComplete",
3123 "inject_barrier_fail",
3124 "injectBarrierFail",
3125 "collect_barrier_fail",
3126 "collectBarrierFail",
3127 "worker_node_panic",
3128 "workerNodePanic",
3129 "auto_schema_change_fail",
3130 "autoSchemaChangeFail",
3131 "sink_fail",
3132 "sinkFail",
3133 "recovery",
3134 ];
3135
3136 #[allow(clippy::enum_variant_names)]
3137 enum GeneratedField {
3138 UniqueId,
3139 Timestamp,
3140 CreateStreamJobFail,
3141 DirtyStreamJobClear,
3142 MetaNodeStart,
3143 BarrierComplete,
3144 InjectBarrierFail,
3145 CollectBarrierFail,
3146 WorkerNodePanic,
3147 AutoSchemaChangeFail,
3148 SinkFail,
3149 Recovery,
3150 }
3151 impl<'de> serde::Deserialize<'de> for GeneratedField {
3152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3153 where
3154 D: serde::Deserializer<'de>,
3155 {
3156 struct GeneratedVisitor;
3157
3158 impl serde::de::Visitor<'_> for GeneratedVisitor {
3159 type Value = GeneratedField;
3160
3161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3162 write!(formatter, "expected one of: {:?}", &FIELDS)
3163 }
3164
3165 #[allow(unused_variables)]
3166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3167 where
3168 E: serde::de::Error,
3169 {
3170 match value {
3171 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
3172 "timestamp" => Ok(GeneratedField::Timestamp),
3173 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
3174 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
3175 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
3176 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
3177 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
3178 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
3179 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
3180 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
3181 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
3182 "recovery" => Ok(GeneratedField::Recovery),
3183 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3184 }
3185 }
3186 }
3187 deserializer.deserialize_identifier(GeneratedVisitor)
3188 }
3189 }
3190 struct GeneratedVisitor;
3191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3192 type Value = EventLog;
3193
3194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3195 formatter.write_str("struct meta.EventLog")
3196 }
3197
3198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
3199 where
3200 V: serde::de::MapAccess<'de>,
3201 {
3202 let mut unique_id__ = None;
3203 let mut timestamp__ = None;
3204 let mut event__ = None;
3205 while let Some(k) = map_.next_key()? {
3206 match k {
3207 GeneratedField::UniqueId => {
3208 if unique_id__.is_some() {
3209 return Err(serde::de::Error::duplicate_field("uniqueId"));
3210 }
3211 unique_id__ = map_.next_value()?;
3212 }
3213 GeneratedField::Timestamp => {
3214 if timestamp__.is_some() {
3215 return Err(serde::de::Error::duplicate_field("timestamp"));
3216 }
3217 timestamp__ =
3218 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3219 ;
3220 }
3221 GeneratedField::CreateStreamJobFail => {
3222 if event__.is_some() {
3223 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
3224 }
3225 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
3226;
3227 }
3228 GeneratedField::DirtyStreamJobClear => {
3229 if event__.is_some() {
3230 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
3231 }
3232 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
3233;
3234 }
3235 GeneratedField::MetaNodeStart => {
3236 if event__.is_some() {
3237 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
3238 }
3239 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
3240;
3241 }
3242 GeneratedField::BarrierComplete => {
3243 if event__.is_some() {
3244 return Err(serde::de::Error::duplicate_field("barrierComplete"));
3245 }
3246 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
3247;
3248 }
3249 GeneratedField::InjectBarrierFail => {
3250 if event__.is_some() {
3251 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
3252 }
3253 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
3254;
3255 }
3256 GeneratedField::CollectBarrierFail => {
3257 if event__.is_some() {
3258 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
3259 }
3260 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
3261;
3262 }
3263 GeneratedField::WorkerNodePanic => {
3264 if event__.is_some() {
3265 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
3266 }
3267 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
3268;
3269 }
3270 GeneratedField::AutoSchemaChangeFail => {
3271 if event__.is_some() {
3272 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
3273 }
3274 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
3275;
3276 }
3277 GeneratedField::SinkFail => {
3278 if event__.is_some() {
3279 return Err(serde::de::Error::duplicate_field("sinkFail"));
3280 }
3281 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
3282;
3283 }
3284 GeneratedField::Recovery => {
3285 if event__.is_some() {
3286 return Err(serde::de::Error::duplicate_field("recovery"));
3287 }
3288 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
3289;
3290 }
3291 }
3292 }
3293 Ok(EventLog {
3294 unique_id: unique_id__,
3295 timestamp: timestamp__,
3296 event: event__,
3297 })
3298 }
3299 }
3300 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
3301 }
3302}
3303impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
3304 #[allow(deprecated)]
3305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3306 where
3307 S: serde::Serializer,
3308 {
3309 use serde::ser::SerializeStruct;
3310 let mut len = 0;
3311 if self.table_id != 0 {
3312 len += 1;
3313 }
3314 if !self.table_name.is_empty() {
3315 len += 1;
3316 }
3317 if !self.cdc_table_id.is_empty() {
3318 len += 1;
3319 }
3320 if !self.upstream_ddl.is_empty() {
3321 len += 1;
3322 }
3323 if !self.fail_info.is_empty() {
3324 len += 1;
3325 }
3326 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
3327 if self.table_id != 0 {
3328 struct_ser.serialize_field("tableId", &self.table_id)?;
3329 }
3330 if !self.table_name.is_empty() {
3331 struct_ser.serialize_field("tableName", &self.table_name)?;
3332 }
3333 if !self.cdc_table_id.is_empty() {
3334 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
3335 }
3336 if !self.upstream_ddl.is_empty() {
3337 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
3338 }
3339 if !self.fail_info.is_empty() {
3340 struct_ser.serialize_field("failInfo", &self.fail_info)?;
3341 }
3342 struct_ser.end()
3343 }
3344}
3345impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
3346 #[allow(deprecated)]
3347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3348 where
3349 D: serde::Deserializer<'de>,
3350 {
3351 const FIELDS: &[&str] = &[
3352 "table_id",
3353 "tableId",
3354 "table_name",
3355 "tableName",
3356 "cdc_table_id",
3357 "cdcTableId",
3358 "upstream_ddl",
3359 "upstreamDdl",
3360 "fail_info",
3361 "failInfo",
3362 ];
3363
3364 #[allow(clippy::enum_variant_names)]
3365 enum GeneratedField {
3366 TableId,
3367 TableName,
3368 CdcTableId,
3369 UpstreamDdl,
3370 FailInfo,
3371 }
3372 impl<'de> serde::Deserialize<'de> for GeneratedField {
3373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3374 where
3375 D: serde::Deserializer<'de>,
3376 {
3377 struct GeneratedVisitor;
3378
3379 impl serde::de::Visitor<'_> for GeneratedVisitor {
3380 type Value = GeneratedField;
3381
3382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3383 write!(formatter, "expected one of: {:?}", &FIELDS)
3384 }
3385
3386 #[allow(unused_variables)]
3387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3388 where
3389 E: serde::de::Error,
3390 {
3391 match value {
3392 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3393 "tableName" | "table_name" => Ok(GeneratedField::TableName),
3394 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
3395 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
3396 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
3397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3398 }
3399 }
3400 }
3401 deserializer.deserialize_identifier(GeneratedVisitor)
3402 }
3403 }
3404 struct GeneratedVisitor;
3405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3406 type Value = event_log::EventAutoSchemaChangeFail;
3407
3408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3409 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
3410 }
3411
3412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
3413 where
3414 V: serde::de::MapAccess<'de>,
3415 {
3416 let mut table_id__ = None;
3417 let mut table_name__ = None;
3418 let mut cdc_table_id__ = None;
3419 let mut upstream_ddl__ = None;
3420 let mut fail_info__ = None;
3421 while let Some(k) = map_.next_key()? {
3422 match k {
3423 GeneratedField::TableId => {
3424 if table_id__.is_some() {
3425 return Err(serde::de::Error::duplicate_field("tableId"));
3426 }
3427 table_id__ =
3428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3429 ;
3430 }
3431 GeneratedField::TableName => {
3432 if table_name__.is_some() {
3433 return Err(serde::de::Error::duplicate_field("tableName"));
3434 }
3435 table_name__ = Some(map_.next_value()?);
3436 }
3437 GeneratedField::CdcTableId => {
3438 if cdc_table_id__.is_some() {
3439 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3440 }
3441 cdc_table_id__ = Some(map_.next_value()?);
3442 }
3443 GeneratedField::UpstreamDdl => {
3444 if upstream_ddl__.is_some() {
3445 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3446 }
3447 upstream_ddl__ = Some(map_.next_value()?);
3448 }
3449 GeneratedField::FailInfo => {
3450 if fail_info__.is_some() {
3451 return Err(serde::de::Error::duplicate_field("failInfo"));
3452 }
3453 fail_info__ = Some(map_.next_value()?);
3454 }
3455 }
3456 }
3457 Ok(event_log::EventAutoSchemaChangeFail {
3458 table_id: table_id__.unwrap_or_default(),
3459 table_name: table_name__.unwrap_or_default(),
3460 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3461 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3462 fail_info: fail_info__.unwrap_or_default(),
3463 })
3464 }
3465 }
3466 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3467 }
3468}
3469impl serde::Serialize for event_log::EventBarrierComplete {
3470 #[allow(deprecated)]
3471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3472 where
3473 S: serde::Serializer,
3474 {
3475 use serde::ser::SerializeStruct;
3476 let mut len = 0;
3477 if self.prev_epoch != 0 {
3478 len += 1;
3479 }
3480 if self.cur_epoch != 0 {
3481 len += 1;
3482 }
3483 if self.duration_sec != 0. {
3484 len += 1;
3485 }
3486 if !self.command.is_empty() {
3487 len += 1;
3488 }
3489 if !self.barrier_kind.is_empty() {
3490 len += 1;
3491 }
3492 if self.database_id != 0 {
3493 len += 1;
3494 }
3495 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3496 if self.prev_epoch != 0 {
3497 #[allow(clippy::needless_borrow)]
3498 #[allow(clippy::needless_borrows_for_generic_args)]
3499 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3500 }
3501 if self.cur_epoch != 0 {
3502 #[allow(clippy::needless_borrow)]
3503 #[allow(clippy::needless_borrows_for_generic_args)]
3504 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3505 }
3506 if self.duration_sec != 0. {
3507 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3508 }
3509 if !self.command.is_empty() {
3510 struct_ser.serialize_field("command", &self.command)?;
3511 }
3512 if !self.barrier_kind.is_empty() {
3513 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3514 }
3515 if self.database_id != 0 {
3516 struct_ser.serialize_field("databaseId", &self.database_id)?;
3517 }
3518 struct_ser.end()
3519 }
3520}
3521impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3522 #[allow(deprecated)]
3523 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3524 where
3525 D: serde::Deserializer<'de>,
3526 {
3527 const FIELDS: &[&str] = &[
3528 "prev_epoch",
3529 "prevEpoch",
3530 "cur_epoch",
3531 "curEpoch",
3532 "duration_sec",
3533 "durationSec",
3534 "command",
3535 "barrier_kind",
3536 "barrierKind",
3537 "database_id",
3538 "databaseId",
3539 ];
3540
3541 #[allow(clippy::enum_variant_names)]
3542 enum GeneratedField {
3543 PrevEpoch,
3544 CurEpoch,
3545 DurationSec,
3546 Command,
3547 BarrierKind,
3548 DatabaseId,
3549 }
3550 impl<'de> serde::Deserialize<'de> for GeneratedField {
3551 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3552 where
3553 D: serde::Deserializer<'de>,
3554 {
3555 struct GeneratedVisitor;
3556
3557 impl serde::de::Visitor<'_> for GeneratedVisitor {
3558 type Value = GeneratedField;
3559
3560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3561 write!(formatter, "expected one of: {:?}", &FIELDS)
3562 }
3563
3564 #[allow(unused_variables)]
3565 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3566 where
3567 E: serde::de::Error,
3568 {
3569 match value {
3570 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3571 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3572 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3573 "command" => Ok(GeneratedField::Command),
3574 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3575 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3576 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3577 }
3578 }
3579 }
3580 deserializer.deserialize_identifier(GeneratedVisitor)
3581 }
3582 }
3583 struct GeneratedVisitor;
3584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3585 type Value = event_log::EventBarrierComplete;
3586
3587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3588 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3589 }
3590
3591 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3592 where
3593 V: serde::de::MapAccess<'de>,
3594 {
3595 let mut prev_epoch__ = None;
3596 let mut cur_epoch__ = None;
3597 let mut duration_sec__ = None;
3598 let mut command__ = None;
3599 let mut barrier_kind__ = None;
3600 let mut database_id__ = None;
3601 while let Some(k) = map_.next_key()? {
3602 match k {
3603 GeneratedField::PrevEpoch => {
3604 if prev_epoch__.is_some() {
3605 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3606 }
3607 prev_epoch__ =
3608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3609 ;
3610 }
3611 GeneratedField::CurEpoch => {
3612 if cur_epoch__.is_some() {
3613 return Err(serde::de::Error::duplicate_field("curEpoch"));
3614 }
3615 cur_epoch__ =
3616 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3617 ;
3618 }
3619 GeneratedField::DurationSec => {
3620 if duration_sec__.is_some() {
3621 return Err(serde::de::Error::duplicate_field("durationSec"));
3622 }
3623 duration_sec__ =
3624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3625 ;
3626 }
3627 GeneratedField::Command => {
3628 if command__.is_some() {
3629 return Err(serde::de::Error::duplicate_field("command"));
3630 }
3631 command__ = Some(map_.next_value()?);
3632 }
3633 GeneratedField::BarrierKind => {
3634 if barrier_kind__.is_some() {
3635 return Err(serde::de::Error::duplicate_field("barrierKind"));
3636 }
3637 barrier_kind__ = Some(map_.next_value()?);
3638 }
3639 GeneratedField::DatabaseId => {
3640 if database_id__.is_some() {
3641 return Err(serde::de::Error::duplicate_field("databaseId"));
3642 }
3643 database_id__ =
3644 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3645 ;
3646 }
3647 }
3648 }
3649 Ok(event_log::EventBarrierComplete {
3650 prev_epoch: prev_epoch__.unwrap_or_default(),
3651 cur_epoch: cur_epoch__.unwrap_or_default(),
3652 duration_sec: duration_sec__.unwrap_or_default(),
3653 command: command__.unwrap_or_default(),
3654 barrier_kind: barrier_kind__.unwrap_or_default(),
3655 database_id: database_id__.unwrap_or_default(),
3656 })
3657 }
3658 }
3659 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3660 }
3661}
3662impl serde::Serialize for event_log::EventCollectBarrierFail {
3663 #[allow(deprecated)]
3664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3665 where
3666 S: serde::Serializer,
3667 {
3668 use serde::ser::SerializeStruct;
3669 let mut len = 0;
3670 if !self.error.is_empty() {
3671 len += 1;
3672 }
3673 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3674 if !self.error.is_empty() {
3675 struct_ser.serialize_field("error", &self.error)?;
3676 }
3677 struct_ser.end()
3678 }
3679}
3680impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3681 #[allow(deprecated)]
3682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3683 where
3684 D: serde::Deserializer<'de>,
3685 {
3686 const FIELDS: &[&str] = &[
3687 "error",
3688 ];
3689
3690 #[allow(clippy::enum_variant_names)]
3691 enum GeneratedField {
3692 Error,
3693 }
3694 impl<'de> serde::Deserialize<'de> for GeneratedField {
3695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3696 where
3697 D: serde::Deserializer<'de>,
3698 {
3699 struct GeneratedVisitor;
3700
3701 impl serde::de::Visitor<'_> for GeneratedVisitor {
3702 type Value = GeneratedField;
3703
3704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3705 write!(formatter, "expected one of: {:?}", &FIELDS)
3706 }
3707
3708 #[allow(unused_variables)]
3709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3710 where
3711 E: serde::de::Error,
3712 {
3713 match value {
3714 "error" => Ok(GeneratedField::Error),
3715 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3716 }
3717 }
3718 }
3719 deserializer.deserialize_identifier(GeneratedVisitor)
3720 }
3721 }
3722 struct GeneratedVisitor;
3723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3724 type Value = event_log::EventCollectBarrierFail;
3725
3726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3727 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3728 }
3729
3730 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3731 where
3732 V: serde::de::MapAccess<'de>,
3733 {
3734 let mut error__ = None;
3735 while let Some(k) = map_.next_key()? {
3736 match k {
3737 GeneratedField::Error => {
3738 if error__.is_some() {
3739 return Err(serde::de::Error::duplicate_field("error"));
3740 }
3741 error__ = Some(map_.next_value()?);
3742 }
3743 }
3744 }
3745 Ok(event_log::EventCollectBarrierFail {
3746 error: error__.unwrap_or_default(),
3747 })
3748 }
3749 }
3750 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3751 }
3752}
3753impl serde::Serialize for event_log::EventCreateStreamJobFail {
3754 #[allow(deprecated)]
3755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3756 where
3757 S: serde::Serializer,
3758 {
3759 use serde::ser::SerializeStruct;
3760 let mut len = 0;
3761 if self.id != 0 {
3762 len += 1;
3763 }
3764 if !self.name.is_empty() {
3765 len += 1;
3766 }
3767 if !self.definition.is_empty() {
3768 len += 1;
3769 }
3770 if !self.error.is_empty() {
3771 len += 1;
3772 }
3773 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3774 if self.id != 0 {
3775 struct_ser.serialize_field("id", &self.id)?;
3776 }
3777 if !self.name.is_empty() {
3778 struct_ser.serialize_field("name", &self.name)?;
3779 }
3780 if !self.definition.is_empty() {
3781 struct_ser.serialize_field("definition", &self.definition)?;
3782 }
3783 if !self.error.is_empty() {
3784 struct_ser.serialize_field("error", &self.error)?;
3785 }
3786 struct_ser.end()
3787 }
3788}
3789impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3790 #[allow(deprecated)]
3791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3792 where
3793 D: serde::Deserializer<'de>,
3794 {
3795 const FIELDS: &[&str] = &[
3796 "id",
3797 "name",
3798 "definition",
3799 "error",
3800 ];
3801
3802 #[allow(clippy::enum_variant_names)]
3803 enum GeneratedField {
3804 Id,
3805 Name,
3806 Definition,
3807 Error,
3808 }
3809 impl<'de> serde::Deserialize<'de> for GeneratedField {
3810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3811 where
3812 D: serde::Deserializer<'de>,
3813 {
3814 struct GeneratedVisitor;
3815
3816 impl serde::de::Visitor<'_> for GeneratedVisitor {
3817 type Value = GeneratedField;
3818
3819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3820 write!(formatter, "expected one of: {:?}", &FIELDS)
3821 }
3822
3823 #[allow(unused_variables)]
3824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3825 where
3826 E: serde::de::Error,
3827 {
3828 match value {
3829 "id" => Ok(GeneratedField::Id),
3830 "name" => Ok(GeneratedField::Name),
3831 "definition" => Ok(GeneratedField::Definition),
3832 "error" => Ok(GeneratedField::Error),
3833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3834 }
3835 }
3836 }
3837 deserializer.deserialize_identifier(GeneratedVisitor)
3838 }
3839 }
3840 struct GeneratedVisitor;
3841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3842 type Value = event_log::EventCreateStreamJobFail;
3843
3844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3845 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3846 }
3847
3848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3849 where
3850 V: serde::de::MapAccess<'de>,
3851 {
3852 let mut id__ = None;
3853 let mut name__ = None;
3854 let mut definition__ = None;
3855 let mut error__ = None;
3856 while let Some(k) = map_.next_key()? {
3857 match k {
3858 GeneratedField::Id => {
3859 if id__.is_some() {
3860 return Err(serde::de::Error::duplicate_field("id"));
3861 }
3862 id__ =
3863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3864 ;
3865 }
3866 GeneratedField::Name => {
3867 if name__.is_some() {
3868 return Err(serde::de::Error::duplicate_field("name"));
3869 }
3870 name__ = Some(map_.next_value()?);
3871 }
3872 GeneratedField::Definition => {
3873 if definition__.is_some() {
3874 return Err(serde::de::Error::duplicate_field("definition"));
3875 }
3876 definition__ = Some(map_.next_value()?);
3877 }
3878 GeneratedField::Error => {
3879 if error__.is_some() {
3880 return Err(serde::de::Error::duplicate_field("error"));
3881 }
3882 error__ = Some(map_.next_value()?);
3883 }
3884 }
3885 }
3886 Ok(event_log::EventCreateStreamJobFail {
3887 id: id__.unwrap_or_default(),
3888 name: name__.unwrap_or_default(),
3889 definition: definition__.unwrap_or_default(),
3890 error: error__.unwrap_or_default(),
3891 })
3892 }
3893 }
3894 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3895 }
3896}
3897impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3898 #[allow(deprecated)]
3899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3900 where
3901 S: serde::Serializer,
3902 {
3903 use serde::ser::SerializeStruct;
3904 let mut len = 0;
3905 if self.id != 0 {
3906 len += 1;
3907 }
3908 if !self.name.is_empty() {
3909 len += 1;
3910 }
3911 if !self.definition.is_empty() {
3912 len += 1;
3913 }
3914 if !self.error.is_empty() {
3915 len += 1;
3916 }
3917 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3918 if self.id != 0 {
3919 struct_ser.serialize_field("id", &self.id)?;
3920 }
3921 if !self.name.is_empty() {
3922 struct_ser.serialize_field("name", &self.name)?;
3923 }
3924 if !self.definition.is_empty() {
3925 struct_ser.serialize_field("definition", &self.definition)?;
3926 }
3927 if !self.error.is_empty() {
3928 struct_ser.serialize_field("error", &self.error)?;
3929 }
3930 struct_ser.end()
3931 }
3932}
3933impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3934 #[allow(deprecated)]
3935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3936 where
3937 D: serde::Deserializer<'de>,
3938 {
3939 const FIELDS: &[&str] = &[
3940 "id",
3941 "name",
3942 "definition",
3943 "error",
3944 ];
3945
3946 #[allow(clippy::enum_variant_names)]
3947 enum GeneratedField {
3948 Id,
3949 Name,
3950 Definition,
3951 Error,
3952 }
3953 impl<'de> serde::Deserialize<'de> for GeneratedField {
3954 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3955 where
3956 D: serde::Deserializer<'de>,
3957 {
3958 struct GeneratedVisitor;
3959
3960 impl serde::de::Visitor<'_> for GeneratedVisitor {
3961 type Value = GeneratedField;
3962
3963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3964 write!(formatter, "expected one of: {:?}", &FIELDS)
3965 }
3966
3967 #[allow(unused_variables)]
3968 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3969 where
3970 E: serde::de::Error,
3971 {
3972 match value {
3973 "id" => Ok(GeneratedField::Id),
3974 "name" => Ok(GeneratedField::Name),
3975 "definition" => Ok(GeneratedField::Definition),
3976 "error" => Ok(GeneratedField::Error),
3977 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3978 }
3979 }
3980 }
3981 deserializer.deserialize_identifier(GeneratedVisitor)
3982 }
3983 }
3984 struct GeneratedVisitor;
3985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3986 type Value = event_log::EventDirtyStreamJobClear;
3987
3988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3989 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3990 }
3991
3992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3993 where
3994 V: serde::de::MapAccess<'de>,
3995 {
3996 let mut id__ = None;
3997 let mut name__ = None;
3998 let mut definition__ = None;
3999 let mut error__ = None;
4000 while let Some(k) = map_.next_key()? {
4001 match k {
4002 GeneratedField::Id => {
4003 if id__.is_some() {
4004 return Err(serde::de::Error::duplicate_field("id"));
4005 }
4006 id__ =
4007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4008 ;
4009 }
4010 GeneratedField::Name => {
4011 if name__.is_some() {
4012 return Err(serde::de::Error::duplicate_field("name"));
4013 }
4014 name__ = Some(map_.next_value()?);
4015 }
4016 GeneratedField::Definition => {
4017 if definition__.is_some() {
4018 return Err(serde::de::Error::duplicate_field("definition"));
4019 }
4020 definition__ = Some(map_.next_value()?);
4021 }
4022 GeneratedField::Error => {
4023 if error__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("error"));
4025 }
4026 error__ = Some(map_.next_value()?);
4027 }
4028 }
4029 }
4030 Ok(event_log::EventDirtyStreamJobClear {
4031 id: id__.unwrap_or_default(),
4032 name: name__.unwrap_or_default(),
4033 definition: definition__.unwrap_or_default(),
4034 error: error__.unwrap_or_default(),
4035 })
4036 }
4037 }
4038 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
4039 }
4040}
4041impl serde::Serialize for event_log::EventInjectBarrierFail {
4042 #[allow(deprecated)]
4043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4044 where
4045 S: serde::Serializer,
4046 {
4047 use serde::ser::SerializeStruct;
4048 let mut len = 0;
4049 if self.prev_epoch != 0 {
4050 len += 1;
4051 }
4052 if self.cur_epoch != 0 {
4053 len += 1;
4054 }
4055 if !self.error.is_empty() {
4056 len += 1;
4057 }
4058 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
4059 if self.prev_epoch != 0 {
4060 #[allow(clippy::needless_borrow)]
4061 #[allow(clippy::needless_borrows_for_generic_args)]
4062 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
4063 }
4064 if self.cur_epoch != 0 {
4065 #[allow(clippy::needless_borrow)]
4066 #[allow(clippy::needless_borrows_for_generic_args)]
4067 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
4068 }
4069 if !self.error.is_empty() {
4070 struct_ser.serialize_field("error", &self.error)?;
4071 }
4072 struct_ser.end()
4073 }
4074}
4075impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
4076 #[allow(deprecated)]
4077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4078 where
4079 D: serde::Deserializer<'de>,
4080 {
4081 const FIELDS: &[&str] = &[
4082 "prev_epoch",
4083 "prevEpoch",
4084 "cur_epoch",
4085 "curEpoch",
4086 "error",
4087 ];
4088
4089 #[allow(clippy::enum_variant_names)]
4090 enum GeneratedField {
4091 PrevEpoch,
4092 CurEpoch,
4093 Error,
4094 }
4095 impl<'de> serde::Deserialize<'de> for GeneratedField {
4096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4097 where
4098 D: serde::Deserializer<'de>,
4099 {
4100 struct GeneratedVisitor;
4101
4102 impl serde::de::Visitor<'_> for GeneratedVisitor {
4103 type Value = GeneratedField;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 write!(formatter, "expected one of: {:?}", &FIELDS)
4107 }
4108
4109 #[allow(unused_variables)]
4110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4111 where
4112 E: serde::de::Error,
4113 {
4114 match value {
4115 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
4116 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
4117 "error" => Ok(GeneratedField::Error),
4118 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4119 }
4120 }
4121 }
4122 deserializer.deserialize_identifier(GeneratedVisitor)
4123 }
4124 }
4125 struct GeneratedVisitor;
4126 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4127 type Value = event_log::EventInjectBarrierFail;
4128
4129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4130 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
4131 }
4132
4133 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
4134 where
4135 V: serde::de::MapAccess<'de>,
4136 {
4137 let mut prev_epoch__ = None;
4138 let mut cur_epoch__ = None;
4139 let mut error__ = None;
4140 while let Some(k) = map_.next_key()? {
4141 match k {
4142 GeneratedField::PrevEpoch => {
4143 if prev_epoch__.is_some() {
4144 return Err(serde::de::Error::duplicate_field("prevEpoch"));
4145 }
4146 prev_epoch__ =
4147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4148 ;
4149 }
4150 GeneratedField::CurEpoch => {
4151 if cur_epoch__.is_some() {
4152 return Err(serde::de::Error::duplicate_field("curEpoch"));
4153 }
4154 cur_epoch__ =
4155 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4156 ;
4157 }
4158 GeneratedField::Error => {
4159 if error__.is_some() {
4160 return Err(serde::de::Error::duplicate_field("error"));
4161 }
4162 error__ = Some(map_.next_value()?);
4163 }
4164 }
4165 }
4166 Ok(event_log::EventInjectBarrierFail {
4167 prev_epoch: prev_epoch__.unwrap_or_default(),
4168 cur_epoch: cur_epoch__.unwrap_or_default(),
4169 error: error__.unwrap_or_default(),
4170 })
4171 }
4172 }
4173 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
4174 }
4175}
4176impl serde::Serialize for event_log::EventMetaNodeStart {
4177 #[allow(deprecated)]
4178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4179 where
4180 S: serde::Serializer,
4181 {
4182 use serde::ser::SerializeStruct;
4183 let mut len = 0;
4184 if !self.advertise_addr.is_empty() {
4185 len += 1;
4186 }
4187 if !self.listen_addr.is_empty() {
4188 len += 1;
4189 }
4190 if !self.opts.is_empty() {
4191 len += 1;
4192 }
4193 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
4194 if !self.advertise_addr.is_empty() {
4195 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
4196 }
4197 if !self.listen_addr.is_empty() {
4198 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
4199 }
4200 if !self.opts.is_empty() {
4201 struct_ser.serialize_field("opts", &self.opts)?;
4202 }
4203 struct_ser.end()
4204 }
4205}
4206impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
4207 #[allow(deprecated)]
4208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4209 where
4210 D: serde::Deserializer<'de>,
4211 {
4212 const FIELDS: &[&str] = &[
4213 "advertise_addr",
4214 "advertiseAddr",
4215 "listen_addr",
4216 "listenAddr",
4217 "opts",
4218 ];
4219
4220 #[allow(clippy::enum_variant_names)]
4221 enum GeneratedField {
4222 AdvertiseAddr,
4223 ListenAddr,
4224 Opts,
4225 }
4226 impl<'de> serde::Deserialize<'de> for GeneratedField {
4227 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4228 where
4229 D: serde::Deserializer<'de>,
4230 {
4231 struct GeneratedVisitor;
4232
4233 impl serde::de::Visitor<'_> for GeneratedVisitor {
4234 type Value = GeneratedField;
4235
4236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4237 write!(formatter, "expected one of: {:?}", &FIELDS)
4238 }
4239
4240 #[allow(unused_variables)]
4241 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4242 where
4243 E: serde::de::Error,
4244 {
4245 match value {
4246 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
4247 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
4248 "opts" => Ok(GeneratedField::Opts),
4249 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4250 }
4251 }
4252 }
4253 deserializer.deserialize_identifier(GeneratedVisitor)
4254 }
4255 }
4256 struct GeneratedVisitor;
4257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4258 type Value = event_log::EventMetaNodeStart;
4259
4260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4261 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
4262 }
4263
4264 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
4265 where
4266 V: serde::de::MapAccess<'de>,
4267 {
4268 let mut advertise_addr__ = None;
4269 let mut listen_addr__ = None;
4270 let mut opts__ = None;
4271 while let Some(k) = map_.next_key()? {
4272 match k {
4273 GeneratedField::AdvertiseAddr => {
4274 if advertise_addr__.is_some() {
4275 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
4276 }
4277 advertise_addr__ = Some(map_.next_value()?);
4278 }
4279 GeneratedField::ListenAddr => {
4280 if listen_addr__.is_some() {
4281 return Err(serde::de::Error::duplicate_field("listenAddr"));
4282 }
4283 listen_addr__ = Some(map_.next_value()?);
4284 }
4285 GeneratedField::Opts => {
4286 if opts__.is_some() {
4287 return Err(serde::de::Error::duplicate_field("opts"));
4288 }
4289 opts__ = Some(map_.next_value()?);
4290 }
4291 }
4292 }
4293 Ok(event_log::EventMetaNodeStart {
4294 advertise_addr: advertise_addr__.unwrap_or_default(),
4295 listen_addr: listen_addr__.unwrap_or_default(),
4296 opts: opts__.unwrap_or_default(),
4297 })
4298 }
4299 }
4300 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
4301 }
4302}
4303impl serde::Serialize for event_log::EventRecovery {
4304 #[allow(deprecated)]
4305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4306 where
4307 S: serde::Serializer,
4308 {
4309 use serde::ser::SerializeStruct;
4310 let mut len = 0;
4311 if self.recovery_event.is_some() {
4312 len += 1;
4313 }
4314 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
4315 if let Some(v) = self.recovery_event.as_ref() {
4316 match v {
4317 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
4318 struct_ser.serialize_field("globalStart", v)?;
4319 }
4320 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
4321 struct_ser.serialize_field("globalSuccess", v)?;
4322 }
4323 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
4324 struct_ser.serialize_field("globalFailure", v)?;
4325 }
4326 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
4327 struct_ser.serialize_field("databaseStart", v)?;
4328 }
4329 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
4330 struct_ser.serialize_field("databaseFailure", v)?;
4331 }
4332 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
4333 struct_ser.serialize_field("databaseSuccess", v)?;
4334 }
4335 }
4336 }
4337 struct_ser.end()
4338 }
4339}
4340impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
4341 #[allow(deprecated)]
4342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4343 where
4344 D: serde::Deserializer<'de>,
4345 {
4346 const FIELDS: &[&str] = &[
4347 "global_start",
4348 "globalStart",
4349 "global_success",
4350 "globalSuccess",
4351 "global_failure",
4352 "globalFailure",
4353 "database_start",
4354 "databaseStart",
4355 "database_failure",
4356 "databaseFailure",
4357 "database_success",
4358 "databaseSuccess",
4359 ];
4360
4361 #[allow(clippy::enum_variant_names)]
4362 enum GeneratedField {
4363 GlobalStart,
4364 GlobalSuccess,
4365 GlobalFailure,
4366 DatabaseStart,
4367 DatabaseFailure,
4368 DatabaseSuccess,
4369 }
4370 impl<'de> serde::Deserialize<'de> for GeneratedField {
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 struct GeneratedVisitor;
4376
4377 impl serde::de::Visitor<'_> for GeneratedVisitor {
4378 type Value = GeneratedField;
4379
4380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4381 write!(formatter, "expected one of: {:?}", &FIELDS)
4382 }
4383
4384 #[allow(unused_variables)]
4385 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4386 where
4387 E: serde::de::Error,
4388 {
4389 match value {
4390 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
4391 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
4392 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
4393 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
4394 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
4395 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
4396 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4397 }
4398 }
4399 }
4400 deserializer.deserialize_identifier(GeneratedVisitor)
4401 }
4402 }
4403 struct GeneratedVisitor;
4404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4405 type Value = event_log::EventRecovery;
4406
4407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4408 formatter.write_str("struct meta.EventLog.EventRecovery")
4409 }
4410
4411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
4412 where
4413 V: serde::de::MapAccess<'de>,
4414 {
4415 let mut recovery_event__ = None;
4416 while let Some(k) = map_.next_key()? {
4417 match k {
4418 GeneratedField::GlobalStart => {
4419 if recovery_event__.is_some() {
4420 return Err(serde::de::Error::duplicate_field("globalStart"));
4421 }
4422 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
4423;
4424 }
4425 GeneratedField::GlobalSuccess => {
4426 if recovery_event__.is_some() {
4427 return Err(serde::de::Error::duplicate_field("globalSuccess"));
4428 }
4429 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
4430;
4431 }
4432 GeneratedField::GlobalFailure => {
4433 if recovery_event__.is_some() {
4434 return Err(serde::de::Error::duplicate_field("globalFailure"));
4435 }
4436 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
4437;
4438 }
4439 GeneratedField::DatabaseStart => {
4440 if recovery_event__.is_some() {
4441 return Err(serde::de::Error::duplicate_field("databaseStart"));
4442 }
4443 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
4444;
4445 }
4446 GeneratedField::DatabaseFailure => {
4447 if recovery_event__.is_some() {
4448 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4449 }
4450 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4451;
4452 }
4453 GeneratedField::DatabaseSuccess => {
4454 if recovery_event__.is_some() {
4455 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4456 }
4457 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4458;
4459 }
4460 }
4461 }
4462 Ok(event_log::EventRecovery {
4463 recovery_event: recovery_event__,
4464 })
4465 }
4466 }
4467 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4468 }
4469}
4470impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4471 #[allow(deprecated)]
4472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4473 where
4474 S: serde::Serializer,
4475 {
4476 use serde::ser::SerializeStruct;
4477 let mut len = 0;
4478 if self.database_id != 0 {
4479 len += 1;
4480 }
4481 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4482 if self.database_id != 0 {
4483 struct_ser.serialize_field("databaseId", &self.database_id)?;
4484 }
4485 struct_ser.end()
4486 }
4487}
4488impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4489 #[allow(deprecated)]
4490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4491 where
4492 D: serde::Deserializer<'de>,
4493 {
4494 const FIELDS: &[&str] = &[
4495 "database_id",
4496 "databaseId",
4497 ];
4498
4499 #[allow(clippy::enum_variant_names)]
4500 enum GeneratedField {
4501 DatabaseId,
4502 }
4503 impl<'de> serde::Deserialize<'de> for GeneratedField {
4504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4505 where
4506 D: serde::Deserializer<'de>,
4507 {
4508 struct GeneratedVisitor;
4509
4510 impl serde::de::Visitor<'_> for GeneratedVisitor {
4511 type Value = GeneratedField;
4512
4513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4514 write!(formatter, "expected one of: {:?}", &FIELDS)
4515 }
4516
4517 #[allow(unused_variables)]
4518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4519 where
4520 E: serde::de::Error,
4521 {
4522 match value {
4523 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4525 }
4526 }
4527 }
4528 deserializer.deserialize_identifier(GeneratedVisitor)
4529 }
4530 }
4531 struct GeneratedVisitor;
4532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4533 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4534
4535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4536 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4537 }
4538
4539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4540 where
4541 V: serde::de::MapAccess<'de>,
4542 {
4543 let mut database_id__ = None;
4544 while let Some(k) = map_.next_key()? {
4545 match k {
4546 GeneratedField::DatabaseId => {
4547 if database_id__.is_some() {
4548 return Err(serde::de::Error::duplicate_field("databaseId"));
4549 }
4550 database_id__ =
4551 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4552 ;
4553 }
4554 }
4555 }
4556 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4557 database_id: database_id__.unwrap_or_default(),
4558 })
4559 }
4560 }
4561 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4562 }
4563}
4564impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4565 #[allow(deprecated)]
4566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4567 where
4568 S: serde::Serializer,
4569 {
4570 use serde::ser::SerializeStruct;
4571 let mut len = 0;
4572 if self.database_id != 0 {
4573 len += 1;
4574 }
4575 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4576 if self.database_id != 0 {
4577 struct_ser.serialize_field("databaseId", &self.database_id)?;
4578 }
4579 struct_ser.end()
4580 }
4581}
4582impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4583 #[allow(deprecated)]
4584 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4585 where
4586 D: serde::Deserializer<'de>,
4587 {
4588 const FIELDS: &[&str] = &[
4589 "database_id",
4590 "databaseId",
4591 ];
4592
4593 #[allow(clippy::enum_variant_names)]
4594 enum GeneratedField {
4595 DatabaseId,
4596 }
4597 impl<'de> serde::Deserialize<'de> for GeneratedField {
4598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4599 where
4600 D: serde::Deserializer<'de>,
4601 {
4602 struct GeneratedVisitor;
4603
4604 impl serde::de::Visitor<'_> for GeneratedVisitor {
4605 type Value = GeneratedField;
4606
4607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4608 write!(formatter, "expected one of: {:?}", &FIELDS)
4609 }
4610
4611 #[allow(unused_variables)]
4612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4613 where
4614 E: serde::de::Error,
4615 {
4616 match value {
4617 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4619 }
4620 }
4621 }
4622 deserializer.deserialize_identifier(GeneratedVisitor)
4623 }
4624 }
4625 struct GeneratedVisitor;
4626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4627 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4628
4629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4630 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4631 }
4632
4633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4634 where
4635 V: serde::de::MapAccess<'de>,
4636 {
4637 let mut database_id__ = None;
4638 while let Some(k) = map_.next_key()? {
4639 match k {
4640 GeneratedField::DatabaseId => {
4641 if database_id__.is_some() {
4642 return Err(serde::de::Error::duplicate_field("databaseId"));
4643 }
4644 database_id__ =
4645 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4646 ;
4647 }
4648 }
4649 }
4650 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4651 database_id: database_id__.unwrap_or_default(),
4652 })
4653 }
4654 }
4655 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4656 }
4657}
4658impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4659 #[allow(deprecated)]
4660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4661 where
4662 S: serde::Serializer,
4663 {
4664 use serde::ser::SerializeStruct;
4665 let mut len = 0;
4666 if self.database_id != 0 {
4667 len += 1;
4668 }
4669 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4670 if self.database_id != 0 {
4671 struct_ser.serialize_field("databaseId", &self.database_id)?;
4672 }
4673 struct_ser.end()
4674 }
4675}
4676impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4677 #[allow(deprecated)]
4678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4679 where
4680 D: serde::Deserializer<'de>,
4681 {
4682 const FIELDS: &[&str] = &[
4683 "database_id",
4684 "databaseId",
4685 ];
4686
4687 #[allow(clippy::enum_variant_names)]
4688 enum GeneratedField {
4689 DatabaseId,
4690 }
4691 impl<'de> serde::Deserialize<'de> for GeneratedField {
4692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4693 where
4694 D: serde::Deserializer<'de>,
4695 {
4696 struct GeneratedVisitor;
4697
4698 impl serde::de::Visitor<'_> for GeneratedVisitor {
4699 type Value = GeneratedField;
4700
4701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4702 write!(formatter, "expected one of: {:?}", &FIELDS)
4703 }
4704
4705 #[allow(unused_variables)]
4706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4707 where
4708 E: serde::de::Error,
4709 {
4710 match value {
4711 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4713 }
4714 }
4715 }
4716 deserializer.deserialize_identifier(GeneratedVisitor)
4717 }
4718 }
4719 struct GeneratedVisitor;
4720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4721 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4722
4723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4724 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4725 }
4726
4727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4728 where
4729 V: serde::de::MapAccess<'de>,
4730 {
4731 let mut database_id__ = None;
4732 while let Some(k) = map_.next_key()? {
4733 match k {
4734 GeneratedField::DatabaseId => {
4735 if database_id__.is_some() {
4736 return Err(serde::de::Error::duplicate_field("databaseId"));
4737 }
4738 database_id__ =
4739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4740 ;
4741 }
4742 }
4743 }
4744 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4745 database_id: database_id__.unwrap_or_default(),
4746 })
4747 }
4748 }
4749 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4750 }
4751}
4752impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4753 #[allow(deprecated)]
4754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4755 where
4756 S: serde::Serializer,
4757 {
4758 use serde::ser::SerializeStruct;
4759 let mut len = 0;
4760 if !self.reason.is_empty() {
4761 len += 1;
4762 }
4763 if !self.error.is_empty() {
4764 len += 1;
4765 }
4766 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4767 if !self.reason.is_empty() {
4768 struct_ser.serialize_field("reason", &self.reason)?;
4769 }
4770 if !self.error.is_empty() {
4771 struct_ser.serialize_field("error", &self.error)?;
4772 }
4773 struct_ser.end()
4774 }
4775}
4776impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4777 #[allow(deprecated)]
4778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4779 where
4780 D: serde::Deserializer<'de>,
4781 {
4782 const FIELDS: &[&str] = &[
4783 "reason",
4784 "error",
4785 ];
4786
4787 #[allow(clippy::enum_variant_names)]
4788 enum GeneratedField {
4789 Reason,
4790 Error,
4791 }
4792 impl<'de> serde::Deserialize<'de> for GeneratedField {
4793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4794 where
4795 D: serde::Deserializer<'de>,
4796 {
4797 struct GeneratedVisitor;
4798
4799 impl serde::de::Visitor<'_> for GeneratedVisitor {
4800 type Value = GeneratedField;
4801
4802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4803 write!(formatter, "expected one of: {:?}", &FIELDS)
4804 }
4805
4806 #[allow(unused_variables)]
4807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4808 where
4809 E: serde::de::Error,
4810 {
4811 match value {
4812 "reason" => Ok(GeneratedField::Reason),
4813 "error" => Ok(GeneratedField::Error),
4814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4815 }
4816 }
4817 }
4818 deserializer.deserialize_identifier(GeneratedVisitor)
4819 }
4820 }
4821 struct GeneratedVisitor;
4822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4823 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4824
4825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4826 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4827 }
4828
4829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4830 where
4831 V: serde::de::MapAccess<'de>,
4832 {
4833 let mut reason__ = None;
4834 let mut error__ = None;
4835 while let Some(k) = map_.next_key()? {
4836 match k {
4837 GeneratedField::Reason => {
4838 if reason__.is_some() {
4839 return Err(serde::de::Error::duplicate_field("reason"));
4840 }
4841 reason__ = Some(map_.next_value()?);
4842 }
4843 GeneratedField::Error => {
4844 if error__.is_some() {
4845 return Err(serde::de::Error::duplicate_field("error"));
4846 }
4847 error__ = Some(map_.next_value()?);
4848 }
4849 }
4850 }
4851 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4852 reason: reason__.unwrap_or_default(),
4853 error: error__.unwrap_or_default(),
4854 })
4855 }
4856 }
4857 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4858 }
4859}
4860impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4861 #[allow(deprecated)]
4862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4863 where
4864 S: serde::Serializer,
4865 {
4866 use serde::ser::SerializeStruct;
4867 let mut len = 0;
4868 if !self.reason.is_empty() {
4869 len += 1;
4870 }
4871 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4872 if !self.reason.is_empty() {
4873 struct_ser.serialize_field("reason", &self.reason)?;
4874 }
4875 struct_ser.end()
4876 }
4877}
4878impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4879 #[allow(deprecated)]
4880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4881 where
4882 D: serde::Deserializer<'de>,
4883 {
4884 const FIELDS: &[&str] = &[
4885 "reason",
4886 ];
4887
4888 #[allow(clippy::enum_variant_names)]
4889 enum GeneratedField {
4890 Reason,
4891 }
4892 impl<'de> serde::Deserialize<'de> for GeneratedField {
4893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4894 where
4895 D: serde::Deserializer<'de>,
4896 {
4897 struct GeneratedVisitor;
4898
4899 impl serde::de::Visitor<'_> for GeneratedVisitor {
4900 type Value = GeneratedField;
4901
4902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4903 write!(formatter, "expected one of: {:?}", &FIELDS)
4904 }
4905
4906 #[allow(unused_variables)]
4907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4908 where
4909 E: serde::de::Error,
4910 {
4911 match value {
4912 "reason" => Ok(GeneratedField::Reason),
4913 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4914 }
4915 }
4916 }
4917 deserializer.deserialize_identifier(GeneratedVisitor)
4918 }
4919 }
4920 struct GeneratedVisitor;
4921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4922 type Value = event_log::event_recovery::GlobalRecoveryStart;
4923
4924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4925 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4926 }
4927
4928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4929 where
4930 V: serde::de::MapAccess<'de>,
4931 {
4932 let mut reason__ = None;
4933 while let Some(k) = map_.next_key()? {
4934 match k {
4935 GeneratedField::Reason => {
4936 if reason__.is_some() {
4937 return Err(serde::de::Error::duplicate_field("reason"));
4938 }
4939 reason__ = Some(map_.next_value()?);
4940 }
4941 }
4942 }
4943 Ok(event_log::event_recovery::GlobalRecoveryStart {
4944 reason: reason__.unwrap_or_default(),
4945 })
4946 }
4947 }
4948 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4949 }
4950}
4951impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4952 #[allow(deprecated)]
4953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4954 where
4955 S: serde::Serializer,
4956 {
4957 use serde::ser::SerializeStruct;
4958 let mut len = 0;
4959 if !self.reason.is_empty() {
4960 len += 1;
4961 }
4962 if self.duration_secs != 0. {
4963 len += 1;
4964 }
4965 if !self.running_database_ids.is_empty() {
4966 len += 1;
4967 }
4968 if !self.recovering_database_ids.is_empty() {
4969 len += 1;
4970 }
4971 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4972 if !self.reason.is_empty() {
4973 struct_ser.serialize_field("reason", &self.reason)?;
4974 }
4975 if self.duration_secs != 0. {
4976 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4977 }
4978 if !self.running_database_ids.is_empty() {
4979 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4980 }
4981 if !self.recovering_database_ids.is_empty() {
4982 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4983 }
4984 struct_ser.end()
4985 }
4986}
4987impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4988 #[allow(deprecated)]
4989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4990 where
4991 D: serde::Deserializer<'de>,
4992 {
4993 const FIELDS: &[&str] = &[
4994 "reason",
4995 "duration_secs",
4996 "durationSecs",
4997 "running_database_ids",
4998 "runningDatabaseIds",
4999 "recovering_database_ids",
5000 "recoveringDatabaseIds",
5001 ];
5002
5003 #[allow(clippy::enum_variant_names)]
5004 enum GeneratedField {
5005 Reason,
5006 DurationSecs,
5007 RunningDatabaseIds,
5008 RecoveringDatabaseIds,
5009 }
5010 impl<'de> serde::Deserialize<'de> for GeneratedField {
5011 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5012 where
5013 D: serde::Deserializer<'de>,
5014 {
5015 struct GeneratedVisitor;
5016
5017 impl serde::de::Visitor<'_> for GeneratedVisitor {
5018 type Value = GeneratedField;
5019
5020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5021 write!(formatter, "expected one of: {:?}", &FIELDS)
5022 }
5023
5024 #[allow(unused_variables)]
5025 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5026 where
5027 E: serde::de::Error,
5028 {
5029 match value {
5030 "reason" => Ok(GeneratedField::Reason),
5031 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
5032 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
5033 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
5034 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5035 }
5036 }
5037 }
5038 deserializer.deserialize_identifier(GeneratedVisitor)
5039 }
5040 }
5041 struct GeneratedVisitor;
5042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5043 type Value = event_log::event_recovery::GlobalRecoverySuccess;
5044
5045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5046 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
5047 }
5048
5049 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
5050 where
5051 V: serde::de::MapAccess<'de>,
5052 {
5053 let mut reason__ = None;
5054 let mut duration_secs__ = None;
5055 let mut running_database_ids__ = None;
5056 let mut recovering_database_ids__ = None;
5057 while let Some(k) = map_.next_key()? {
5058 match k {
5059 GeneratedField::Reason => {
5060 if reason__.is_some() {
5061 return Err(serde::de::Error::duplicate_field("reason"));
5062 }
5063 reason__ = Some(map_.next_value()?);
5064 }
5065 GeneratedField::DurationSecs => {
5066 if duration_secs__.is_some() {
5067 return Err(serde::de::Error::duplicate_field("durationSecs"));
5068 }
5069 duration_secs__ =
5070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5071 ;
5072 }
5073 GeneratedField::RunningDatabaseIds => {
5074 if running_database_ids__.is_some() {
5075 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
5076 }
5077 running_database_ids__ =
5078 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5079 .into_iter().map(|x| x.0).collect())
5080 ;
5081 }
5082 GeneratedField::RecoveringDatabaseIds => {
5083 if recovering_database_ids__.is_some() {
5084 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
5085 }
5086 recovering_database_ids__ =
5087 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5088 .into_iter().map(|x| x.0).collect())
5089 ;
5090 }
5091 }
5092 }
5093 Ok(event_log::event_recovery::GlobalRecoverySuccess {
5094 reason: reason__.unwrap_or_default(),
5095 duration_secs: duration_secs__.unwrap_or_default(),
5096 running_database_ids: running_database_ids__.unwrap_or_default(),
5097 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
5098 })
5099 }
5100 }
5101 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
5102 }
5103}
5104impl serde::Serialize for event_log::EventSinkFail {
5105 #[allow(deprecated)]
5106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5107 where
5108 S: serde::Serializer,
5109 {
5110 use serde::ser::SerializeStruct;
5111 let mut len = 0;
5112 if self.sink_id != 0 {
5113 len += 1;
5114 }
5115 if !self.sink_name.is_empty() {
5116 len += 1;
5117 }
5118 if !self.connector.is_empty() {
5119 len += 1;
5120 }
5121 if !self.error.is_empty() {
5122 len += 1;
5123 }
5124 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
5125 if self.sink_id != 0 {
5126 struct_ser.serialize_field("sinkId", &self.sink_id)?;
5127 }
5128 if !self.sink_name.is_empty() {
5129 struct_ser.serialize_field("sinkName", &self.sink_name)?;
5130 }
5131 if !self.connector.is_empty() {
5132 struct_ser.serialize_field("connector", &self.connector)?;
5133 }
5134 if !self.error.is_empty() {
5135 struct_ser.serialize_field("error", &self.error)?;
5136 }
5137 struct_ser.end()
5138 }
5139}
5140impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
5141 #[allow(deprecated)]
5142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5143 where
5144 D: serde::Deserializer<'de>,
5145 {
5146 const FIELDS: &[&str] = &[
5147 "sink_id",
5148 "sinkId",
5149 "sink_name",
5150 "sinkName",
5151 "connector",
5152 "error",
5153 ];
5154
5155 #[allow(clippy::enum_variant_names)]
5156 enum GeneratedField {
5157 SinkId,
5158 SinkName,
5159 Connector,
5160 Error,
5161 }
5162 impl<'de> serde::Deserialize<'de> for GeneratedField {
5163 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5164 where
5165 D: serde::Deserializer<'de>,
5166 {
5167 struct GeneratedVisitor;
5168
5169 impl serde::de::Visitor<'_> for GeneratedVisitor {
5170 type Value = GeneratedField;
5171
5172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5173 write!(formatter, "expected one of: {:?}", &FIELDS)
5174 }
5175
5176 #[allow(unused_variables)]
5177 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5178 where
5179 E: serde::de::Error,
5180 {
5181 match value {
5182 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
5183 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
5184 "connector" => Ok(GeneratedField::Connector),
5185 "error" => Ok(GeneratedField::Error),
5186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5187 }
5188 }
5189 }
5190 deserializer.deserialize_identifier(GeneratedVisitor)
5191 }
5192 }
5193 struct GeneratedVisitor;
5194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5195 type Value = event_log::EventSinkFail;
5196
5197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5198 formatter.write_str("struct meta.EventLog.EventSinkFail")
5199 }
5200
5201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
5202 where
5203 V: serde::de::MapAccess<'de>,
5204 {
5205 let mut sink_id__ = None;
5206 let mut sink_name__ = None;
5207 let mut connector__ = None;
5208 let mut error__ = None;
5209 while let Some(k) = map_.next_key()? {
5210 match k {
5211 GeneratedField::SinkId => {
5212 if sink_id__.is_some() {
5213 return Err(serde::de::Error::duplicate_field("sinkId"));
5214 }
5215 sink_id__ =
5216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5217 ;
5218 }
5219 GeneratedField::SinkName => {
5220 if sink_name__.is_some() {
5221 return Err(serde::de::Error::duplicate_field("sinkName"));
5222 }
5223 sink_name__ = Some(map_.next_value()?);
5224 }
5225 GeneratedField::Connector => {
5226 if connector__.is_some() {
5227 return Err(serde::de::Error::duplicate_field("connector"));
5228 }
5229 connector__ = Some(map_.next_value()?);
5230 }
5231 GeneratedField::Error => {
5232 if error__.is_some() {
5233 return Err(serde::de::Error::duplicate_field("error"));
5234 }
5235 error__ = Some(map_.next_value()?);
5236 }
5237 }
5238 }
5239 Ok(event_log::EventSinkFail {
5240 sink_id: sink_id__.unwrap_or_default(),
5241 sink_name: sink_name__.unwrap_or_default(),
5242 connector: connector__.unwrap_or_default(),
5243 error: error__.unwrap_or_default(),
5244 })
5245 }
5246 }
5247 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
5248 }
5249}
5250impl serde::Serialize for event_log::EventWorkerNodePanic {
5251 #[allow(deprecated)]
5252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5253 where
5254 S: serde::Serializer,
5255 {
5256 use serde::ser::SerializeStruct;
5257 let mut len = 0;
5258 if self.worker_id != 0 {
5259 len += 1;
5260 }
5261 if self.worker_type != 0 {
5262 len += 1;
5263 }
5264 if self.host_addr.is_some() {
5265 len += 1;
5266 }
5267 if !self.panic_info.is_empty() {
5268 len += 1;
5269 }
5270 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
5271 if self.worker_id != 0 {
5272 struct_ser.serialize_field("workerId", &self.worker_id)?;
5273 }
5274 if self.worker_type != 0 {
5275 let v = super::common::WorkerType::try_from(self.worker_type)
5276 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
5277 struct_ser.serialize_field("workerType", &v)?;
5278 }
5279 if let Some(v) = self.host_addr.as_ref() {
5280 struct_ser.serialize_field("hostAddr", v)?;
5281 }
5282 if !self.panic_info.is_empty() {
5283 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
5284 }
5285 struct_ser.end()
5286 }
5287}
5288impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
5289 #[allow(deprecated)]
5290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5291 where
5292 D: serde::Deserializer<'de>,
5293 {
5294 const FIELDS: &[&str] = &[
5295 "worker_id",
5296 "workerId",
5297 "worker_type",
5298 "workerType",
5299 "host_addr",
5300 "hostAddr",
5301 "panic_info",
5302 "panicInfo",
5303 ];
5304
5305 #[allow(clippy::enum_variant_names)]
5306 enum GeneratedField {
5307 WorkerId,
5308 WorkerType,
5309 HostAddr,
5310 PanicInfo,
5311 }
5312 impl<'de> serde::Deserialize<'de> for GeneratedField {
5313 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5314 where
5315 D: serde::Deserializer<'de>,
5316 {
5317 struct GeneratedVisitor;
5318
5319 impl serde::de::Visitor<'_> for GeneratedVisitor {
5320 type Value = GeneratedField;
5321
5322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5323 write!(formatter, "expected one of: {:?}", &FIELDS)
5324 }
5325
5326 #[allow(unused_variables)]
5327 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5328 where
5329 E: serde::de::Error,
5330 {
5331 match value {
5332 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
5333 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
5334 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
5335 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
5336 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5337 }
5338 }
5339 }
5340 deserializer.deserialize_identifier(GeneratedVisitor)
5341 }
5342 }
5343 struct GeneratedVisitor;
5344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5345 type Value = event_log::EventWorkerNodePanic;
5346
5347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5348 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
5349 }
5350
5351 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
5352 where
5353 V: serde::de::MapAccess<'de>,
5354 {
5355 let mut worker_id__ = None;
5356 let mut worker_type__ = None;
5357 let mut host_addr__ = None;
5358 let mut panic_info__ = None;
5359 while let Some(k) = map_.next_key()? {
5360 match k {
5361 GeneratedField::WorkerId => {
5362 if worker_id__.is_some() {
5363 return Err(serde::de::Error::duplicate_field("workerId"));
5364 }
5365 worker_id__ =
5366 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5367 ;
5368 }
5369 GeneratedField::WorkerType => {
5370 if worker_type__.is_some() {
5371 return Err(serde::de::Error::duplicate_field("workerType"));
5372 }
5373 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
5374 }
5375 GeneratedField::HostAddr => {
5376 if host_addr__.is_some() {
5377 return Err(serde::de::Error::duplicate_field("hostAddr"));
5378 }
5379 host_addr__ = map_.next_value()?;
5380 }
5381 GeneratedField::PanicInfo => {
5382 if panic_info__.is_some() {
5383 return Err(serde::de::Error::duplicate_field("panicInfo"));
5384 }
5385 panic_info__ = Some(map_.next_value()?);
5386 }
5387 }
5388 }
5389 Ok(event_log::EventWorkerNodePanic {
5390 worker_id: worker_id__.unwrap_or_default(),
5391 worker_type: worker_type__.unwrap_or_default(),
5392 host_addr: host_addr__,
5393 panic_info: panic_info__.unwrap_or_default(),
5394 })
5395 }
5396 }
5397 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
5398 }
5399}
5400impl serde::Serialize for FlushRequest {
5401 #[allow(deprecated)]
5402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5403 where
5404 S: serde::Serializer,
5405 {
5406 use serde::ser::SerializeStruct;
5407 let mut len = 0;
5408 if self.database_id != 0 {
5409 len += 1;
5410 }
5411 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
5412 if self.database_id != 0 {
5413 struct_ser.serialize_field("databaseId", &self.database_id)?;
5414 }
5415 struct_ser.end()
5416 }
5417}
5418impl<'de> serde::Deserialize<'de> for FlushRequest {
5419 #[allow(deprecated)]
5420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5421 where
5422 D: serde::Deserializer<'de>,
5423 {
5424 const FIELDS: &[&str] = &[
5425 "database_id",
5426 "databaseId",
5427 ];
5428
5429 #[allow(clippy::enum_variant_names)]
5430 enum GeneratedField {
5431 DatabaseId,
5432 }
5433 impl<'de> serde::Deserialize<'de> for GeneratedField {
5434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5435 where
5436 D: serde::Deserializer<'de>,
5437 {
5438 struct GeneratedVisitor;
5439
5440 impl serde::de::Visitor<'_> for GeneratedVisitor {
5441 type Value = GeneratedField;
5442
5443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5444 write!(formatter, "expected one of: {:?}", &FIELDS)
5445 }
5446
5447 #[allow(unused_variables)]
5448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5449 where
5450 E: serde::de::Error,
5451 {
5452 match value {
5453 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5455 }
5456 }
5457 }
5458 deserializer.deserialize_identifier(GeneratedVisitor)
5459 }
5460 }
5461 struct GeneratedVisitor;
5462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5463 type Value = FlushRequest;
5464
5465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5466 formatter.write_str("struct meta.FlushRequest")
5467 }
5468
5469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5470 where
5471 V: serde::de::MapAccess<'de>,
5472 {
5473 let mut database_id__ = None;
5474 while let Some(k) = map_.next_key()? {
5475 match k {
5476 GeneratedField::DatabaseId => {
5477 if database_id__.is_some() {
5478 return Err(serde::de::Error::duplicate_field("databaseId"));
5479 }
5480 database_id__ =
5481 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5482 ;
5483 }
5484 }
5485 }
5486 Ok(FlushRequest {
5487 database_id: database_id__.unwrap_or_default(),
5488 })
5489 }
5490 }
5491 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5492 }
5493}
5494impl serde::Serialize for FlushResponse {
5495 #[allow(deprecated)]
5496 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5497 where
5498 S: serde::Serializer,
5499 {
5500 use serde::ser::SerializeStruct;
5501 let mut len = 0;
5502 if self.status.is_some() {
5503 len += 1;
5504 }
5505 if self.hummock_version_id != 0 {
5506 len += 1;
5507 }
5508 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5509 if let Some(v) = self.status.as_ref() {
5510 struct_ser.serialize_field("status", v)?;
5511 }
5512 if self.hummock_version_id != 0 {
5513 #[allow(clippy::needless_borrow)]
5514 #[allow(clippy::needless_borrows_for_generic_args)]
5515 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5516 }
5517 struct_ser.end()
5518 }
5519}
5520impl<'de> serde::Deserialize<'de> for FlushResponse {
5521 #[allow(deprecated)]
5522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5523 where
5524 D: serde::Deserializer<'de>,
5525 {
5526 const FIELDS: &[&str] = &[
5527 "status",
5528 "hummock_version_id",
5529 "hummockVersionId",
5530 ];
5531
5532 #[allow(clippy::enum_variant_names)]
5533 enum GeneratedField {
5534 Status,
5535 HummockVersionId,
5536 }
5537 impl<'de> serde::Deserialize<'de> for GeneratedField {
5538 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5539 where
5540 D: serde::Deserializer<'de>,
5541 {
5542 struct GeneratedVisitor;
5543
5544 impl serde::de::Visitor<'_> for GeneratedVisitor {
5545 type Value = GeneratedField;
5546
5547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5548 write!(formatter, "expected one of: {:?}", &FIELDS)
5549 }
5550
5551 #[allow(unused_variables)]
5552 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5553 where
5554 E: serde::de::Error,
5555 {
5556 match value {
5557 "status" => Ok(GeneratedField::Status),
5558 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5559 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5560 }
5561 }
5562 }
5563 deserializer.deserialize_identifier(GeneratedVisitor)
5564 }
5565 }
5566 struct GeneratedVisitor;
5567 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5568 type Value = FlushResponse;
5569
5570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5571 formatter.write_str("struct meta.FlushResponse")
5572 }
5573
5574 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5575 where
5576 V: serde::de::MapAccess<'de>,
5577 {
5578 let mut status__ = None;
5579 let mut hummock_version_id__ = None;
5580 while let Some(k) = map_.next_key()? {
5581 match k {
5582 GeneratedField::Status => {
5583 if status__.is_some() {
5584 return Err(serde::de::Error::duplicate_field("status"));
5585 }
5586 status__ = map_.next_value()?;
5587 }
5588 GeneratedField::HummockVersionId => {
5589 if hummock_version_id__.is_some() {
5590 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5591 }
5592 hummock_version_id__ =
5593 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5594 ;
5595 }
5596 }
5597 }
5598 Ok(FlushResponse {
5599 status: status__,
5600 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5601 })
5602 }
5603 }
5604 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5605 }
5606}
5607impl serde::Serialize for FragmentDistribution {
5608 #[allow(deprecated)]
5609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5610 where
5611 S: serde::Serializer,
5612 {
5613 use serde::ser::SerializeStruct;
5614 let mut len = 0;
5615 if self.fragment_id != 0 {
5616 len += 1;
5617 }
5618 if self.table_id != 0 {
5619 len += 1;
5620 }
5621 if self.distribution_type != 0 {
5622 len += 1;
5623 }
5624 if !self.state_table_ids.is_empty() {
5625 len += 1;
5626 }
5627 if !self.upstream_fragment_ids.is_empty() {
5628 len += 1;
5629 }
5630 if self.fragment_type_mask != 0 {
5631 len += 1;
5632 }
5633 if self.parallelism != 0 {
5634 len += 1;
5635 }
5636 if self.vnode_count != 0 {
5637 len += 1;
5638 }
5639 if self.node.is_some() {
5640 len += 1;
5641 }
5642 if !self.parallelism_policy.is_empty() {
5643 len += 1;
5644 }
5645 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5646 if self.fragment_id != 0 {
5647 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5648 }
5649 if self.table_id != 0 {
5650 struct_ser.serialize_field("tableId", &self.table_id)?;
5651 }
5652 if self.distribution_type != 0 {
5653 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5654 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5655 struct_ser.serialize_field("distributionType", &v)?;
5656 }
5657 if !self.state_table_ids.is_empty() {
5658 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5659 }
5660 if !self.upstream_fragment_ids.is_empty() {
5661 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5662 }
5663 if self.fragment_type_mask != 0 {
5664 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5665 }
5666 if self.parallelism != 0 {
5667 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5668 }
5669 if self.vnode_count != 0 {
5670 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5671 }
5672 if let Some(v) = self.node.as_ref() {
5673 struct_ser.serialize_field("node", v)?;
5674 }
5675 if !self.parallelism_policy.is_empty() {
5676 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5677 }
5678 struct_ser.end()
5679 }
5680}
5681impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5682 #[allow(deprecated)]
5683 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5684 where
5685 D: serde::Deserializer<'de>,
5686 {
5687 const FIELDS: &[&str] = &[
5688 "fragment_id",
5689 "fragmentId",
5690 "table_id",
5691 "tableId",
5692 "distribution_type",
5693 "distributionType",
5694 "state_table_ids",
5695 "stateTableIds",
5696 "upstream_fragment_ids",
5697 "upstreamFragmentIds",
5698 "fragment_type_mask",
5699 "fragmentTypeMask",
5700 "parallelism",
5701 "vnode_count",
5702 "vnodeCount",
5703 "node",
5704 "parallelism_policy",
5705 "parallelismPolicy",
5706 ];
5707
5708 #[allow(clippy::enum_variant_names)]
5709 enum GeneratedField {
5710 FragmentId,
5711 TableId,
5712 DistributionType,
5713 StateTableIds,
5714 UpstreamFragmentIds,
5715 FragmentTypeMask,
5716 Parallelism,
5717 VnodeCount,
5718 Node,
5719 ParallelismPolicy,
5720 }
5721 impl<'de> serde::Deserialize<'de> for GeneratedField {
5722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5723 where
5724 D: serde::Deserializer<'de>,
5725 {
5726 struct GeneratedVisitor;
5727
5728 impl serde::de::Visitor<'_> for GeneratedVisitor {
5729 type Value = GeneratedField;
5730
5731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5732 write!(formatter, "expected one of: {:?}", &FIELDS)
5733 }
5734
5735 #[allow(unused_variables)]
5736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5737 where
5738 E: serde::de::Error,
5739 {
5740 match value {
5741 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5742 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5743 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5744 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5745 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5746 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5747 "parallelism" => Ok(GeneratedField::Parallelism),
5748 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5749 "node" => Ok(GeneratedField::Node),
5750 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5752 }
5753 }
5754 }
5755 deserializer.deserialize_identifier(GeneratedVisitor)
5756 }
5757 }
5758 struct GeneratedVisitor;
5759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5760 type Value = FragmentDistribution;
5761
5762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5763 formatter.write_str("struct meta.FragmentDistribution")
5764 }
5765
5766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5767 where
5768 V: serde::de::MapAccess<'de>,
5769 {
5770 let mut fragment_id__ = None;
5771 let mut table_id__ = None;
5772 let mut distribution_type__ = None;
5773 let mut state_table_ids__ = None;
5774 let mut upstream_fragment_ids__ = None;
5775 let mut fragment_type_mask__ = None;
5776 let mut parallelism__ = None;
5777 let mut vnode_count__ = None;
5778 let mut node__ = None;
5779 let mut parallelism_policy__ = None;
5780 while let Some(k) = map_.next_key()? {
5781 match k {
5782 GeneratedField::FragmentId => {
5783 if fragment_id__.is_some() {
5784 return Err(serde::de::Error::duplicate_field("fragmentId"));
5785 }
5786 fragment_id__ =
5787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5788 ;
5789 }
5790 GeneratedField::TableId => {
5791 if table_id__.is_some() {
5792 return Err(serde::de::Error::duplicate_field("tableId"));
5793 }
5794 table_id__ =
5795 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5796 ;
5797 }
5798 GeneratedField::DistributionType => {
5799 if distribution_type__.is_some() {
5800 return Err(serde::de::Error::duplicate_field("distributionType"));
5801 }
5802 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5803 }
5804 GeneratedField::StateTableIds => {
5805 if state_table_ids__.is_some() {
5806 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5807 }
5808 state_table_ids__ =
5809 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5810 .into_iter().map(|x| x.0).collect())
5811 ;
5812 }
5813 GeneratedField::UpstreamFragmentIds => {
5814 if upstream_fragment_ids__.is_some() {
5815 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5816 }
5817 upstream_fragment_ids__ =
5818 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5819 .into_iter().map(|x| x.0).collect())
5820 ;
5821 }
5822 GeneratedField::FragmentTypeMask => {
5823 if fragment_type_mask__.is_some() {
5824 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5825 }
5826 fragment_type_mask__ =
5827 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5828 ;
5829 }
5830 GeneratedField::Parallelism => {
5831 if parallelism__.is_some() {
5832 return Err(serde::de::Error::duplicate_field("parallelism"));
5833 }
5834 parallelism__ =
5835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5836 ;
5837 }
5838 GeneratedField::VnodeCount => {
5839 if vnode_count__.is_some() {
5840 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5841 }
5842 vnode_count__ =
5843 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5844 ;
5845 }
5846 GeneratedField::Node => {
5847 if node__.is_some() {
5848 return Err(serde::de::Error::duplicate_field("node"));
5849 }
5850 node__ = map_.next_value()?;
5851 }
5852 GeneratedField::ParallelismPolicy => {
5853 if parallelism_policy__.is_some() {
5854 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5855 }
5856 parallelism_policy__ = Some(map_.next_value()?);
5857 }
5858 }
5859 }
5860 Ok(FragmentDistribution {
5861 fragment_id: fragment_id__.unwrap_or_default(),
5862 table_id: table_id__.unwrap_or_default(),
5863 distribution_type: distribution_type__.unwrap_or_default(),
5864 state_table_ids: state_table_ids__.unwrap_or_default(),
5865 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5866 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5867 parallelism: parallelism__.unwrap_or_default(),
5868 vnode_count: vnode_count__.unwrap_or_default(),
5869 node: node__,
5870 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5871 })
5872 }
5873 }
5874 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5875 }
5876}
5877impl serde::Serialize for FragmentIdToActorIdMap {
5878 #[allow(deprecated)]
5879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5880 where
5881 S: serde::Serializer,
5882 {
5883 use serde::ser::SerializeStruct;
5884 let mut len = 0;
5885 if !self.map.is_empty() {
5886 len += 1;
5887 }
5888 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5889 if !self.map.is_empty() {
5890 struct_ser.serialize_field("map", &self.map)?;
5891 }
5892 struct_ser.end()
5893 }
5894}
5895impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5896 #[allow(deprecated)]
5897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5898 where
5899 D: serde::Deserializer<'de>,
5900 {
5901 const FIELDS: &[&str] = &[
5902 "map",
5903 ];
5904
5905 #[allow(clippy::enum_variant_names)]
5906 enum GeneratedField {
5907 Map,
5908 }
5909 impl<'de> serde::Deserialize<'de> for GeneratedField {
5910 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5911 where
5912 D: serde::Deserializer<'de>,
5913 {
5914 struct GeneratedVisitor;
5915
5916 impl serde::de::Visitor<'_> for GeneratedVisitor {
5917 type Value = GeneratedField;
5918
5919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5920 write!(formatter, "expected one of: {:?}", &FIELDS)
5921 }
5922
5923 #[allow(unused_variables)]
5924 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5925 where
5926 E: serde::de::Error,
5927 {
5928 match value {
5929 "map" => Ok(GeneratedField::Map),
5930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5931 }
5932 }
5933 }
5934 deserializer.deserialize_identifier(GeneratedVisitor)
5935 }
5936 }
5937 struct GeneratedVisitor;
5938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5939 type Value = FragmentIdToActorIdMap;
5940
5941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5942 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5943 }
5944
5945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5946 where
5947 V: serde::de::MapAccess<'de>,
5948 {
5949 let mut map__ = None;
5950 while let Some(k) = map_.next_key()? {
5951 match k {
5952 GeneratedField::Map => {
5953 if map__.is_some() {
5954 return Err(serde::de::Error::duplicate_field("map"));
5955 }
5956 map__ = Some(
5957 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5958 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5959 );
5960 }
5961 }
5962 }
5963 Ok(FragmentIdToActorIdMap {
5964 map: map__.unwrap_or_default(),
5965 })
5966 }
5967 }
5968 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5969 }
5970}
5971impl serde::Serialize for FragmentToRelationMap {
5972 #[allow(deprecated)]
5973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5974 where
5975 S: serde::Serializer,
5976 {
5977 use serde::ser::SerializeStruct;
5978 let mut len = 0;
5979 if !self.fragment_to_relation_map.is_empty() {
5980 len += 1;
5981 }
5982 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5983 if !self.fragment_to_relation_map.is_empty() {
5984 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5985 }
5986 struct_ser.end()
5987 }
5988}
5989impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5990 #[allow(deprecated)]
5991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5992 where
5993 D: serde::Deserializer<'de>,
5994 {
5995 const FIELDS: &[&str] = &[
5996 "fragment_to_relation_map",
5997 "fragmentToRelationMap",
5998 ];
5999
6000 #[allow(clippy::enum_variant_names)]
6001 enum GeneratedField {
6002 FragmentToRelationMap,
6003 }
6004 impl<'de> serde::Deserialize<'de> for GeneratedField {
6005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6006 where
6007 D: serde::Deserializer<'de>,
6008 {
6009 struct GeneratedVisitor;
6010
6011 impl serde::de::Visitor<'_> for GeneratedVisitor {
6012 type Value = GeneratedField;
6013
6014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6015 write!(formatter, "expected one of: {:?}", &FIELDS)
6016 }
6017
6018 #[allow(unused_variables)]
6019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6020 where
6021 E: serde::de::Error,
6022 {
6023 match value {
6024 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
6025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6026 }
6027 }
6028 }
6029 deserializer.deserialize_identifier(GeneratedVisitor)
6030 }
6031 }
6032 struct GeneratedVisitor;
6033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6034 type Value = FragmentToRelationMap;
6035
6036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6037 formatter.write_str("struct meta.FragmentToRelationMap")
6038 }
6039
6040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
6041 where
6042 V: serde::de::MapAccess<'de>,
6043 {
6044 let mut fragment_to_relation_map__ = None;
6045 while let Some(k) = map_.next_key()? {
6046 match k {
6047 GeneratedField::FragmentToRelationMap => {
6048 if fragment_to_relation_map__.is_some() {
6049 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
6050 }
6051 fragment_to_relation_map__ = Some(
6052 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
6053 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
6054 );
6055 }
6056 }
6057 }
6058 Ok(FragmentToRelationMap {
6059 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
6060 })
6061 }
6062 }
6063 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
6064 }
6065}
6066impl serde::Serialize for FragmentWorkerSlotMapping {
6067 #[allow(deprecated)]
6068 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6069 where
6070 S: serde::Serializer,
6071 {
6072 use serde::ser::SerializeStruct;
6073 let mut len = 0;
6074 if self.fragment_id != 0 {
6075 len += 1;
6076 }
6077 if self.mapping.is_some() {
6078 len += 1;
6079 }
6080 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
6081 if self.fragment_id != 0 {
6082 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6083 }
6084 if let Some(v) = self.mapping.as_ref() {
6085 struct_ser.serialize_field("mapping", v)?;
6086 }
6087 struct_ser.end()
6088 }
6089}
6090impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
6091 #[allow(deprecated)]
6092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6093 where
6094 D: serde::Deserializer<'de>,
6095 {
6096 const FIELDS: &[&str] = &[
6097 "fragment_id",
6098 "fragmentId",
6099 "mapping",
6100 ];
6101
6102 #[allow(clippy::enum_variant_names)]
6103 enum GeneratedField {
6104 FragmentId,
6105 Mapping,
6106 }
6107 impl<'de> serde::Deserialize<'de> for GeneratedField {
6108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6109 where
6110 D: serde::Deserializer<'de>,
6111 {
6112 struct GeneratedVisitor;
6113
6114 impl serde::de::Visitor<'_> for GeneratedVisitor {
6115 type Value = GeneratedField;
6116
6117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6118 write!(formatter, "expected one of: {:?}", &FIELDS)
6119 }
6120
6121 #[allow(unused_variables)]
6122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6123 where
6124 E: serde::de::Error,
6125 {
6126 match value {
6127 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6128 "mapping" => Ok(GeneratedField::Mapping),
6129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6130 }
6131 }
6132 }
6133 deserializer.deserialize_identifier(GeneratedVisitor)
6134 }
6135 }
6136 struct GeneratedVisitor;
6137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6138 type Value = FragmentWorkerSlotMapping;
6139
6140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6141 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
6142 }
6143
6144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
6145 where
6146 V: serde::de::MapAccess<'de>,
6147 {
6148 let mut fragment_id__ = None;
6149 let mut mapping__ = None;
6150 while let Some(k) = map_.next_key()? {
6151 match k {
6152 GeneratedField::FragmentId => {
6153 if fragment_id__.is_some() {
6154 return Err(serde::de::Error::duplicate_field("fragmentId"));
6155 }
6156 fragment_id__ =
6157 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6158 ;
6159 }
6160 GeneratedField::Mapping => {
6161 if mapping__.is_some() {
6162 return Err(serde::de::Error::duplicate_field("mapping"));
6163 }
6164 mapping__ = map_.next_value()?;
6165 }
6166 }
6167 }
6168 Ok(FragmentWorkerSlotMapping {
6169 fragment_id: fragment_id__.unwrap_or_default(),
6170 mapping: mapping__,
6171 })
6172 }
6173 }
6174 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
6175 }
6176}
6177impl serde::Serialize for FragmentWorkerSlotMappings {
6178 #[allow(deprecated)]
6179 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6180 where
6181 S: serde::Serializer,
6182 {
6183 use serde::ser::SerializeStruct;
6184 let mut len = 0;
6185 if !self.mappings.is_empty() {
6186 len += 1;
6187 }
6188 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
6189 if !self.mappings.is_empty() {
6190 struct_ser.serialize_field("mappings", &self.mappings)?;
6191 }
6192 struct_ser.end()
6193 }
6194}
6195impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
6196 #[allow(deprecated)]
6197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6198 where
6199 D: serde::Deserializer<'de>,
6200 {
6201 const FIELDS: &[&str] = &[
6202 "mappings",
6203 ];
6204
6205 #[allow(clippy::enum_variant_names)]
6206 enum GeneratedField {
6207 Mappings,
6208 }
6209 impl<'de> serde::Deserialize<'de> for GeneratedField {
6210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6211 where
6212 D: serde::Deserializer<'de>,
6213 {
6214 struct GeneratedVisitor;
6215
6216 impl serde::de::Visitor<'_> for GeneratedVisitor {
6217 type Value = GeneratedField;
6218
6219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6220 write!(formatter, "expected one of: {:?}", &FIELDS)
6221 }
6222
6223 #[allow(unused_variables)]
6224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6225 where
6226 E: serde::de::Error,
6227 {
6228 match value {
6229 "mappings" => Ok(GeneratedField::Mappings),
6230 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6231 }
6232 }
6233 }
6234 deserializer.deserialize_identifier(GeneratedVisitor)
6235 }
6236 }
6237 struct GeneratedVisitor;
6238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6239 type Value = FragmentWorkerSlotMappings;
6240
6241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6242 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
6243 }
6244
6245 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
6246 where
6247 V: serde::de::MapAccess<'de>,
6248 {
6249 let mut mappings__ = None;
6250 while let Some(k) = map_.next_key()? {
6251 match k {
6252 GeneratedField::Mappings => {
6253 if mappings__.is_some() {
6254 return Err(serde::de::Error::duplicate_field("mappings"));
6255 }
6256 mappings__ = Some(map_.next_value()?);
6257 }
6258 }
6259 }
6260 Ok(FragmentWorkerSlotMappings {
6261 mappings: mappings__.unwrap_or_default(),
6262 })
6263 }
6264 }
6265 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
6266 }
6267}
6268impl serde::Serialize for GetActorVnodesRequest {
6269 #[allow(deprecated)]
6270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6271 where
6272 S: serde::Serializer,
6273 {
6274 use serde::ser::SerializeStruct;
6275 let mut len = 0;
6276 if self.actor_id != 0 {
6277 len += 1;
6278 }
6279 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
6280 if self.actor_id != 0 {
6281 struct_ser.serialize_field("actorId", &self.actor_id)?;
6282 }
6283 struct_ser.end()
6284 }
6285}
6286impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
6287 #[allow(deprecated)]
6288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6289 where
6290 D: serde::Deserializer<'de>,
6291 {
6292 const FIELDS: &[&str] = &[
6293 "actor_id",
6294 "actorId",
6295 ];
6296
6297 #[allow(clippy::enum_variant_names)]
6298 enum GeneratedField {
6299 ActorId,
6300 }
6301 impl<'de> serde::Deserialize<'de> for GeneratedField {
6302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6303 where
6304 D: serde::Deserializer<'de>,
6305 {
6306 struct GeneratedVisitor;
6307
6308 impl serde::de::Visitor<'_> for GeneratedVisitor {
6309 type Value = GeneratedField;
6310
6311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6312 write!(formatter, "expected one of: {:?}", &FIELDS)
6313 }
6314
6315 #[allow(unused_variables)]
6316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6317 where
6318 E: serde::de::Error,
6319 {
6320 match value {
6321 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
6322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6323 }
6324 }
6325 }
6326 deserializer.deserialize_identifier(GeneratedVisitor)
6327 }
6328 }
6329 struct GeneratedVisitor;
6330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6331 type Value = GetActorVnodesRequest;
6332
6333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6334 formatter.write_str("struct meta.GetActorVnodesRequest")
6335 }
6336
6337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
6338 where
6339 V: serde::de::MapAccess<'de>,
6340 {
6341 let mut actor_id__ = None;
6342 while let Some(k) = map_.next_key()? {
6343 match k {
6344 GeneratedField::ActorId => {
6345 if actor_id__.is_some() {
6346 return Err(serde::de::Error::duplicate_field("actorId"));
6347 }
6348 actor_id__ =
6349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6350 ;
6351 }
6352 }
6353 }
6354 Ok(GetActorVnodesRequest {
6355 actor_id: actor_id__.unwrap_or_default(),
6356 })
6357 }
6358 }
6359 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
6360 }
6361}
6362impl serde::Serialize for GetActorVnodesResponse {
6363 #[allow(deprecated)]
6364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6365 where
6366 S: serde::Serializer,
6367 {
6368 use serde::ser::SerializeStruct;
6369 let mut len = 0;
6370 if !self.vnode_indices.is_empty() {
6371 len += 1;
6372 }
6373 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
6374 if !self.vnode_indices.is_empty() {
6375 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6376 }
6377 struct_ser.end()
6378 }
6379}
6380impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
6381 #[allow(deprecated)]
6382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6383 where
6384 D: serde::Deserializer<'de>,
6385 {
6386 const FIELDS: &[&str] = &[
6387 "vnode_indices",
6388 "vnodeIndices",
6389 ];
6390
6391 #[allow(clippy::enum_variant_names)]
6392 enum GeneratedField {
6393 VnodeIndices,
6394 }
6395 impl<'de> serde::Deserialize<'de> for GeneratedField {
6396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6397 where
6398 D: serde::Deserializer<'de>,
6399 {
6400 struct GeneratedVisitor;
6401
6402 impl serde::de::Visitor<'_> for GeneratedVisitor {
6403 type Value = GeneratedField;
6404
6405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6406 write!(formatter, "expected one of: {:?}", &FIELDS)
6407 }
6408
6409 #[allow(unused_variables)]
6410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6411 where
6412 E: serde::de::Error,
6413 {
6414 match value {
6415 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
6416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6417 }
6418 }
6419 }
6420 deserializer.deserialize_identifier(GeneratedVisitor)
6421 }
6422 }
6423 struct GeneratedVisitor;
6424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6425 type Value = GetActorVnodesResponse;
6426
6427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6428 formatter.write_str("struct meta.GetActorVnodesResponse")
6429 }
6430
6431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
6432 where
6433 V: serde::de::MapAccess<'de>,
6434 {
6435 let mut vnode_indices__ = None;
6436 while let Some(k) = map_.next_key()? {
6437 match k {
6438 GeneratedField::VnodeIndices => {
6439 if vnode_indices__.is_some() {
6440 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
6441 }
6442 vnode_indices__ =
6443 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6444 .into_iter().map(|x| x.0).collect())
6445 ;
6446 }
6447 }
6448 }
6449 Ok(GetActorVnodesResponse {
6450 vnode_indices: vnode_indices__.unwrap_or_default(),
6451 })
6452 }
6453 }
6454 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6455 }
6456}
6457impl serde::Serialize for GetClusterInfoRequest {
6458 #[allow(deprecated)]
6459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6460 where
6461 S: serde::Serializer,
6462 {
6463 use serde::ser::SerializeStruct;
6464 let len = 0;
6465 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6466 struct_ser.end()
6467 }
6468}
6469impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6470 #[allow(deprecated)]
6471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6472 where
6473 D: serde::Deserializer<'de>,
6474 {
6475 const FIELDS: &[&str] = &[
6476 ];
6477
6478 #[allow(clippy::enum_variant_names)]
6479 enum GeneratedField {
6480 }
6481 impl<'de> serde::Deserialize<'de> for GeneratedField {
6482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6483 where
6484 D: serde::Deserializer<'de>,
6485 {
6486 struct GeneratedVisitor;
6487
6488 impl serde::de::Visitor<'_> for GeneratedVisitor {
6489 type Value = GeneratedField;
6490
6491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6492 write!(formatter, "expected one of: {:?}", &FIELDS)
6493 }
6494
6495 #[allow(unused_variables)]
6496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6497 where
6498 E: serde::de::Error,
6499 {
6500 Err(serde::de::Error::unknown_field(value, FIELDS))
6501 }
6502 }
6503 deserializer.deserialize_identifier(GeneratedVisitor)
6504 }
6505 }
6506 struct GeneratedVisitor;
6507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6508 type Value = GetClusterInfoRequest;
6509
6510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6511 formatter.write_str("struct meta.GetClusterInfoRequest")
6512 }
6513
6514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6515 where
6516 V: serde::de::MapAccess<'de>,
6517 {
6518 while map_.next_key::<GeneratedField>()?.is_some() {
6519 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6520 }
6521 Ok(GetClusterInfoRequest {
6522 })
6523 }
6524 }
6525 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6526 }
6527}
6528impl serde::Serialize for GetClusterInfoResponse {
6529 #[allow(deprecated)]
6530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6531 where
6532 S: serde::Serializer,
6533 {
6534 use serde::ser::SerializeStruct;
6535 let mut len = 0;
6536 if !self.worker_nodes.is_empty() {
6537 len += 1;
6538 }
6539 if !self.table_fragments.is_empty() {
6540 len += 1;
6541 }
6542 if !self.actor_splits.is_empty() {
6543 len += 1;
6544 }
6545 if !self.source_infos.is_empty() {
6546 len += 1;
6547 }
6548 if self.revision != 0 {
6549 len += 1;
6550 }
6551 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6552 if !self.worker_nodes.is_empty() {
6553 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6554 }
6555 if !self.table_fragments.is_empty() {
6556 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6557 }
6558 if !self.actor_splits.is_empty() {
6559 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6560 }
6561 if !self.source_infos.is_empty() {
6562 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6563 }
6564 if self.revision != 0 {
6565 #[allow(clippy::needless_borrow)]
6566 #[allow(clippy::needless_borrows_for_generic_args)]
6567 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6568 }
6569 struct_ser.end()
6570 }
6571}
6572impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6573 #[allow(deprecated)]
6574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6575 where
6576 D: serde::Deserializer<'de>,
6577 {
6578 const FIELDS: &[&str] = &[
6579 "worker_nodes",
6580 "workerNodes",
6581 "table_fragments",
6582 "tableFragments",
6583 "actor_splits",
6584 "actorSplits",
6585 "source_infos",
6586 "sourceInfos",
6587 "revision",
6588 ];
6589
6590 #[allow(clippy::enum_variant_names)]
6591 enum GeneratedField {
6592 WorkerNodes,
6593 TableFragments,
6594 ActorSplits,
6595 SourceInfos,
6596 Revision,
6597 }
6598 impl<'de> serde::Deserialize<'de> for GeneratedField {
6599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6600 where
6601 D: serde::Deserializer<'de>,
6602 {
6603 struct GeneratedVisitor;
6604
6605 impl serde::de::Visitor<'_> for GeneratedVisitor {
6606 type Value = GeneratedField;
6607
6608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6609 write!(formatter, "expected one of: {:?}", &FIELDS)
6610 }
6611
6612 #[allow(unused_variables)]
6613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6614 where
6615 E: serde::de::Error,
6616 {
6617 match value {
6618 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6619 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6620 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6621 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6622 "revision" => Ok(GeneratedField::Revision),
6623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6624 }
6625 }
6626 }
6627 deserializer.deserialize_identifier(GeneratedVisitor)
6628 }
6629 }
6630 struct GeneratedVisitor;
6631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6632 type Value = GetClusterInfoResponse;
6633
6634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6635 formatter.write_str("struct meta.GetClusterInfoResponse")
6636 }
6637
6638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6639 where
6640 V: serde::de::MapAccess<'de>,
6641 {
6642 let mut worker_nodes__ = None;
6643 let mut table_fragments__ = None;
6644 let mut actor_splits__ = None;
6645 let mut source_infos__ = None;
6646 let mut revision__ = None;
6647 while let Some(k) = map_.next_key()? {
6648 match k {
6649 GeneratedField::WorkerNodes => {
6650 if worker_nodes__.is_some() {
6651 return Err(serde::de::Error::duplicate_field("workerNodes"));
6652 }
6653 worker_nodes__ = Some(map_.next_value()?);
6654 }
6655 GeneratedField::TableFragments => {
6656 if table_fragments__.is_some() {
6657 return Err(serde::de::Error::duplicate_field("tableFragments"));
6658 }
6659 table_fragments__ = Some(map_.next_value()?);
6660 }
6661 GeneratedField::ActorSplits => {
6662 if actor_splits__.is_some() {
6663 return Err(serde::de::Error::duplicate_field("actorSplits"));
6664 }
6665 actor_splits__ = Some(
6666 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6667 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6668 );
6669 }
6670 GeneratedField::SourceInfos => {
6671 if source_infos__.is_some() {
6672 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6673 }
6674 source_infos__ = Some(
6675 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6676 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6677 );
6678 }
6679 GeneratedField::Revision => {
6680 if revision__.is_some() {
6681 return Err(serde::de::Error::duplicate_field("revision"));
6682 }
6683 revision__ =
6684 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6685 ;
6686 }
6687 }
6688 }
6689 Ok(GetClusterInfoResponse {
6690 worker_nodes: worker_nodes__.unwrap_or_default(),
6691 table_fragments: table_fragments__.unwrap_or_default(),
6692 actor_splits: actor_splits__.unwrap_or_default(),
6693 source_infos: source_infos__.unwrap_or_default(),
6694 revision: revision__.unwrap_or_default(),
6695 })
6696 }
6697 }
6698 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6699 }
6700}
6701impl serde::Serialize for GetClusterLimitsRequest {
6702 #[allow(deprecated)]
6703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6704 where
6705 S: serde::Serializer,
6706 {
6707 use serde::ser::SerializeStruct;
6708 let len = 0;
6709 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6710 struct_ser.end()
6711 }
6712}
6713impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6714 #[allow(deprecated)]
6715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6716 where
6717 D: serde::Deserializer<'de>,
6718 {
6719 const FIELDS: &[&str] = &[
6720 ];
6721
6722 #[allow(clippy::enum_variant_names)]
6723 enum GeneratedField {
6724 }
6725 impl<'de> serde::Deserialize<'de> for GeneratedField {
6726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6727 where
6728 D: serde::Deserializer<'de>,
6729 {
6730 struct GeneratedVisitor;
6731
6732 impl serde::de::Visitor<'_> for GeneratedVisitor {
6733 type Value = GeneratedField;
6734
6735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6736 write!(formatter, "expected one of: {:?}", &FIELDS)
6737 }
6738
6739 #[allow(unused_variables)]
6740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6741 where
6742 E: serde::de::Error,
6743 {
6744 Err(serde::de::Error::unknown_field(value, FIELDS))
6745 }
6746 }
6747 deserializer.deserialize_identifier(GeneratedVisitor)
6748 }
6749 }
6750 struct GeneratedVisitor;
6751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6752 type Value = GetClusterLimitsRequest;
6753
6754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6755 formatter.write_str("struct meta.GetClusterLimitsRequest")
6756 }
6757
6758 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6759 where
6760 V: serde::de::MapAccess<'de>,
6761 {
6762 while map_.next_key::<GeneratedField>()?.is_some() {
6763 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6764 }
6765 Ok(GetClusterLimitsRequest {
6766 })
6767 }
6768 }
6769 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6770 }
6771}
6772impl serde::Serialize for GetClusterLimitsResponse {
6773 #[allow(deprecated)]
6774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6775 where
6776 S: serde::Serializer,
6777 {
6778 use serde::ser::SerializeStruct;
6779 let mut len = 0;
6780 if !self.active_limits.is_empty() {
6781 len += 1;
6782 }
6783 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6784 if !self.active_limits.is_empty() {
6785 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6786 }
6787 struct_ser.end()
6788 }
6789}
6790impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6791 #[allow(deprecated)]
6792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6793 where
6794 D: serde::Deserializer<'de>,
6795 {
6796 const FIELDS: &[&str] = &[
6797 "active_limits",
6798 "activeLimits",
6799 ];
6800
6801 #[allow(clippy::enum_variant_names)]
6802 enum GeneratedField {
6803 ActiveLimits,
6804 }
6805 impl<'de> serde::Deserialize<'de> for GeneratedField {
6806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6807 where
6808 D: serde::Deserializer<'de>,
6809 {
6810 struct GeneratedVisitor;
6811
6812 impl serde::de::Visitor<'_> for GeneratedVisitor {
6813 type Value = GeneratedField;
6814
6815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6816 write!(formatter, "expected one of: {:?}", &FIELDS)
6817 }
6818
6819 #[allow(unused_variables)]
6820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6821 where
6822 E: serde::de::Error,
6823 {
6824 match value {
6825 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6826 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6827 }
6828 }
6829 }
6830 deserializer.deserialize_identifier(GeneratedVisitor)
6831 }
6832 }
6833 struct GeneratedVisitor;
6834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6835 type Value = GetClusterLimitsResponse;
6836
6837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6838 formatter.write_str("struct meta.GetClusterLimitsResponse")
6839 }
6840
6841 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6842 where
6843 V: serde::de::MapAccess<'de>,
6844 {
6845 let mut active_limits__ = None;
6846 while let Some(k) = map_.next_key()? {
6847 match k {
6848 GeneratedField::ActiveLimits => {
6849 if active_limits__.is_some() {
6850 return Err(serde::de::Error::duplicate_field("activeLimits"));
6851 }
6852 active_limits__ = Some(map_.next_value()?);
6853 }
6854 }
6855 }
6856 Ok(GetClusterLimitsResponse {
6857 active_limits: active_limits__.unwrap_or_default(),
6858 })
6859 }
6860 }
6861 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6862 }
6863}
6864impl serde::Serialize for GetClusterRecoveryStatusRequest {
6865 #[allow(deprecated)]
6866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6867 where
6868 S: serde::Serializer,
6869 {
6870 use serde::ser::SerializeStruct;
6871 let len = 0;
6872 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6873 struct_ser.end()
6874 }
6875}
6876impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6877 #[allow(deprecated)]
6878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6879 where
6880 D: serde::Deserializer<'de>,
6881 {
6882 const FIELDS: &[&str] = &[
6883 ];
6884
6885 #[allow(clippy::enum_variant_names)]
6886 enum GeneratedField {
6887 }
6888 impl<'de> serde::Deserialize<'de> for GeneratedField {
6889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6890 where
6891 D: serde::Deserializer<'de>,
6892 {
6893 struct GeneratedVisitor;
6894
6895 impl serde::de::Visitor<'_> for GeneratedVisitor {
6896 type Value = GeneratedField;
6897
6898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6899 write!(formatter, "expected one of: {:?}", &FIELDS)
6900 }
6901
6902 #[allow(unused_variables)]
6903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6904 where
6905 E: serde::de::Error,
6906 {
6907 Err(serde::de::Error::unknown_field(value, FIELDS))
6908 }
6909 }
6910 deserializer.deserialize_identifier(GeneratedVisitor)
6911 }
6912 }
6913 struct GeneratedVisitor;
6914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6915 type Value = GetClusterRecoveryStatusRequest;
6916
6917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6918 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6919 }
6920
6921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6922 where
6923 V: serde::de::MapAccess<'de>,
6924 {
6925 while map_.next_key::<GeneratedField>()?.is_some() {
6926 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6927 }
6928 Ok(GetClusterRecoveryStatusRequest {
6929 })
6930 }
6931 }
6932 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6933 }
6934}
6935impl serde::Serialize for GetClusterRecoveryStatusResponse {
6936 #[allow(deprecated)]
6937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6938 where
6939 S: serde::Serializer,
6940 {
6941 use serde::ser::SerializeStruct;
6942 let mut len = 0;
6943 if self.status != 0 {
6944 len += 1;
6945 }
6946 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6947 if self.status != 0 {
6948 let v = RecoveryStatus::try_from(self.status)
6949 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6950 struct_ser.serialize_field("status", &v)?;
6951 }
6952 struct_ser.end()
6953 }
6954}
6955impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6956 #[allow(deprecated)]
6957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6958 where
6959 D: serde::Deserializer<'de>,
6960 {
6961 const FIELDS: &[&str] = &[
6962 "status",
6963 ];
6964
6965 #[allow(clippy::enum_variant_names)]
6966 enum GeneratedField {
6967 Status,
6968 }
6969 impl<'de> serde::Deserialize<'de> for GeneratedField {
6970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6971 where
6972 D: serde::Deserializer<'de>,
6973 {
6974 struct GeneratedVisitor;
6975
6976 impl serde::de::Visitor<'_> for GeneratedVisitor {
6977 type Value = GeneratedField;
6978
6979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6980 write!(formatter, "expected one of: {:?}", &FIELDS)
6981 }
6982
6983 #[allow(unused_variables)]
6984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6985 where
6986 E: serde::de::Error,
6987 {
6988 match value {
6989 "status" => Ok(GeneratedField::Status),
6990 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6991 }
6992 }
6993 }
6994 deserializer.deserialize_identifier(GeneratedVisitor)
6995 }
6996 }
6997 struct GeneratedVisitor;
6998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6999 type Value = GetClusterRecoveryStatusResponse;
7000
7001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7002 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
7003 }
7004
7005 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
7006 where
7007 V: serde::de::MapAccess<'de>,
7008 {
7009 let mut status__ = None;
7010 while let Some(k) = map_.next_key()? {
7011 match k {
7012 GeneratedField::Status => {
7013 if status__.is_some() {
7014 return Err(serde::de::Error::duplicate_field("status"));
7015 }
7016 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
7017 }
7018 }
7019 }
7020 Ok(GetClusterRecoveryStatusResponse {
7021 status: status__.unwrap_or_default(),
7022 })
7023 }
7024 }
7025 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
7026 }
7027}
7028impl serde::Serialize for GetFragmentByIdRequest {
7029 #[allow(deprecated)]
7030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7031 where
7032 S: serde::Serializer,
7033 {
7034 use serde::ser::SerializeStruct;
7035 let mut len = 0;
7036 if self.fragment_id != 0 {
7037 len += 1;
7038 }
7039 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
7040 if self.fragment_id != 0 {
7041 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7042 }
7043 struct_ser.end()
7044 }
7045}
7046impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
7047 #[allow(deprecated)]
7048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7049 where
7050 D: serde::Deserializer<'de>,
7051 {
7052 const FIELDS: &[&str] = &[
7053 "fragment_id",
7054 "fragmentId",
7055 ];
7056
7057 #[allow(clippy::enum_variant_names)]
7058 enum GeneratedField {
7059 FragmentId,
7060 }
7061 impl<'de> serde::Deserialize<'de> for GeneratedField {
7062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7063 where
7064 D: serde::Deserializer<'de>,
7065 {
7066 struct GeneratedVisitor;
7067
7068 impl serde::de::Visitor<'_> for GeneratedVisitor {
7069 type Value = GeneratedField;
7070
7071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7072 write!(formatter, "expected one of: {:?}", &FIELDS)
7073 }
7074
7075 #[allow(unused_variables)]
7076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7077 where
7078 E: serde::de::Error,
7079 {
7080 match value {
7081 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7082 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7083 }
7084 }
7085 }
7086 deserializer.deserialize_identifier(GeneratedVisitor)
7087 }
7088 }
7089 struct GeneratedVisitor;
7090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7091 type Value = GetFragmentByIdRequest;
7092
7093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7094 formatter.write_str("struct meta.GetFragmentByIdRequest")
7095 }
7096
7097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
7098 where
7099 V: serde::de::MapAccess<'de>,
7100 {
7101 let mut fragment_id__ = None;
7102 while let Some(k) = map_.next_key()? {
7103 match k {
7104 GeneratedField::FragmentId => {
7105 if fragment_id__.is_some() {
7106 return Err(serde::de::Error::duplicate_field("fragmentId"));
7107 }
7108 fragment_id__ =
7109 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7110 ;
7111 }
7112 }
7113 }
7114 Ok(GetFragmentByIdRequest {
7115 fragment_id: fragment_id__.unwrap_or_default(),
7116 })
7117 }
7118 }
7119 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
7120 }
7121}
7122impl serde::Serialize for GetFragmentByIdResponse {
7123 #[allow(deprecated)]
7124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7125 where
7126 S: serde::Serializer,
7127 {
7128 use serde::ser::SerializeStruct;
7129 let mut len = 0;
7130 if self.distribution.is_some() {
7131 len += 1;
7132 }
7133 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
7134 if let Some(v) = self.distribution.as_ref() {
7135 struct_ser.serialize_field("distribution", v)?;
7136 }
7137 struct_ser.end()
7138 }
7139}
7140impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
7141 #[allow(deprecated)]
7142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7143 where
7144 D: serde::Deserializer<'de>,
7145 {
7146 const FIELDS: &[&str] = &[
7147 "distribution",
7148 ];
7149
7150 #[allow(clippy::enum_variant_names)]
7151 enum GeneratedField {
7152 Distribution,
7153 }
7154 impl<'de> serde::Deserialize<'de> for GeneratedField {
7155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7156 where
7157 D: serde::Deserializer<'de>,
7158 {
7159 struct GeneratedVisitor;
7160
7161 impl serde::de::Visitor<'_> for GeneratedVisitor {
7162 type Value = GeneratedField;
7163
7164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7165 write!(formatter, "expected one of: {:?}", &FIELDS)
7166 }
7167
7168 #[allow(unused_variables)]
7169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7170 where
7171 E: serde::de::Error,
7172 {
7173 match value {
7174 "distribution" => Ok(GeneratedField::Distribution),
7175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7176 }
7177 }
7178 }
7179 deserializer.deserialize_identifier(GeneratedVisitor)
7180 }
7181 }
7182 struct GeneratedVisitor;
7183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7184 type Value = GetFragmentByIdResponse;
7185
7186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7187 formatter.write_str("struct meta.GetFragmentByIdResponse")
7188 }
7189
7190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
7191 where
7192 V: serde::de::MapAccess<'de>,
7193 {
7194 let mut distribution__ = None;
7195 while let Some(k) = map_.next_key()? {
7196 match k {
7197 GeneratedField::Distribution => {
7198 if distribution__.is_some() {
7199 return Err(serde::de::Error::duplicate_field("distribution"));
7200 }
7201 distribution__ = map_.next_value()?;
7202 }
7203 }
7204 }
7205 Ok(GetFragmentByIdResponse {
7206 distribution: distribution__,
7207 })
7208 }
7209 }
7210 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
7211 }
7212}
7213impl serde::Serialize for GetFragmentVnodesRequest {
7214 #[allow(deprecated)]
7215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7216 where
7217 S: serde::Serializer,
7218 {
7219 use serde::ser::SerializeStruct;
7220 let mut len = 0;
7221 if self.fragment_id != 0 {
7222 len += 1;
7223 }
7224 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
7225 if self.fragment_id != 0 {
7226 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7227 }
7228 struct_ser.end()
7229 }
7230}
7231impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
7232 #[allow(deprecated)]
7233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7234 where
7235 D: serde::Deserializer<'de>,
7236 {
7237 const FIELDS: &[&str] = &[
7238 "fragment_id",
7239 "fragmentId",
7240 ];
7241
7242 #[allow(clippy::enum_variant_names)]
7243 enum GeneratedField {
7244 FragmentId,
7245 }
7246 impl<'de> serde::Deserialize<'de> for GeneratedField {
7247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7248 where
7249 D: serde::Deserializer<'de>,
7250 {
7251 struct GeneratedVisitor;
7252
7253 impl serde::de::Visitor<'_> for GeneratedVisitor {
7254 type Value = GeneratedField;
7255
7256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7257 write!(formatter, "expected one of: {:?}", &FIELDS)
7258 }
7259
7260 #[allow(unused_variables)]
7261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7262 where
7263 E: serde::de::Error,
7264 {
7265 match value {
7266 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7267 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7268 }
7269 }
7270 }
7271 deserializer.deserialize_identifier(GeneratedVisitor)
7272 }
7273 }
7274 struct GeneratedVisitor;
7275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7276 type Value = GetFragmentVnodesRequest;
7277
7278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7279 formatter.write_str("struct meta.GetFragmentVnodesRequest")
7280 }
7281
7282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
7283 where
7284 V: serde::de::MapAccess<'de>,
7285 {
7286 let mut fragment_id__ = None;
7287 while let Some(k) = map_.next_key()? {
7288 match k {
7289 GeneratedField::FragmentId => {
7290 if fragment_id__.is_some() {
7291 return Err(serde::de::Error::duplicate_field("fragmentId"));
7292 }
7293 fragment_id__ =
7294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7295 ;
7296 }
7297 }
7298 }
7299 Ok(GetFragmentVnodesRequest {
7300 fragment_id: fragment_id__.unwrap_or_default(),
7301 })
7302 }
7303 }
7304 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
7305 }
7306}
7307impl serde::Serialize for GetFragmentVnodesResponse {
7308 #[allow(deprecated)]
7309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7310 where
7311 S: serde::Serializer,
7312 {
7313 use serde::ser::SerializeStruct;
7314 let mut len = 0;
7315 if !self.actor_vnodes.is_empty() {
7316 len += 1;
7317 }
7318 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
7319 if !self.actor_vnodes.is_empty() {
7320 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
7321 }
7322 struct_ser.end()
7323 }
7324}
7325impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
7326 #[allow(deprecated)]
7327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7328 where
7329 D: serde::Deserializer<'de>,
7330 {
7331 const FIELDS: &[&str] = &[
7332 "actor_vnodes",
7333 "actorVnodes",
7334 ];
7335
7336 #[allow(clippy::enum_variant_names)]
7337 enum GeneratedField {
7338 ActorVnodes,
7339 }
7340 impl<'de> serde::Deserialize<'de> for GeneratedField {
7341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7342 where
7343 D: serde::Deserializer<'de>,
7344 {
7345 struct GeneratedVisitor;
7346
7347 impl serde::de::Visitor<'_> for GeneratedVisitor {
7348 type Value = GeneratedField;
7349
7350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7351 write!(formatter, "expected one of: {:?}", &FIELDS)
7352 }
7353
7354 #[allow(unused_variables)]
7355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7356 where
7357 E: serde::de::Error,
7358 {
7359 match value {
7360 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
7361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7362 }
7363 }
7364 }
7365 deserializer.deserialize_identifier(GeneratedVisitor)
7366 }
7367 }
7368 struct GeneratedVisitor;
7369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7370 type Value = GetFragmentVnodesResponse;
7371
7372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7373 formatter.write_str("struct meta.GetFragmentVnodesResponse")
7374 }
7375
7376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
7377 where
7378 V: serde::de::MapAccess<'de>,
7379 {
7380 let mut actor_vnodes__ = None;
7381 while let Some(k) = map_.next_key()? {
7382 match k {
7383 GeneratedField::ActorVnodes => {
7384 if actor_vnodes__.is_some() {
7385 return Err(serde::de::Error::duplicate_field("actorVnodes"));
7386 }
7387 actor_vnodes__ = Some(map_.next_value()?);
7388 }
7389 }
7390 }
7391 Ok(GetFragmentVnodesResponse {
7392 actor_vnodes: actor_vnodes__.unwrap_or_default(),
7393 })
7394 }
7395 }
7396 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
7397 }
7398}
7399impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
7400 #[allow(deprecated)]
7401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7402 where
7403 S: serde::Serializer,
7404 {
7405 use serde::ser::SerializeStruct;
7406 let mut len = 0;
7407 if self.actor_id != 0 {
7408 len += 1;
7409 }
7410 if !self.vnode_indices.is_empty() {
7411 len += 1;
7412 }
7413 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
7414 if self.actor_id != 0 {
7415 struct_ser.serialize_field("actorId", &self.actor_id)?;
7416 }
7417 if !self.vnode_indices.is_empty() {
7418 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
7419 }
7420 struct_ser.end()
7421 }
7422}
7423impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
7424 #[allow(deprecated)]
7425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7426 where
7427 D: serde::Deserializer<'de>,
7428 {
7429 const FIELDS: &[&str] = &[
7430 "actor_id",
7431 "actorId",
7432 "vnode_indices",
7433 "vnodeIndices",
7434 ];
7435
7436 #[allow(clippy::enum_variant_names)]
7437 enum GeneratedField {
7438 ActorId,
7439 VnodeIndices,
7440 }
7441 impl<'de> serde::Deserialize<'de> for GeneratedField {
7442 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7443 where
7444 D: serde::Deserializer<'de>,
7445 {
7446 struct GeneratedVisitor;
7447
7448 impl serde::de::Visitor<'_> for GeneratedVisitor {
7449 type Value = GeneratedField;
7450
7451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7452 write!(formatter, "expected one of: {:?}", &FIELDS)
7453 }
7454
7455 #[allow(unused_variables)]
7456 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7457 where
7458 E: serde::de::Error,
7459 {
7460 match value {
7461 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7462 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7464 }
7465 }
7466 }
7467 deserializer.deserialize_identifier(GeneratedVisitor)
7468 }
7469 }
7470 struct GeneratedVisitor;
7471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7472 type Value = get_fragment_vnodes_response::ActorVnodes;
7473
7474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7475 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7476 }
7477
7478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7479 where
7480 V: serde::de::MapAccess<'de>,
7481 {
7482 let mut actor_id__ = None;
7483 let mut vnode_indices__ = None;
7484 while let Some(k) = map_.next_key()? {
7485 match k {
7486 GeneratedField::ActorId => {
7487 if actor_id__.is_some() {
7488 return Err(serde::de::Error::duplicate_field("actorId"));
7489 }
7490 actor_id__ =
7491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7492 ;
7493 }
7494 GeneratedField::VnodeIndices => {
7495 if vnode_indices__.is_some() {
7496 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7497 }
7498 vnode_indices__ =
7499 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7500 .into_iter().map(|x| x.0).collect())
7501 ;
7502 }
7503 }
7504 }
7505 Ok(get_fragment_vnodes_response::ActorVnodes {
7506 actor_id: actor_id__.unwrap_or_default(),
7507 vnode_indices: vnode_indices__.unwrap_or_default(),
7508 })
7509 }
7510 }
7511 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7512 }
7513}
7514impl serde::Serialize for GetMetaStoreInfoRequest {
7515 #[allow(deprecated)]
7516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7517 where
7518 S: serde::Serializer,
7519 {
7520 use serde::ser::SerializeStruct;
7521 let len = 0;
7522 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7523 struct_ser.end()
7524 }
7525}
7526impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7527 #[allow(deprecated)]
7528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7529 where
7530 D: serde::Deserializer<'de>,
7531 {
7532 const FIELDS: &[&str] = &[
7533 ];
7534
7535 #[allow(clippy::enum_variant_names)]
7536 enum GeneratedField {
7537 }
7538 impl<'de> serde::Deserialize<'de> for GeneratedField {
7539 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7540 where
7541 D: serde::Deserializer<'de>,
7542 {
7543 struct GeneratedVisitor;
7544
7545 impl serde::de::Visitor<'_> for GeneratedVisitor {
7546 type Value = GeneratedField;
7547
7548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7549 write!(formatter, "expected one of: {:?}", &FIELDS)
7550 }
7551
7552 #[allow(unused_variables)]
7553 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7554 where
7555 E: serde::de::Error,
7556 {
7557 Err(serde::de::Error::unknown_field(value, FIELDS))
7558 }
7559 }
7560 deserializer.deserialize_identifier(GeneratedVisitor)
7561 }
7562 }
7563 struct GeneratedVisitor;
7564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7565 type Value = GetMetaStoreInfoRequest;
7566
7567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7568 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7569 }
7570
7571 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7572 where
7573 V: serde::de::MapAccess<'de>,
7574 {
7575 while map_.next_key::<GeneratedField>()?.is_some() {
7576 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7577 }
7578 Ok(GetMetaStoreInfoRequest {
7579 })
7580 }
7581 }
7582 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7583 }
7584}
7585impl serde::Serialize for GetMetaStoreInfoResponse {
7586 #[allow(deprecated)]
7587 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7588 where
7589 S: serde::Serializer,
7590 {
7591 use serde::ser::SerializeStruct;
7592 let mut len = 0;
7593 if !self.meta_store_endpoint.is_empty() {
7594 len += 1;
7595 }
7596 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7597 if !self.meta_store_endpoint.is_empty() {
7598 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7599 }
7600 struct_ser.end()
7601 }
7602}
7603impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7604 #[allow(deprecated)]
7605 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7606 where
7607 D: serde::Deserializer<'de>,
7608 {
7609 const FIELDS: &[&str] = &[
7610 "meta_store_endpoint",
7611 "metaStoreEndpoint",
7612 ];
7613
7614 #[allow(clippy::enum_variant_names)]
7615 enum GeneratedField {
7616 MetaStoreEndpoint,
7617 }
7618 impl<'de> serde::Deserialize<'de> for GeneratedField {
7619 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7620 where
7621 D: serde::Deserializer<'de>,
7622 {
7623 struct GeneratedVisitor;
7624
7625 impl serde::de::Visitor<'_> for GeneratedVisitor {
7626 type Value = GeneratedField;
7627
7628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7629 write!(formatter, "expected one of: {:?}", &FIELDS)
7630 }
7631
7632 #[allow(unused_variables)]
7633 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7634 where
7635 E: serde::de::Error,
7636 {
7637 match value {
7638 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7639 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7640 }
7641 }
7642 }
7643 deserializer.deserialize_identifier(GeneratedVisitor)
7644 }
7645 }
7646 struct GeneratedVisitor;
7647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7648 type Value = GetMetaStoreInfoResponse;
7649
7650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7651 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7652 }
7653
7654 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7655 where
7656 V: serde::de::MapAccess<'de>,
7657 {
7658 let mut meta_store_endpoint__ = None;
7659 while let Some(k) = map_.next_key()? {
7660 match k {
7661 GeneratedField::MetaStoreEndpoint => {
7662 if meta_store_endpoint__.is_some() {
7663 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7664 }
7665 meta_store_endpoint__ = Some(map_.next_value()?);
7666 }
7667 }
7668 }
7669 Ok(GetMetaStoreInfoResponse {
7670 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7671 })
7672 }
7673 }
7674 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7675 }
7676}
7677impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7678 #[allow(deprecated)]
7679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7680 where
7681 S: serde::Serializer,
7682 {
7683 use serde::ser::SerializeStruct;
7684 let len = 0;
7685 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7686 struct_ser.end()
7687 }
7688}
7689impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
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 ];
7697
7698 #[allow(clippy::enum_variant_names)]
7699 enum GeneratedField {
7700 }
7701 impl<'de> serde::Deserialize<'de> for GeneratedField {
7702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7703 where
7704 D: serde::Deserializer<'de>,
7705 {
7706 struct GeneratedVisitor;
7707
7708 impl serde::de::Visitor<'_> for GeneratedVisitor {
7709 type Value = GeneratedField;
7710
7711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7712 write!(formatter, "expected one of: {:?}", &FIELDS)
7713 }
7714
7715 #[allow(unused_variables)]
7716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7717 where
7718 E: serde::de::Error,
7719 {
7720 Err(serde::de::Error::unknown_field(value, FIELDS))
7721 }
7722 }
7723 deserializer.deserialize_identifier(GeneratedVisitor)
7724 }
7725 }
7726 struct GeneratedVisitor;
7727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7728 type Value = GetServerlessStreamingJobsStatusRequest;
7729
7730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7731 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7732 }
7733
7734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7735 where
7736 V: serde::de::MapAccess<'de>,
7737 {
7738 while map_.next_key::<GeneratedField>()?.is_some() {
7739 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7740 }
7741 Ok(GetServerlessStreamingJobsStatusRequest {
7742 })
7743 }
7744 }
7745 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7746 }
7747}
7748impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
7749 #[allow(deprecated)]
7750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7751 where
7752 S: serde::Serializer,
7753 {
7754 use serde::ser::SerializeStruct;
7755 let mut len = 0;
7756 if !self.streaming_job_statuses.is_empty() {
7757 len += 1;
7758 }
7759 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7760 if !self.streaming_job_statuses.is_empty() {
7761 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7762 }
7763 struct_ser.end()
7764 }
7765}
7766impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7767 #[allow(deprecated)]
7768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7769 where
7770 D: serde::Deserializer<'de>,
7771 {
7772 const FIELDS: &[&str] = &[
7773 "streaming_job_statuses",
7774 "streamingJobStatuses",
7775 ];
7776
7777 #[allow(clippy::enum_variant_names)]
7778 enum GeneratedField {
7779 StreamingJobStatuses,
7780 }
7781 impl<'de> serde::Deserialize<'de> for GeneratedField {
7782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7783 where
7784 D: serde::Deserializer<'de>,
7785 {
7786 struct GeneratedVisitor;
7787
7788 impl serde::de::Visitor<'_> for GeneratedVisitor {
7789 type Value = GeneratedField;
7790
7791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7792 write!(formatter, "expected one of: {:?}", &FIELDS)
7793 }
7794
7795 #[allow(unused_variables)]
7796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7797 where
7798 E: serde::de::Error,
7799 {
7800 match value {
7801 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7803 }
7804 }
7805 }
7806 deserializer.deserialize_identifier(GeneratedVisitor)
7807 }
7808 }
7809 struct GeneratedVisitor;
7810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7811 type Value = GetServerlessStreamingJobsStatusResponse;
7812
7813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7814 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7815 }
7816
7817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7818 where
7819 V: serde::de::MapAccess<'de>,
7820 {
7821 let mut streaming_job_statuses__ = None;
7822 while let Some(k) = map_.next_key()? {
7823 match k {
7824 GeneratedField::StreamingJobStatuses => {
7825 if streaming_job_statuses__.is_some() {
7826 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7827 }
7828 streaming_job_statuses__ = Some(map_.next_value()?);
7829 }
7830 }
7831 }
7832 Ok(GetServerlessStreamingJobsStatusResponse {
7833 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7834 })
7835 }
7836 }
7837 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7838 }
7839}
7840impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7841 #[allow(deprecated)]
7842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7843 where
7844 S: serde::Serializer,
7845 {
7846 use serde::ser::SerializeStruct;
7847 let mut len = 0;
7848 if self.table_id != 0 {
7849 len += 1;
7850 }
7851 if !self.node_label.is_empty() {
7852 len += 1;
7853 }
7854 if self.backfill_done {
7855 len += 1;
7856 }
7857 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7858 if self.table_id != 0 {
7859 struct_ser.serialize_field("tableId", &self.table_id)?;
7860 }
7861 if !self.node_label.is_empty() {
7862 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7863 }
7864 if self.backfill_done {
7865 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7866 }
7867 struct_ser.end()
7868 }
7869}
7870impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7871 #[allow(deprecated)]
7872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7873 where
7874 D: serde::Deserializer<'de>,
7875 {
7876 const FIELDS: &[&str] = &[
7877 "table_id",
7878 "tableId",
7879 "node_label",
7880 "nodeLabel",
7881 "backfill_done",
7882 "backfillDone",
7883 ];
7884
7885 #[allow(clippy::enum_variant_names)]
7886 enum GeneratedField {
7887 TableId,
7888 NodeLabel,
7889 BackfillDone,
7890 }
7891 impl<'de> serde::Deserialize<'de> for GeneratedField {
7892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7893 where
7894 D: serde::Deserializer<'de>,
7895 {
7896 struct GeneratedVisitor;
7897
7898 impl serde::de::Visitor<'_> for GeneratedVisitor {
7899 type Value = GeneratedField;
7900
7901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7902 write!(formatter, "expected one of: {:?}", &FIELDS)
7903 }
7904
7905 #[allow(unused_variables)]
7906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7907 where
7908 E: serde::de::Error,
7909 {
7910 match value {
7911 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7912 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7913 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7914 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7915 }
7916 }
7917 }
7918 deserializer.deserialize_identifier(GeneratedVisitor)
7919 }
7920 }
7921 struct GeneratedVisitor;
7922 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7923 type Value = get_serverless_streaming_jobs_status_response::Status;
7924
7925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7926 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7927 }
7928
7929 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7930 where
7931 V: serde::de::MapAccess<'de>,
7932 {
7933 let mut table_id__ = None;
7934 let mut node_label__ = None;
7935 let mut backfill_done__ = None;
7936 while let Some(k) = map_.next_key()? {
7937 match k {
7938 GeneratedField::TableId => {
7939 if table_id__.is_some() {
7940 return Err(serde::de::Error::duplicate_field("tableId"));
7941 }
7942 table_id__ =
7943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7944 ;
7945 }
7946 GeneratedField::NodeLabel => {
7947 if node_label__.is_some() {
7948 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7949 }
7950 node_label__ = Some(map_.next_value()?);
7951 }
7952 GeneratedField::BackfillDone => {
7953 if backfill_done__.is_some() {
7954 return Err(serde::de::Error::duplicate_field("backfillDone"));
7955 }
7956 backfill_done__ = Some(map_.next_value()?);
7957 }
7958 }
7959 }
7960 Ok(get_serverless_streaming_jobs_status_response::Status {
7961 table_id: table_id__.unwrap_or_default(),
7962 node_label: node_label__.unwrap_or_default(),
7963 backfill_done: backfill_done__.unwrap_or_default(),
7964 })
7965 }
7966 }
7967 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7968 }
7969}
7970impl serde::Serialize for GetServingVnodeMappingsRequest {
7971 #[allow(deprecated)]
7972 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7973 where
7974 S: serde::Serializer,
7975 {
7976 use serde::ser::SerializeStruct;
7977 let len = 0;
7978 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7979 struct_ser.end()
7980 }
7981}
7982impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7983 #[allow(deprecated)]
7984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7985 where
7986 D: serde::Deserializer<'de>,
7987 {
7988 const FIELDS: &[&str] = &[
7989 ];
7990
7991 #[allow(clippy::enum_variant_names)]
7992 enum GeneratedField {
7993 }
7994 impl<'de> serde::Deserialize<'de> for GeneratedField {
7995 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7996 where
7997 D: serde::Deserializer<'de>,
7998 {
7999 struct GeneratedVisitor;
8000
8001 impl serde::de::Visitor<'_> for GeneratedVisitor {
8002 type Value = GeneratedField;
8003
8004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8005 write!(formatter, "expected one of: {:?}", &FIELDS)
8006 }
8007
8008 #[allow(unused_variables)]
8009 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8010 where
8011 E: serde::de::Error,
8012 {
8013 Err(serde::de::Error::unknown_field(value, FIELDS))
8014 }
8015 }
8016 deserializer.deserialize_identifier(GeneratedVisitor)
8017 }
8018 }
8019 struct GeneratedVisitor;
8020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8021 type Value = GetServingVnodeMappingsRequest;
8022
8023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8024 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
8025 }
8026
8027 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
8028 where
8029 V: serde::de::MapAccess<'de>,
8030 {
8031 while map_.next_key::<GeneratedField>()?.is_some() {
8032 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8033 }
8034 Ok(GetServingVnodeMappingsRequest {
8035 })
8036 }
8037 }
8038 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
8039 }
8040}
8041impl serde::Serialize for GetServingVnodeMappingsResponse {
8042 #[allow(deprecated)]
8043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8044 where
8045 S: serde::Serializer,
8046 {
8047 use serde::ser::SerializeStruct;
8048 let mut len = 0;
8049 if !self.fragment_to_table.is_empty() {
8050 len += 1;
8051 }
8052 if !self.worker_slot_mappings.is_empty() {
8053 len += 1;
8054 }
8055 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
8056 if !self.fragment_to_table.is_empty() {
8057 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
8058 }
8059 if !self.worker_slot_mappings.is_empty() {
8060 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
8061 }
8062 struct_ser.end()
8063 }
8064}
8065impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
8066 #[allow(deprecated)]
8067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8068 where
8069 D: serde::Deserializer<'de>,
8070 {
8071 const FIELDS: &[&str] = &[
8072 "fragment_to_table",
8073 "fragmentToTable",
8074 "worker_slot_mappings",
8075 "workerSlotMappings",
8076 ];
8077
8078 #[allow(clippy::enum_variant_names)]
8079 enum GeneratedField {
8080 FragmentToTable,
8081 WorkerSlotMappings,
8082 }
8083 impl<'de> serde::Deserialize<'de> for GeneratedField {
8084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8085 where
8086 D: serde::Deserializer<'de>,
8087 {
8088 struct GeneratedVisitor;
8089
8090 impl serde::de::Visitor<'_> for GeneratedVisitor {
8091 type Value = GeneratedField;
8092
8093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8094 write!(formatter, "expected one of: {:?}", &FIELDS)
8095 }
8096
8097 #[allow(unused_variables)]
8098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8099 where
8100 E: serde::de::Error,
8101 {
8102 match value {
8103 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
8104 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
8105 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8106 }
8107 }
8108 }
8109 deserializer.deserialize_identifier(GeneratedVisitor)
8110 }
8111 }
8112 struct GeneratedVisitor;
8113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8114 type Value = GetServingVnodeMappingsResponse;
8115
8116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8117 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
8118 }
8119
8120 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
8121 where
8122 V: serde::de::MapAccess<'de>,
8123 {
8124 let mut fragment_to_table__ = None;
8125 let mut worker_slot_mappings__ = None;
8126 while let Some(k) = map_.next_key()? {
8127 match k {
8128 GeneratedField::FragmentToTable => {
8129 if fragment_to_table__.is_some() {
8130 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
8131 }
8132 fragment_to_table__ = Some(
8133 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
8134 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
8135 );
8136 }
8137 GeneratedField::WorkerSlotMappings => {
8138 if worker_slot_mappings__.is_some() {
8139 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
8140 }
8141 worker_slot_mappings__ = Some(map_.next_value()?);
8142 }
8143 }
8144 }
8145 Ok(GetServingVnodeMappingsResponse {
8146 fragment_to_table: fragment_to_table__.unwrap_or_default(),
8147 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
8148 })
8149 }
8150 }
8151 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
8152 }
8153}
8154impl serde::Serialize for GetSessionParamsRequest {
8155 #[allow(deprecated)]
8156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8157 where
8158 S: serde::Serializer,
8159 {
8160 use serde::ser::SerializeStruct;
8161 let len = 0;
8162 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
8163 struct_ser.end()
8164 }
8165}
8166impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
8167 #[allow(deprecated)]
8168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8169 where
8170 D: serde::Deserializer<'de>,
8171 {
8172 const FIELDS: &[&str] = &[
8173 ];
8174
8175 #[allow(clippy::enum_variant_names)]
8176 enum GeneratedField {
8177 }
8178 impl<'de> serde::Deserialize<'de> for GeneratedField {
8179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8180 where
8181 D: serde::Deserializer<'de>,
8182 {
8183 struct GeneratedVisitor;
8184
8185 impl serde::de::Visitor<'_> for GeneratedVisitor {
8186 type Value = GeneratedField;
8187
8188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8189 write!(formatter, "expected one of: {:?}", &FIELDS)
8190 }
8191
8192 #[allow(unused_variables)]
8193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8194 where
8195 E: serde::de::Error,
8196 {
8197 Err(serde::de::Error::unknown_field(value, FIELDS))
8198 }
8199 }
8200 deserializer.deserialize_identifier(GeneratedVisitor)
8201 }
8202 }
8203 struct GeneratedVisitor;
8204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8205 type Value = GetSessionParamsRequest;
8206
8207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8208 formatter.write_str("struct meta.GetSessionParamsRequest")
8209 }
8210
8211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
8212 where
8213 V: serde::de::MapAccess<'de>,
8214 {
8215 while map_.next_key::<GeneratedField>()?.is_some() {
8216 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8217 }
8218 Ok(GetSessionParamsRequest {
8219 })
8220 }
8221 }
8222 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
8223 }
8224}
8225impl serde::Serialize for GetSessionParamsResponse {
8226 #[allow(deprecated)]
8227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8228 where
8229 S: serde::Serializer,
8230 {
8231 use serde::ser::SerializeStruct;
8232 let mut len = 0;
8233 if !self.params.is_empty() {
8234 len += 1;
8235 }
8236 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
8237 if !self.params.is_empty() {
8238 struct_ser.serialize_field("params", &self.params)?;
8239 }
8240 struct_ser.end()
8241 }
8242}
8243impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
8244 #[allow(deprecated)]
8245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8246 where
8247 D: serde::Deserializer<'de>,
8248 {
8249 const FIELDS: &[&str] = &[
8250 "params",
8251 ];
8252
8253 #[allow(clippy::enum_variant_names)]
8254 enum GeneratedField {
8255 Params,
8256 }
8257 impl<'de> serde::Deserialize<'de> for GeneratedField {
8258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8259 where
8260 D: serde::Deserializer<'de>,
8261 {
8262 struct GeneratedVisitor;
8263
8264 impl serde::de::Visitor<'_> for GeneratedVisitor {
8265 type Value = GeneratedField;
8266
8267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8268 write!(formatter, "expected one of: {:?}", &FIELDS)
8269 }
8270
8271 #[allow(unused_variables)]
8272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8273 where
8274 E: serde::de::Error,
8275 {
8276 match value {
8277 "params" => Ok(GeneratedField::Params),
8278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8279 }
8280 }
8281 }
8282 deserializer.deserialize_identifier(GeneratedVisitor)
8283 }
8284 }
8285 struct GeneratedVisitor;
8286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8287 type Value = GetSessionParamsResponse;
8288
8289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8290 formatter.write_str("struct meta.GetSessionParamsResponse")
8291 }
8292
8293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
8294 where
8295 V: serde::de::MapAccess<'de>,
8296 {
8297 let mut params__ = None;
8298 while let Some(k) = map_.next_key()? {
8299 match k {
8300 GeneratedField::Params => {
8301 if params__.is_some() {
8302 return Err(serde::de::Error::duplicate_field("params"));
8303 }
8304 params__ = Some(map_.next_value()?);
8305 }
8306 }
8307 }
8308 Ok(GetSessionParamsResponse {
8309 params: params__.unwrap_or_default(),
8310 })
8311 }
8312 }
8313 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
8314 }
8315}
8316impl serde::Serialize for GetSystemParamsRequest {
8317 #[allow(deprecated)]
8318 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8319 where
8320 S: serde::Serializer,
8321 {
8322 use serde::ser::SerializeStruct;
8323 let len = 0;
8324 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
8325 struct_ser.end()
8326 }
8327}
8328impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
8329 #[allow(deprecated)]
8330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8331 where
8332 D: serde::Deserializer<'de>,
8333 {
8334 const FIELDS: &[&str] = &[
8335 ];
8336
8337 #[allow(clippy::enum_variant_names)]
8338 enum GeneratedField {
8339 }
8340 impl<'de> serde::Deserialize<'de> for GeneratedField {
8341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8342 where
8343 D: serde::Deserializer<'de>,
8344 {
8345 struct GeneratedVisitor;
8346
8347 impl serde::de::Visitor<'_> for GeneratedVisitor {
8348 type Value = GeneratedField;
8349
8350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8351 write!(formatter, "expected one of: {:?}", &FIELDS)
8352 }
8353
8354 #[allow(unused_variables)]
8355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8356 where
8357 E: serde::de::Error,
8358 {
8359 Err(serde::de::Error::unknown_field(value, FIELDS))
8360 }
8361 }
8362 deserializer.deserialize_identifier(GeneratedVisitor)
8363 }
8364 }
8365 struct GeneratedVisitor;
8366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8367 type Value = GetSystemParamsRequest;
8368
8369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8370 formatter.write_str("struct meta.GetSystemParamsRequest")
8371 }
8372
8373 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
8374 where
8375 V: serde::de::MapAccess<'de>,
8376 {
8377 while map_.next_key::<GeneratedField>()?.is_some() {
8378 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8379 }
8380 Ok(GetSystemParamsRequest {
8381 })
8382 }
8383 }
8384 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
8385 }
8386}
8387impl serde::Serialize for GetSystemParamsResponse {
8388 #[allow(deprecated)]
8389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8390 where
8391 S: serde::Serializer,
8392 {
8393 use serde::ser::SerializeStruct;
8394 let mut len = 0;
8395 if self.params.is_some() {
8396 len += 1;
8397 }
8398 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
8399 if let Some(v) = self.params.as_ref() {
8400 struct_ser.serialize_field("params", v)?;
8401 }
8402 struct_ser.end()
8403 }
8404}
8405impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
8406 #[allow(deprecated)]
8407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8408 where
8409 D: serde::Deserializer<'de>,
8410 {
8411 const FIELDS: &[&str] = &[
8412 "params",
8413 ];
8414
8415 #[allow(clippy::enum_variant_names)]
8416 enum GeneratedField {
8417 Params,
8418 }
8419 impl<'de> serde::Deserialize<'de> for GeneratedField {
8420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8421 where
8422 D: serde::Deserializer<'de>,
8423 {
8424 struct GeneratedVisitor;
8425
8426 impl serde::de::Visitor<'_> for GeneratedVisitor {
8427 type Value = GeneratedField;
8428
8429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8430 write!(formatter, "expected one of: {:?}", &FIELDS)
8431 }
8432
8433 #[allow(unused_variables)]
8434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8435 where
8436 E: serde::de::Error,
8437 {
8438 match value {
8439 "params" => Ok(GeneratedField::Params),
8440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8441 }
8442 }
8443 }
8444 deserializer.deserialize_identifier(GeneratedVisitor)
8445 }
8446 }
8447 struct GeneratedVisitor;
8448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8449 type Value = GetSystemParamsResponse;
8450
8451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8452 formatter.write_str("struct meta.GetSystemParamsResponse")
8453 }
8454
8455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8456 where
8457 V: serde::de::MapAccess<'de>,
8458 {
8459 let mut params__ = None;
8460 while let Some(k) = map_.next_key()? {
8461 match k {
8462 GeneratedField::Params => {
8463 if params__.is_some() {
8464 return Err(serde::de::Error::duplicate_field("params"));
8465 }
8466 params__ = map_.next_value()?;
8467 }
8468 }
8469 }
8470 Ok(GetSystemParamsResponse {
8471 params: params__,
8472 })
8473 }
8474 }
8475 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8476 }
8477}
8478impl serde::Serialize for GetTelemetryInfoRequest {
8479 #[allow(deprecated)]
8480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8481 where
8482 S: serde::Serializer,
8483 {
8484 use serde::ser::SerializeStruct;
8485 let len = 0;
8486 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8487 struct_ser.end()
8488 }
8489}
8490impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8491 #[allow(deprecated)]
8492 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8493 where
8494 D: serde::Deserializer<'de>,
8495 {
8496 const FIELDS: &[&str] = &[
8497 ];
8498
8499 #[allow(clippy::enum_variant_names)]
8500 enum GeneratedField {
8501 }
8502 impl<'de> serde::Deserialize<'de> for GeneratedField {
8503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8504 where
8505 D: serde::Deserializer<'de>,
8506 {
8507 struct GeneratedVisitor;
8508
8509 impl serde::de::Visitor<'_> for GeneratedVisitor {
8510 type Value = GeneratedField;
8511
8512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8513 write!(formatter, "expected one of: {:?}", &FIELDS)
8514 }
8515
8516 #[allow(unused_variables)]
8517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8518 where
8519 E: serde::de::Error,
8520 {
8521 Err(serde::de::Error::unknown_field(value, FIELDS))
8522 }
8523 }
8524 deserializer.deserialize_identifier(GeneratedVisitor)
8525 }
8526 }
8527 struct GeneratedVisitor;
8528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8529 type Value = GetTelemetryInfoRequest;
8530
8531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8532 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8533 }
8534
8535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8536 where
8537 V: serde::de::MapAccess<'de>,
8538 {
8539 while map_.next_key::<GeneratedField>()?.is_some() {
8540 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8541 }
8542 Ok(GetTelemetryInfoRequest {
8543 })
8544 }
8545 }
8546 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8547 }
8548}
8549impl serde::Serialize for HeartbeatRequest {
8550 #[allow(deprecated)]
8551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8552 where
8553 S: serde::Serializer,
8554 {
8555 use serde::ser::SerializeStruct;
8556 let mut len = 0;
8557 if self.node_id != 0 {
8558 len += 1;
8559 }
8560 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8561 if self.node_id != 0 {
8562 struct_ser.serialize_field("nodeId", &self.node_id)?;
8563 }
8564 struct_ser.end()
8565 }
8566}
8567impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8568 #[allow(deprecated)]
8569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8570 where
8571 D: serde::Deserializer<'de>,
8572 {
8573 const FIELDS: &[&str] = &[
8574 "node_id",
8575 "nodeId",
8576 ];
8577
8578 #[allow(clippy::enum_variant_names)]
8579 enum GeneratedField {
8580 NodeId,
8581 }
8582 impl<'de> serde::Deserialize<'de> for GeneratedField {
8583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8584 where
8585 D: serde::Deserializer<'de>,
8586 {
8587 struct GeneratedVisitor;
8588
8589 impl serde::de::Visitor<'_> for GeneratedVisitor {
8590 type Value = GeneratedField;
8591
8592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8593 write!(formatter, "expected one of: {:?}", &FIELDS)
8594 }
8595
8596 #[allow(unused_variables)]
8597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8598 where
8599 E: serde::de::Error,
8600 {
8601 match value {
8602 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8604 }
8605 }
8606 }
8607 deserializer.deserialize_identifier(GeneratedVisitor)
8608 }
8609 }
8610 struct GeneratedVisitor;
8611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8612 type Value = HeartbeatRequest;
8613
8614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8615 formatter.write_str("struct meta.HeartbeatRequest")
8616 }
8617
8618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8619 where
8620 V: serde::de::MapAccess<'de>,
8621 {
8622 let mut node_id__ = None;
8623 while let Some(k) = map_.next_key()? {
8624 match k {
8625 GeneratedField::NodeId => {
8626 if node_id__.is_some() {
8627 return Err(serde::de::Error::duplicate_field("nodeId"));
8628 }
8629 node_id__ =
8630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8631 ;
8632 }
8633 }
8634 }
8635 Ok(HeartbeatRequest {
8636 node_id: node_id__.unwrap_or_default(),
8637 })
8638 }
8639 }
8640 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8641 }
8642}
8643impl serde::Serialize for HeartbeatResponse {
8644 #[allow(deprecated)]
8645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8646 where
8647 S: serde::Serializer,
8648 {
8649 use serde::ser::SerializeStruct;
8650 let mut len = 0;
8651 if self.status.is_some() {
8652 len += 1;
8653 }
8654 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8655 if let Some(v) = self.status.as_ref() {
8656 struct_ser.serialize_field("status", v)?;
8657 }
8658 struct_ser.end()
8659 }
8660}
8661impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8662 #[allow(deprecated)]
8663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8664 where
8665 D: serde::Deserializer<'de>,
8666 {
8667 const FIELDS: &[&str] = &[
8668 "status",
8669 ];
8670
8671 #[allow(clippy::enum_variant_names)]
8672 enum GeneratedField {
8673 Status,
8674 }
8675 impl<'de> serde::Deserialize<'de> for GeneratedField {
8676 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8677 where
8678 D: serde::Deserializer<'de>,
8679 {
8680 struct GeneratedVisitor;
8681
8682 impl serde::de::Visitor<'_> for GeneratedVisitor {
8683 type Value = GeneratedField;
8684
8685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8686 write!(formatter, "expected one of: {:?}", &FIELDS)
8687 }
8688
8689 #[allow(unused_variables)]
8690 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8691 where
8692 E: serde::de::Error,
8693 {
8694 match value {
8695 "status" => Ok(GeneratedField::Status),
8696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8697 }
8698 }
8699 }
8700 deserializer.deserialize_identifier(GeneratedVisitor)
8701 }
8702 }
8703 struct GeneratedVisitor;
8704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8705 type Value = HeartbeatResponse;
8706
8707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8708 formatter.write_str("struct meta.HeartbeatResponse")
8709 }
8710
8711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8712 where
8713 V: serde::de::MapAccess<'de>,
8714 {
8715 let mut status__ = None;
8716 while let Some(k) = map_.next_key()? {
8717 match k {
8718 GeneratedField::Status => {
8719 if status__.is_some() {
8720 return Err(serde::de::Error::duplicate_field("status"));
8721 }
8722 status__ = map_.next_value()?;
8723 }
8724 }
8725 }
8726 Ok(HeartbeatResponse {
8727 status: status__,
8728 })
8729 }
8730 }
8731 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8732 }
8733}
8734impl serde::Serialize for InjectSourceOffsetsRequest {
8735 #[allow(deprecated)]
8736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8737 where
8738 S: serde::Serializer,
8739 {
8740 use serde::ser::SerializeStruct;
8741 let mut len = 0;
8742 if self.source_id != 0 {
8743 len += 1;
8744 }
8745 if !self.split_offsets.is_empty() {
8746 len += 1;
8747 }
8748 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsRequest", len)?;
8749 if self.source_id != 0 {
8750 struct_ser.serialize_field("sourceId", &self.source_id)?;
8751 }
8752 if !self.split_offsets.is_empty() {
8753 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
8754 }
8755 struct_ser.end()
8756 }
8757}
8758impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsRequest {
8759 #[allow(deprecated)]
8760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8761 where
8762 D: serde::Deserializer<'de>,
8763 {
8764 const FIELDS: &[&str] = &[
8765 "source_id",
8766 "sourceId",
8767 "split_offsets",
8768 "splitOffsets",
8769 ];
8770
8771 #[allow(clippy::enum_variant_names)]
8772 enum GeneratedField {
8773 SourceId,
8774 SplitOffsets,
8775 }
8776 impl<'de> serde::Deserialize<'de> for GeneratedField {
8777 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8778 where
8779 D: serde::Deserializer<'de>,
8780 {
8781 struct GeneratedVisitor;
8782
8783 impl serde::de::Visitor<'_> for GeneratedVisitor {
8784 type Value = GeneratedField;
8785
8786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8787 write!(formatter, "expected one of: {:?}", &FIELDS)
8788 }
8789
8790 #[allow(unused_variables)]
8791 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8792 where
8793 E: serde::de::Error,
8794 {
8795 match value {
8796 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8797 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
8798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8799 }
8800 }
8801 }
8802 deserializer.deserialize_identifier(GeneratedVisitor)
8803 }
8804 }
8805 struct GeneratedVisitor;
8806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8807 type Value = InjectSourceOffsetsRequest;
8808
8809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8810 formatter.write_str("struct meta.InjectSourceOffsetsRequest")
8811 }
8812
8813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsRequest, V::Error>
8814 where
8815 V: serde::de::MapAccess<'de>,
8816 {
8817 let mut source_id__ = None;
8818 let mut split_offsets__ = None;
8819 while let Some(k) = map_.next_key()? {
8820 match k {
8821 GeneratedField::SourceId => {
8822 if source_id__.is_some() {
8823 return Err(serde::de::Error::duplicate_field("sourceId"));
8824 }
8825 source_id__ =
8826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8827 ;
8828 }
8829 GeneratedField::SplitOffsets => {
8830 if split_offsets__.is_some() {
8831 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8832 }
8833 split_offsets__ = Some(
8834 map_.next_value::<std::collections::HashMap<_, _>>()?
8835 );
8836 }
8837 }
8838 }
8839 Ok(InjectSourceOffsetsRequest {
8840 source_id: source_id__.unwrap_or_default(),
8841 split_offsets: split_offsets__.unwrap_or_default(),
8842 })
8843 }
8844 }
8845 deserializer.deserialize_struct("meta.InjectSourceOffsetsRequest", FIELDS, GeneratedVisitor)
8846 }
8847}
8848impl serde::Serialize for InjectSourceOffsetsResponse {
8849 #[allow(deprecated)]
8850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8851 where
8852 S: serde::Serializer,
8853 {
8854 use serde::ser::SerializeStruct;
8855 let mut len = 0;
8856 if !self.applied_split_ids.is_empty() {
8857 len += 1;
8858 }
8859 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsResponse", len)?;
8860 if !self.applied_split_ids.is_empty() {
8861 struct_ser.serialize_field("appliedSplitIds", &self.applied_split_ids)?;
8862 }
8863 struct_ser.end()
8864 }
8865}
8866impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsResponse {
8867 #[allow(deprecated)]
8868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8869 where
8870 D: serde::Deserializer<'de>,
8871 {
8872 const FIELDS: &[&str] = &[
8873 "applied_split_ids",
8874 "appliedSplitIds",
8875 ];
8876
8877 #[allow(clippy::enum_variant_names)]
8878 enum GeneratedField {
8879 AppliedSplitIds,
8880 }
8881 impl<'de> serde::Deserialize<'de> for GeneratedField {
8882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8883 where
8884 D: serde::Deserializer<'de>,
8885 {
8886 struct GeneratedVisitor;
8887
8888 impl serde::de::Visitor<'_> for GeneratedVisitor {
8889 type Value = GeneratedField;
8890
8891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8892 write!(formatter, "expected one of: {:?}", &FIELDS)
8893 }
8894
8895 #[allow(unused_variables)]
8896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8897 where
8898 E: serde::de::Error,
8899 {
8900 match value {
8901 "appliedSplitIds" | "applied_split_ids" => Ok(GeneratedField::AppliedSplitIds),
8902 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8903 }
8904 }
8905 }
8906 deserializer.deserialize_identifier(GeneratedVisitor)
8907 }
8908 }
8909 struct GeneratedVisitor;
8910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8911 type Value = InjectSourceOffsetsResponse;
8912
8913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8914 formatter.write_str("struct meta.InjectSourceOffsetsResponse")
8915 }
8916
8917 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsResponse, V::Error>
8918 where
8919 V: serde::de::MapAccess<'de>,
8920 {
8921 let mut applied_split_ids__ = None;
8922 while let Some(k) = map_.next_key()? {
8923 match k {
8924 GeneratedField::AppliedSplitIds => {
8925 if applied_split_ids__.is_some() {
8926 return Err(serde::de::Error::duplicate_field("appliedSplitIds"));
8927 }
8928 applied_split_ids__ = Some(map_.next_value()?);
8929 }
8930 }
8931 }
8932 Ok(InjectSourceOffsetsResponse {
8933 applied_split_ids: applied_split_ids__.unwrap_or_default(),
8934 })
8935 }
8936 }
8937 deserializer.deserialize_struct("meta.InjectSourceOffsetsResponse", FIELDS, GeneratedVisitor)
8938 }
8939}
8940impl serde::Serialize for ListActorSplitsRequest {
8941 #[allow(deprecated)]
8942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8943 where
8944 S: serde::Serializer,
8945 {
8946 use serde::ser::SerializeStruct;
8947 let len = 0;
8948 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8949 struct_ser.end()
8950 }
8951}
8952impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8953 #[allow(deprecated)]
8954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8955 where
8956 D: serde::Deserializer<'de>,
8957 {
8958 const FIELDS: &[&str] = &[
8959 ];
8960
8961 #[allow(clippy::enum_variant_names)]
8962 enum GeneratedField {
8963 }
8964 impl<'de> serde::Deserialize<'de> for GeneratedField {
8965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8966 where
8967 D: serde::Deserializer<'de>,
8968 {
8969 struct GeneratedVisitor;
8970
8971 impl serde::de::Visitor<'_> for GeneratedVisitor {
8972 type Value = GeneratedField;
8973
8974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8975 write!(formatter, "expected one of: {:?}", &FIELDS)
8976 }
8977
8978 #[allow(unused_variables)]
8979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8980 where
8981 E: serde::de::Error,
8982 {
8983 Err(serde::de::Error::unknown_field(value, FIELDS))
8984 }
8985 }
8986 deserializer.deserialize_identifier(GeneratedVisitor)
8987 }
8988 }
8989 struct GeneratedVisitor;
8990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8991 type Value = ListActorSplitsRequest;
8992
8993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8994 formatter.write_str("struct meta.ListActorSplitsRequest")
8995 }
8996
8997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8998 where
8999 V: serde::de::MapAccess<'de>,
9000 {
9001 while map_.next_key::<GeneratedField>()?.is_some() {
9002 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9003 }
9004 Ok(ListActorSplitsRequest {
9005 })
9006 }
9007 }
9008 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
9009 }
9010}
9011impl serde::Serialize for ListActorSplitsResponse {
9012 #[allow(deprecated)]
9013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9014 where
9015 S: serde::Serializer,
9016 {
9017 use serde::ser::SerializeStruct;
9018 let mut len = 0;
9019 if !self.actor_splits.is_empty() {
9020 len += 1;
9021 }
9022 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
9023 if !self.actor_splits.is_empty() {
9024 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9025 }
9026 struct_ser.end()
9027 }
9028}
9029impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
9030 #[allow(deprecated)]
9031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9032 where
9033 D: serde::Deserializer<'de>,
9034 {
9035 const FIELDS: &[&str] = &[
9036 "actor_splits",
9037 "actorSplits",
9038 ];
9039
9040 #[allow(clippy::enum_variant_names)]
9041 enum GeneratedField {
9042 ActorSplits,
9043 }
9044 impl<'de> serde::Deserialize<'de> for GeneratedField {
9045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9046 where
9047 D: serde::Deserializer<'de>,
9048 {
9049 struct GeneratedVisitor;
9050
9051 impl serde::de::Visitor<'_> for GeneratedVisitor {
9052 type Value = GeneratedField;
9053
9054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9055 write!(formatter, "expected one of: {:?}", &FIELDS)
9056 }
9057
9058 #[allow(unused_variables)]
9059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9060 where
9061 E: serde::de::Error,
9062 {
9063 match value {
9064 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9066 }
9067 }
9068 }
9069 deserializer.deserialize_identifier(GeneratedVisitor)
9070 }
9071 }
9072 struct GeneratedVisitor;
9073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9074 type Value = ListActorSplitsResponse;
9075
9076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9077 formatter.write_str("struct meta.ListActorSplitsResponse")
9078 }
9079
9080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
9081 where
9082 V: serde::de::MapAccess<'de>,
9083 {
9084 let mut actor_splits__ = None;
9085 while let Some(k) = map_.next_key()? {
9086 match k {
9087 GeneratedField::ActorSplits => {
9088 if actor_splits__.is_some() {
9089 return Err(serde::de::Error::duplicate_field("actorSplits"));
9090 }
9091 actor_splits__ = Some(map_.next_value()?);
9092 }
9093 }
9094 }
9095 Ok(ListActorSplitsResponse {
9096 actor_splits: actor_splits__.unwrap_or_default(),
9097 })
9098 }
9099 }
9100 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
9101 }
9102}
9103impl serde::Serialize for list_actor_splits_response::ActorSplit {
9104 #[allow(deprecated)]
9105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9106 where
9107 S: serde::Serializer,
9108 {
9109 use serde::ser::SerializeStruct;
9110 let mut len = 0;
9111 if self.actor_id != 0 {
9112 len += 1;
9113 }
9114 if self.fragment_id != 0 {
9115 len += 1;
9116 }
9117 if self.source_id != 0 {
9118 len += 1;
9119 }
9120 if !self.split_id.is_empty() {
9121 len += 1;
9122 }
9123 if self.fragment_type != 0 {
9124 len += 1;
9125 }
9126 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
9127 if self.actor_id != 0 {
9128 struct_ser.serialize_field("actorId", &self.actor_id)?;
9129 }
9130 if self.fragment_id != 0 {
9131 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9132 }
9133 if self.source_id != 0 {
9134 struct_ser.serialize_field("sourceId", &self.source_id)?;
9135 }
9136 if !self.split_id.is_empty() {
9137 struct_ser.serialize_field("splitId", &self.split_id)?;
9138 }
9139 if self.fragment_type != 0 {
9140 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
9141 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
9142 struct_ser.serialize_field("fragmentType", &v)?;
9143 }
9144 struct_ser.end()
9145 }
9146}
9147impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
9148 #[allow(deprecated)]
9149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9150 where
9151 D: serde::Deserializer<'de>,
9152 {
9153 const FIELDS: &[&str] = &[
9154 "actor_id",
9155 "actorId",
9156 "fragment_id",
9157 "fragmentId",
9158 "source_id",
9159 "sourceId",
9160 "split_id",
9161 "splitId",
9162 "fragment_type",
9163 "fragmentType",
9164 ];
9165
9166 #[allow(clippy::enum_variant_names)]
9167 enum GeneratedField {
9168 ActorId,
9169 FragmentId,
9170 SourceId,
9171 SplitId,
9172 FragmentType,
9173 }
9174 impl<'de> serde::Deserialize<'de> for GeneratedField {
9175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9176 where
9177 D: serde::Deserializer<'de>,
9178 {
9179 struct GeneratedVisitor;
9180
9181 impl serde::de::Visitor<'_> for GeneratedVisitor {
9182 type Value = GeneratedField;
9183
9184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9185 write!(formatter, "expected one of: {:?}", &FIELDS)
9186 }
9187
9188 #[allow(unused_variables)]
9189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9190 where
9191 E: serde::de::Error,
9192 {
9193 match value {
9194 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9195 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9196 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9197 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
9198 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
9199 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9200 }
9201 }
9202 }
9203 deserializer.deserialize_identifier(GeneratedVisitor)
9204 }
9205 }
9206 struct GeneratedVisitor;
9207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9208 type Value = list_actor_splits_response::ActorSplit;
9209
9210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9211 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
9212 }
9213
9214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
9215 where
9216 V: serde::de::MapAccess<'de>,
9217 {
9218 let mut actor_id__ = None;
9219 let mut fragment_id__ = None;
9220 let mut source_id__ = None;
9221 let mut split_id__ = None;
9222 let mut fragment_type__ = None;
9223 while let Some(k) = map_.next_key()? {
9224 match k {
9225 GeneratedField::ActorId => {
9226 if actor_id__.is_some() {
9227 return Err(serde::de::Error::duplicate_field("actorId"));
9228 }
9229 actor_id__ =
9230 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9231 ;
9232 }
9233 GeneratedField::FragmentId => {
9234 if fragment_id__.is_some() {
9235 return Err(serde::de::Error::duplicate_field("fragmentId"));
9236 }
9237 fragment_id__ =
9238 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9239 ;
9240 }
9241 GeneratedField::SourceId => {
9242 if source_id__.is_some() {
9243 return Err(serde::de::Error::duplicate_field("sourceId"));
9244 }
9245 source_id__ =
9246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9247 ;
9248 }
9249 GeneratedField::SplitId => {
9250 if split_id__.is_some() {
9251 return Err(serde::de::Error::duplicate_field("splitId"));
9252 }
9253 split_id__ = Some(map_.next_value()?);
9254 }
9255 GeneratedField::FragmentType => {
9256 if fragment_type__.is_some() {
9257 return Err(serde::de::Error::duplicate_field("fragmentType"));
9258 }
9259 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
9260 }
9261 }
9262 }
9263 Ok(list_actor_splits_response::ActorSplit {
9264 actor_id: actor_id__.unwrap_or_default(),
9265 fragment_id: fragment_id__.unwrap_or_default(),
9266 source_id: source_id__.unwrap_or_default(),
9267 split_id: split_id__.unwrap_or_default(),
9268 fragment_type: fragment_type__.unwrap_or_default(),
9269 })
9270 }
9271 }
9272 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
9273 }
9274}
9275impl serde::Serialize for list_actor_splits_response::FragmentType {
9276 #[allow(deprecated)]
9277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9278 where
9279 S: serde::Serializer,
9280 {
9281 let variant = match self {
9282 Self::Unspecified => "UNSPECIFIED",
9283 Self::NonSharedSource => "NON_SHARED_SOURCE",
9284 Self::SharedSource => "SHARED_SOURCE",
9285 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
9286 };
9287 serializer.serialize_str(variant)
9288 }
9289}
9290impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
9291 #[allow(deprecated)]
9292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9293 where
9294 D: serde::Deserializer<'de>,
9295 {
9296 const FIELDS: &[&str] = &[
9297 "UNSPECIFIED",
9298 "NON_SHARED_SOURCE",
9299 "SHARED_SOURCE",
9300 "SHARED_SOURCE_BACKFILL",
9301 ];
9302
9303 struct GeneratedVisitor;
9304
9305 impl serde::de::Visitor<'_> for GeneratedVisitor {
9306 type Value = list_actor_splits_response::FragmentType;
9307
9308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9309 write!(formatter, "expected one of: {:?}", &FIELDS)
9310 }
9311
9312 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9313 where
9314 E: serde::de::Error,
9315 {
9316 i32::try_from(v)
9317 .ok()
9318 .and_then(|x| x.try_into().ok())
9319 .ok_or_else(|| {
9320 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9321 })
9322 }
9323
9324 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9325 where
9326 E: serde::de::Error,
9327 {
9328 i32::try_from(v)
9329 .ok()
9330 .and_then(|x| x.try_into().ok())
9331 .ok_or_else(|| {
9332 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9333 })
9334 }
9335
9336 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9337 where
9338 E: serde::de::Error,
9339 {
9340 match value {
9341 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
9342 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
9343 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
9344 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
9345 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9346 }
9347 }
9348 }
9349 deserializer.deserialize_any(GeneratedVisitor)
9350 }
9351}
9352impl serde::Serialize for ListActorStatesRequest {
9353 #[allow(deprecated)]
9354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9355 where
9356 S: serde::Serializer,
9357 {
9358 use serde::ser::SerializeStruct;
9359 let len = 0;
9360 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
9361 struct_ser.end()
9362 }
9363}
9364impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
9365 #[allow(deprecated)]
9366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9367 where
9368 D: serde::Deserializer<'de>,
9369 {
9370 const FIELDS: &[&str] = &[
9371 ];
9372
9373 #[allow(clippy::enum_variant_names)]
9374 enum GeneratedField {
9375 }
9376 impl<'de> serde::Deserialize<'de> for GeneratedField {
9377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9378 where
9379 D: serde::Deserializer<'de>,
9380 {
9381 struct GeneratedVisitor;
9382
9383 impl serde::de::Visitor<'_> for GeneratedVisitor {
9384 type Value = GeneratedField;
9385
9386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9387 write!(formatter, "expected one of: {:?}", &FIELDS)
9388 }
9389
9390 #[allow(unused_variables)]
9391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9392 where
9393 E: serde::de::Error,
9394 {
9395 Err(serde::de::Error::unknown_field(value, FIELDS))
9396 }
9397 }
9398 deserializer.deserialize_identifier(GeneratedVisitor)
9399 }
9400 }
9401 struct GeneratedVisitor;
9402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9403 type Value = ListActorStatesRequest;
9404
9405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9406 formatter.write_str("struct meta.ListActorStatesRequest")
9407 }
9408
9409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
9410 where
9411 V: serde::de::MapAccess<'de>,
9412 {
9413 while map_.next_key::<GeneratedField>()?.is_some() {
9414 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9415 }
9416 Ok(ListActorStatesRequest {
9417 })
9418 }
9419 }
9420 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
9421 }
9422}
9423impl serde::Serialize for ListActorStatesResponse {
9424 #[allow(deprecated)]
9425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9426 where
9427 S: serde::Serializer,
9428 {
9429 use serde::ser::SerializeStruct;
9430 let mut len = 0;
9431 if !self.states.is_empty() {
9432 len += 1;
9433 }
9434 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
9435 if !self.states.is_empty() {
9436 struct_ser.serialize_field("states", &self.states)?;
9437 }
9438 struct_ser.end()
9439 }
9440}
9441impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
9442 #[allow(deprecated)]
9443 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9444 where
9445 D: serde::Deserializer<'de>,
9446 {
9447 const FIELDS: &[&str] = &[
9448 "states",
9449 ];
9450
9451 #[allow(clippy::enum_variant_names)]
9452 enum GeneratedField {
9453 States,
9454 }
9455 impl<'de> serde::Deserialize<'de> for GeneratedField {
9456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9457 where
9458 D: serde::Deserializer<'de>,
9459 {
9460 struct GeneratedVisitor;
9461
9462 impl serde::de::Visitor<'_> for GeneratedVisitor {
9463 type Value = GeneratedField;
9464
9465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9466 write!(formatter, "expected one of: {:?}", &FIELDS)
9467 }
9468
9469 #[allow(unused_variables)]
9470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9471 where
9472 E: serde::de::Error,
9473 {
9474 match value {
9475 "states" => Ok(GeneratedField::States),
9476 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9477 }
9478 }
9479 }
9480 deserializer.deserialize_identifier(GeneratedVisitor)
9481 }
9482 }
9483 struct GeneratedVisitor;
9484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9485 type Value = ListActorStatesResponse;
9486
9487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9488 formatter.write_str("struct meta.ListActorStatesResponse")
9489 }
9490
9491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
9492 where
9493 V: serde::de::MapAccess<'de>,
9494 {
9495 let mut states__ = None;
9496 while let Some(k) = map_.next_key()? {
9497 match k {
9498 GeneratedField::States => {
9499 if states__.is_some() {
9500 return Err(serde::de::Error::duplicate_field("states"));
9501 }
9502 states__ = Some(map_.next_value()?);
9503 }
9504 }
9505 }
9506 Ok(ListActorStatesResponse {
9507 states: states__.unwrap_or_default(),
9508 })
9509 }
9510 }
9511 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
9512 }
9513}
9514impl serde::Serialize for list_actor_states_response::ActorState {
9515 #[allow(deprecated)]
9516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9517 where
9518 S: serde::Serializer,
9519 {
9520 use serde::ser::SerializeStruct;
9521 let mut len = 0;
9522 if self.actor_id != 0 {
9523 len += 1;
9524 }
9525 if self.fragment_id != 0 {
9526 len += 1;
9527 }
9528 if self.worker_id != 0 {
9529 len += 1;
9530 }
9531 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
9532 if self.actor_id != 0 {
9533 struct_ser.serialize_field("actorId", &self.actor_id)?;
9534 }
9535 if self.fragment_id != 0 {
9536 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9537 }
9538 if self.worker_id != 0 {
9539 struct_ser.serialize_field("workerId", &self.worker_id)?;
9540 }
9541 struct_ser.end()
9542 }
9543}
9544impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
9545 #[allow(deprecated)]
9546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9547 where
9548 D: serde::Deserializer<'de>,
9549 {
9550 const FIELDS: &[&str] = &[
9551 "actor_id",
9552 "actorId",
9553 "fragment_id",
9554 "fragmentId",
9555 "worker_id",
9556 "workerId",
9557 ];
9558
9559 #[allow(clippy::enum_variant_names)]
9560 enum GeneratedField {
9561 ActorId,
9562 FragmentId,
9563 WorkerId,
9564 }
9565 impl<'de> serde::Deserialize<'de> for GeneratedField {
9566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9567 where
9568 D: serde::Deserializer<'de>,
9569 {
9570 struct GeneratedVisitor;
9571
9572 impl serde::de::Visitor<'_> for GeneratedVisitor {
9573 type Value = GeneratedField;
9574
9575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9576 write!(formatter, "expected one of: {:?}", &FIELDS)
9577 }
9578
9579 #[allow(unused_variables)]
9580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9581 where
9582 E: serde::de::Error,
9583 {
9584 match value {
9585 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9586 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9587 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
9588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9589 }
9590 }
9591 }
9592 deserializer.deserialize_identifier(GeneratedVisitor)
9593 }
9594 }
9595 struct GeneratedVisitor;
9596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9597 type Value = list_actor_states_response::ActorState;
9598
9599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9600 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
9601 }
9602
9603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
9604 where
9605 V: serde::de::MapAccess<'de>,
9606 {
9607 let mut actor_id__ = None;
9608 let mut fragment_id__ = None;
9609 let mut worker_id__ = None;
9610 while let Some(k) = map_.next_key()? {
9611 match k {
9612 GeneratedField::ActorId => {
9613 if actor_id__.is_some() {
9614 return Err(serde::de::Error::duplicate_field("actorId"));
9615 }
9616 actor_id__ =
9617 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9618 ;
9619 }
9620 GeneratedField::FragmentId => {
9621 if fragment_id__.is_some() {
9622 return Err(serde::de::Error::duplicate_field("fragmentId"));
9623 }
9624 fragment_id__ =
9625 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9626 ;
9627 }
9628 GeneratedField::WorkerId => {
9629 if worker_id__.is_some() {
9630 return Err(serde::de::Error::duplicate_field("workerId"));
9631 }
9632 worker_id__ =
9633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9634 ;
9635 }
9636 }
9637 }
9638 Ok(list_actor_states_response::ActorState {
9639 actor_id: actor_id__.unwrap_or_default(),
9640 fragment_id: fragment_id__.unwrap_or_default(),
9641 worker_id: worker_id__.unwrap_or_default(),
9642 })
9643 }
9644 }
9645 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
9646 }
9647}
9648impl serde::Serialize for ListAllNodesRequest {
9649 #[allow(deprecated)]
9650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9651 where
9652 S: serde::Serializer,
9653 {
9654 use serde::ser::SerializeStruct;
9655 let mut len = 0;
9656 if self.worker_type.is_some() {
9657 len += 1;
9658 }
9659 if self.include_starting_nodes {
9660 len += 1;
9661 }
9662 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9663 if let Some(v) = self.worker_type.as_ref() {
9664 let v = super::common::WorkerType::try_from(*v)
9665 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9666 struct_ser.serialize_field("workerType", &v)?;
9667 }
9668 if self.include_starting_nodes {
9669 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9670 }
9671 struct_ser.end()
9672 }
9673}
9674impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9675 #[allow(deprecated)]
9676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9677 where
9678 D: serde::Deserializer<'de>,
9679 {
9680 const FIELDS: &[&str] = &[
9681 "worker_type",
9682 "workerType",
9683 "include_starting_nodes",
9684 "includeStartingNodes",
9685 ];
9686
9687 #[allow(clippy::enum_variant_names)]
9688 enum GeneratedField {
9689 WorkerType,
9690 IncludeStartingNodes,
9691 }
9692 impl<'de> serde::Deserialize<'de> for GeneratedField {
9693 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9694 where
9695 D: serde::Deserializer<'de>,
9696 {
9697 struct GeneratedVisitor;
9698
9699 impl serde::de::Visitor<'_> for GeneratedVisitor {
9700 type Value = GeneratedField;
9701
9702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9703 write!(formatter, "expected one of: {:?}", &FIELDS)
9704 }
9705
9706 #[allow(unused_variables)]
9707 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9708 where
9709 E: serde::de::Error,
9710 {
9711 match value {
9712 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9713 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9714 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9715 }
9716 }
9717 }
9718 deserializer.deserialize_identifier(GeneratedVisitor)
9719 }
9720 }
9721 struct GeneratedVisitor;
9722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9723 type Value = ListAllNodesRequest;
9724
9725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9726 formatter.write_str("struct meta.ListAllNodesRequest")
9727 }
9728
9729 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9730 where
9731 V: serde::de::MapAccess<'de>,
9732 {
9733 let mut worker_type__ = None;
9734 let mut include_starting_nodes__ = None;
9735 while let Some(k) = map_.next_key()? {
9736 match k {
9737 GeneratedField::WorkerType => {
9738 if worker_type__.is_some() {
9739 return Err(serde::de::Error::duplicate_field("workerType"));
9740 }
9741 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9742 }
9743 GeneratedField::IncludeStartingNodes => {
9744 if include_starting_nodes__.is_some() {
9745 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9746 }
9747 include_starting_nodes__ = Some(map_.next_value()?);
9748 }
9749 }
9750 }
9751 Ok(ListAllNodesRequest {
9752 worker_type: worker_type__,
9753 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9754 })
9755 }
9756 }
9757 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9758 }
9759}
9760impl serde::Serialize for ListAllNodesResponse {
9761 #[allow(deprecated)]
9762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9763 where
9764 S: serde::Serializer,
9765 {
9766 use serde::ser::SerializeStruct;
9767 let mut len = 0;
9768 if self.status.is_some() {
9769 len += 1;
9770 }
9771 if !self.nodes.is_empty() {
9772 len += 1;
9773 }
9774 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9775 if let Some(v) = self.status.as_ref() {
9776 struct_ser.serialize_field("status", v)?;
9777 }
9778 if !self.nodes.is_empty() {
9779 struct_ser.serialize_field("nodes", &self.nodes)?;
9780 }
9781 struct_ser.end()
9782 }
9783}
9784impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9785 #[allow(deprecated)]
9786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9787 where
9788 D: serde::Deserializer<'de>,
9789 {
9790 const FIELDS: &[&str] = &[
9791 "status",
9792 "nodes",
9793 ];
9794
9795 #[allow(clippy::enum_variant_names)]
9796 enum GeneratedField {
9797 Status,
9798 Nodes,
9799 }
9800 impl<'de> serde::Deserialize<'de> for GeneratedField {
9801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9802 where
9803 D: serde::Deserializer<'de>,
9804 {
9805 struct GeneratedVisitor;
9806
9807 impl serde::de::Visitor<'_> for GeneratedVisitor {
9808 type Value = GeneratedField;
9809
9810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9811 write!(formatter, "expected one of: {:?}", &FIELDS)
9812 }
9813
9814 #[allow(unused_variables)]
9815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9816 where
9817 E: serde::de::Error,
9818 {
9819 match value {
9820 "status" => Ok(GeneratedField::Status),
9821 "nodes" => Ok(GeneratedField::Nodes),
9822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9823 }
9824 }
9825 }
9826 deserializer.deserialize_identifier(GeneratedVisitor)
9827 }
9828 }
9829 struct GeneratedVisitor;
9830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9831 type Value = ListAllNodesResponse;
9832
9833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9834 formatter.write_str("struct meta.ListAllNodesResponse")
9835 }
9836
9837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9838 where
9839 V: serde::de::MapAccess<'de>,
9840 {
9841 let mut status__ = None;
9842 let mut nodes__ = None;
9843 while let Some(k) = map_.next_key()? {
9844 match k {
9845 GeneratedField::Status => {
9846 if status__.is_some() {
9847 return Err(serde::de::Error::duplicate_field("status"));
9848 }
9849 status__ = map_.next_value()?;
9850 }
9851 GeneratedField::Nodes => {
9852 if nodes__.is_some() {
9853 return Err(serde::de::Error::duplicate_field("nodes"));
9854 }
9855 nodes__ = Some(map_.next_value()?);
9856 }
9857 }
9858 }
9859 Ok(ListAllNodesResponse {
9860 status: status__,
9861 nodes: nodes__.unwrap_or_default(),
9862 })
9863 }
9864 }
9865 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9866 }
9867}
9868impl serde::Serialize for ListCdcProgressRequest {
9869 #[allow(deprecated)]
9870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9871 where
9872 S: serde::Serializer,
9873 {
9874 use serde::ser::SerializeStruct;
9875 let len = 0;
9876 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9877 struct_ser.end()
9878 }
9879}
9880impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9881 #[allow(deprecated)]
9882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9883 where
9884 D: serde::Deserializer<'de>,
9885 {
9886 const FIELDS: &[&str] = &[
9887 ];
9888
9889 #[allow(clippy::enum_variant_names)]
9890 enum GeneratedField {
9891 }
9892 impl<'de> serde::Deserialize<'de> for GeneratedField {
9893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9894 where
9895 D: serde::Deserializer<'de>,
9896 {
9897 struct GeneratedVisitor;
9898
9899 impl serde::de::Visitor<'_> for GeneratedVisitor {
9900 type Value = GeneratedField;
9901
9902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9903 write!(formatter, "expected one of: {:?}", &FIELDS)
9904 }
9905
9906 #[allow(unused_variables)]
9907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9908 where
9909 E: serde::de::Error,
9910 {
9911 Err(serde::de::Error::unknown_field(value, FIELDS))
9912 }
9913 }
9914 deserializer.deserialize_identifier(GeneratedVisitor)
9915 }
9916 }
9917 struct GeneratedVisitor;
9918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9919 type Value = ListCdcProgressRequest;
9920
9921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9922 formatter.write_str("struct meta.ListCdcProgressRequest")
9923 }
9924
9925 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9926 where
9927 V: serde::de::MapAccess<'de>,
9928 {
9929 while map_.next_key::<GeneratedField>()?.is_some() {
9930 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9931 }
9932 Ok(ListCdcProgressRequest {
9933 })
9934 }
9935 }
9936 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9937 }
9938}
9939impl serde::Serialize for ListCdcProgressResponse {
9940 #[allow(deprecated)]
9941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9942 where
9943 S: serde::Serializer,
9944 {
9945 use serde::ser::SerializeStruct;
9946 let mut len = 0;
9947 if !self.cdc_progress.is_empty() {
9948 len += 1;
9949 }
9950 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9951 if !self.cdc_progress.is_empty() {
9952 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9953 }
9954 struct_ser.end()
9955 }
9956}
9957impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9958 #[allow(deprecated)]
9959 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9960 where
9961 D: serde::Deserializer<'de>,
9962 {
9963 const FIELDS: &[&str] = &[
9964 "cdc_progress",
9965 "cdcProgress",
9966 ];
9967
9968 #[allow(clippy::enum_variant_names)]
9969 enum GeneratedField {
9970 CdcProgress,
9971 }
9972 impl<'de> serde::Deserialize<'de> for GeneratedField {
9973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9974 where
9975 D: serde::Deserializer<'de>,
9976 {
9977 struct GeneratedVisitor;
9978
9979 impl serde::de::Visitor<'_> for GeneratedVisitor {
9980 type Value = GeneratedField;
9981
9982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9983 write!(formatter, "expected one of: {:?}", &FIELDS)
9984 }
9985
9986 #[allow(unused_variables)]
9987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9988 where
9989 E: serde::de::Error,
9990 {
9991 match value {
9992 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9994 }
9995 }
9996 }
9997 deserializer.deserialize_identifier(GeneratedVisitor)
9998 }
9999 }
10000 struct GeneratedVisitor;
10001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10002 type Value = ListCdcProgressResponse;
10003
10004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10005 formatter.write_str("struct meta.ListCdcProgressResponse")
10006 }
10007
10008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
10009 where
10010 V: serde::de::MapAccess<'de>,
10011 {
10012 let mut cdc_progress__ = None;
10013 while let Some(k) = map_.next_key()? {
10014 match k {
10015 GeneratedField::CdcProgress => {
10016 if cdc_progress__.is_some() {
10017 return Err(serde::de::Error::duplicate_field("cdcProgress"));
10018 }
10019 cdc_progress__ = Some(
10020 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10021 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10022 );
10023 }
10024 }
10025 }
10026 Ok(ListCdcProgressResponse {
10027 cdc_progress: cdc_progress__.unwrap_or_default(),
10028 })
10029 }
10030 }
10031 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
10032 }
10033}
10034impl serde::Serialize for list_cdc_progress_response::CdcProgress {
10035 #[allow(deprecated)]
10036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10037 where
10038 S: serde::Serializer,
10039 {
10040 use serde::ser::SerializeStruct;
10041 let mut len = 0;
10042 if self.split_total_count != 0 {
10043 len += 1;
10044 }
10045 if self.split_backfilled_count != 0 {
10046 len += 1;
10047 }
10048 if self.split_completed_count != 0 {
10049 len += 1;
10050 }
10051 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
10052 if self.split_total_count != 0 {
10053 #[allow(clippy::needless_borrow)]
10054 #[allow(clippy::needless_borrows_for_generic_args)]
10055 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
10056 }
10057 if self.split_backfilled_count != 0 {
10058 #[allow(clippy::needless_borrow)]
10059 #[allow(clippy::needless_borrows_for_generic_args)]
10060 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
10061 }
10062 if self.split_completed_count != 0 {
10063 #[allow(clippy::needless_borrow)]
10064 #[allow(clippy::needless_borrows_for_generic_args)]
10065 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
10066 }
10067 struct_ser.end()
10068 }
10069}
10070impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
10071 #[allow(deprecated)]
10072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10073 where
10074 D: serde::Deserializer<'de>,
10075 {
10076 const FIELDS: &[&str] = &[
10077 "split_total_count",
10078 "splitTotalCount",
10079 "split_backfilled_count",
10080 "splitBackfilledCount",
10081 "split_completed_count",
10082 "splitCompletedCount",
10083 ];
10084
10085 #[allow(clippy::enum_variant_names)]
10086 enum GeneratedField {
10087 SplitTotalCount,
10088 SplitBackfilledCount,
10089 SplitCompletedCount,
10090 }
10091 impl<'de> serde::Deserialize<'de> for GeneratedField {
10092 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10093 where
10094 D: serde::Deserializer<'de>,
10095 {
10096 struct GeneratedVisitor;
10097
10098 impl serde::de::Visitor<'_> for GeneratedVisitor {
10099 type Value = GeneratedField;
10100
10101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10102 write!(formatter, "expected one of: {:?}", &FIELDS)
10103 }
10104
10105 #[allow(unused_variables)]
10106 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10107 where
10108 E: serde::de::Error,
10109 {
10110 match value {
10111 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
10112 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
10113 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
10114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10115 }
10116 }
10117 }
10118 deserializer.deserialize_identifier(GeneratedVisitor)
10119 }
10120 }
10121 struct GeneratedVisitor;
10122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10123 type Value = list_cdc_progress_response::CdcProgress;
10124
10125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10126 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
10127 }
10128
10129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
10130 where
10131 V: serde::de::MapAccess<'de>,
10132 {
10133 let mut split_total_count__ = None;
10134 let mut split_backfilled_count__ = None;
10135 let mut split_completed_count__ = None;
10136 while let Some(k) = map_.next_key()? {
10137 match k {
10138 GeneratedField::SplitTotalCount => {
10139 if split_total_count__.is_some() {
10140 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
10141 }
10142 split_total_count__ =
10143 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10144 ;
10145 }
10146 GeneratedField::SplitBackfilledCount => {
10147 if split_backfilled_count__.is_some() {
10148 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
10149 }
10150 split_backfilled_count__ =
10151 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10152 ;
10153 }
10154 GeneratedField::SplitCompletedCount => {
10155 if split_completed_count__.is_some() {
10156 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
10157 }
10158 split_completed_count__ =
10159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10160 ;
10161 }
10162 }
10163 }
10164 Ok(list_cdc_progress_response::CdcProgress {
10165 split_total_count: split_total_count__.unwrap_or_default(),
10166 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
10167 split_completed_count: split_completed_count__.unwrap_or_default(),
10168 })
10169 }
10170 }
10171 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
10172 }
10173}
10174impl serde::Serialize for ListCreatingFragmentDistributionRequest {
10175 #[allow(deprecated)]
10176 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10177 where
10178 S: serde::Serializer,
10179 {
10180 use serde::ser::SerializeStruct;
10181 let mut len = 0;
10182 if self.include_node.is_some() {
10183 len += 1;
10184 }
10185 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
10186 if let Some(v) = self.include_node.as_ref() {
10187 struct_ser.serialize_field("includeNode", v)?;
10188 }
10189 struct_ser.end()
10190 }
10191}
10192impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
10193 #[allow(deprecated)]
10194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10195 where
10196 D: serde::Deserializer<'de>,
10197 {
10198 const FIELDS: &[&str] = &[
10199 "include_node",
10200 "includeNode",
10201 ];
10202
10203 #[allow(clippy::enum_variant_names)]
10204 enum GeneratedField {
10205 IncludeNode,
10206 }
10207 impl<'de> serde::Deserialize<'de> for GeneratedField {
10208 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10209 where
10210 D: serde::Deserializer<'de>,
10211 {
10212 struct GeneratedVisitor;
10213
10214 impl serde::de::Visitor<'_> for GeneratedVisitor {
10215 type Value = GeneratedField;
10216
10217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10218 write!(formatter, "expected one of: {:?}", &FIELDS)
10219 }
10220
10221 #[allow(unused_variables)]
10222 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10223 where
10224 E: serde::de::Error,
10225 {
10226 match value {
10227 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10228 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10229 }
10230 }
10231 }
10232 deserializer.deserialize_identifier(GeneratedVisitor)
10233 }
10234 }
10235 struct GeneratedVisitor;
10236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10237 type Value = ListCreatingFragmentDistributionRequest;
10238
10239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10240 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
10241 }
10242
10243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
10244 where
10245 V: serde::de::MapAccess<'de>,
10246 {
10247 let mut include_node__ = None;
10248 while let Some(k) = map_.next_key()? {
10249 match k {
10250 GeneratedField::IncludeNode => {
10251 if include_node__.is_some() {
10252 return Err(serde::de::Error::duplicate_field("includeNode"));
10253 }
10254 include_node__ = map_.next_value()?;
10255 }
10256 }
10257 }
10258 Ok(ListCreatingFragmentDistributionRequest {
10259 include_node: include_node__,
10260 })
10261 }
10262 }
10263 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10264 }
10265}
10266impl serde::Serialize for ListCreatingFragmentDistributionResponse {
10267 #[allow(deprecated)]
10268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10269 where
10270 S: serde::Serializer,
10271 {
10272 use serde::ser::SerializeStruct;
10273 let mut len = 0;
10274 if !self.distributions.is_empty() {
10275 len += 1;
10276 }
10277 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
10278 if !self.distributions.is_empty() {
10279 struct_ser.serialize_field("distributions", &self.distributions)?;
10280 }
10281 struct_ser.end()
10282 }
10283}
10284impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
10285 #[allow(deprecated)]
10286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10287 where
10288 D: serde::Deserializer<'de>,
10289 {
10290 const FIELDS: &[&str] = &[
10291 "distributions",
10292 ];
10293
10294 #[allow(clippy::enum_variant_names)]
10295 enum GeneratedField {
10296 Distributions,
10297 }
10298 impl<'de> serde::Deserialize<'de> for GeneratedField {
10299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10300 where
10301 D: serde::Deserializer<'de>,
10302 {
10303 struct GeneratedVisitor;
10304
10305 impl serde::de::Visitor<'_> for GeneratedVisitor {
10306 type Value = GeneratedField;
10307
10308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10309 write!(formatter, "expected one of: {:?}", &FIELDS)
10310 }
10311
10312 #[allow(unused_variables)]
10313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10314 where
10315 E: serde::de::Error,
10316 {
10317 match value {
10318 "distributions" => Ok(GeneratedField::Distributions),
10319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10320 }
10321 }
10322 }
10323 deserializer.deserialize_identifier(GeneratedVisitor)
10324 }
10325 }
10326 struct GeneratedVisitor;
10327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10328 type Value = ListCreatingFragmentDistributionResponse;
10329
10330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10331 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
10332 }
10333
10334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
10335 where
10336 V: serde::de::MapAccess<'de>,
10337 {
10338 let mut distributions__ = None;
10339 while let Some(k) = map_.next_key()? {
10340 match k {
10341 GeneratedField::Distributions => {
10342 if distributions__.is_some() {
10343 return Err(serde::de::Error::duplicate_field("distributions"));
10344 }
10345 distributions__ = Some(map_.next_value()?);
10346 }
10347 }
10348 }
10349 Ok(ListCreatingFragmentDistributionResponse {
10350 distributions: distributions__.unwrap_or_default(),
10351 })
10352 }
10353 }
10354 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10355 }
10356}
10357impl serde::Serialize for ListEventLogRequest {
10358 #[allow(deprecated)]
10359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10360 where
10361 S: serde::Serializer,
10362 {
10363 use serde::ser::SerializeStruct;
10364 let len = 0;
10365 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
10366 struct_ser.end()
10367 }
10368}
10369impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
10370 #[allow(deprecated)]
10371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10372 where
10373 D: serde::Deserializer<'de>,
10374 {
10375 const FIELDS: &[&str] = &[
10376 ];
10377
10378 #[allow(clippy::enum_variant_names)]
10379 enum GeneratedField {
10380 }
10381 impl<'de> serde::Deserialize<'de> for GeneratedField {
10382 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10383 where
10384 D: serde::Deserializer<'de>,
10385 {
10386 struct GeneratedVisitor;
10387
10388 impl serde::de::Visitor<'_> for GeneratedVisitor {
10389 type Value = GeneratedField;
10390
10391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10392 write!(formatter, "expected one of: {:?}", &FIELDS)
10393 }
10394
10395 #[allow(unused_variables)]
10396 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10397 where
10398 E: serde::de::Error,
10399 {
10400 Err(serde::de::Error::unknown_field(value, FIELDS))
10401 }
10402 }
10403 deserializer.deserialize_identifier(GeneratedVisitor)
10404 }
10405 }
10406 struct GeneratedVisitor;
10407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10408 type Value = ListEventLogRequest;
10409
10410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10411 formatter.write_str("struct meta.ListEventLogRequest")
10412 }
10413
10414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
10415 where
10416 V: serde::de::MapAccess<'de>,
10417 {
10418 while map_.next_key::<GeneratedField>()?.is_some() {
10419 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10420 }
10421 Ok(ListEventLogRequest {
10422 })
10423 }
10424 }
10425 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
10426 }
10427}
10428impl serde::Serialize for ListEventLogResponse {
10429 #[allow(deprecated)]
10430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10431 where
10432 S: serde::Serializer,
10433 {
10434 use serde::ser::SerializeStruct;
10435 let mut len = 0;
10436 if !self.event_logs.is_empty() {
10437 len += 1;
10438 }
10439 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
10440 if !self.event_logs.is_empty() {
10441 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
10442 }
10443 struct_ser.end()
10444 }
10445}
10446impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
10447 #[allow(deprecated)]
10448 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10449 where
10450 D: serde::Deserializer<'de>,
10451 {
10452 const FIELDS: &[&str] = &[
10453 "event_logs",
10454 "eventLogs",
10455 ];
10456
10457 #[allow(clippy::enum_variant_names)]
10458 enum GeneratedField {
10459 EventLogs,
10460 }
10461 impl<'de> serde::Deserialize<'de> for GeneratedField {
10462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10463 where
10464 D: serde::Deserializer<'de>,
10465 {
10466 struct GeneratedVisitor;
10467
10468 impl serde::de::Visitor<'_> for GeneratedVisitor {
10469 type Value = GeneratedField;
10470
10471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10472 write!(formatter, "expected one of: {:?}", &FIELDS)
10473 }
10474
10475 #[allow(unused_variables)]
10476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10477 where
10478 E: serde::de::Error,
10479 {
10480 match value {
10481 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
10482 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10483 }
10484 }
10485 }
10486 deserializer.deserialize_identifier(GeneratedVisitor)
10487 }
10488 }
10489 struct GeneratedVisitor;
10490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10491 type Value = ListEventLogResponse;
10492
10493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10494 formatter.write_str("struct meta.ListEventLogResponse")
10495 }
10496
10497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
10498 where
10499 V: serde::de::MapAccess<'de>,
10500 {
10501 let mut event_logs__ = None;
10502 while let Some(k) = map_.next_key()? {
10503 match k {
10504 GeneratedField::EventLogs => {
10505 if event_logs__.is_some() {
10506 return Err(serde::de::Error::duplicate_field("eventLogs"));
10507 }
10508 event_logs__ = Some(map_.next_value()?);
10509 }
10510 }
10511 }
10512 Ok(ListEventLogResponse {
10513 event_logs: event_logs__.unwrap_or_default(),
10514 })
10515 }
10516 }
10517 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
10518 }
10519}
10520impl serde::Serialize for ListFragmentDistributionRequest {
10521 #[allow(deprecated)]
10522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10523 where
10524 S: serde::Serializer,
10525 {
10526 use serde::ser::SerializeStruct;
10527 let mut len = 0;
10528 if self.include_node.is_some() {
10529 len += 1;
10530 }
10531 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
10532 if let Some(v) = self.include_node.as_ref() {
10533 struct_ser.serialize_field("includeNode", v)?;
10534 }
10535 struct_ser.end()
10536 }
10537}
10538impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
10539 #[allow(deprecated)]
10540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10541 where
10542 D: serde::Deserializer<'de>,
10543 {
10544 const FIELDS: &[&str] = &[
10545 "include_node",
10546 "includeNode",
10547 ];
10548
10549 #[allow(clippy::enum_variant_names)]
10550 enum GeneratedField {
10551 IncludeNode,
10552 }
10553 impl<'de> serde::Deserialize<'de> for GeneratedField {
10554 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10555 where
10556 D: serde::Deserializer<'de>,
10557 {
10558 struct GeneratedVisitor;
10559
10560 impl serde::de::Visitor<'_> for GeneratedVisitor {
10561 type Value = GeneratedField;
10562
10563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10564 write!(formatter, "expected one of: {:?}", &FIELDS)
10565 }
10566
10567 #[allow(unused_variables)]
10568 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10569 where
10570 E: serde::de::Error,
10571 {
10572 match value {
10573 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10574 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10575 }
10576 }
10577 }
10578 deserializer.deserialize_identifier(GeneratedVisitor)
10579 }
10580 }
10581 struct GeneratedVisitor;
10582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10583 type Value = ListFragmentDistributionRequest;
10584
10585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10586 formatter.write_str("struct meta.ListFragmentDistributionRequest")
10587 }
10588
10589 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
10590 where
10591 V: serde::de::MapAccess<'de>,
10592 {
10593 let mut include_node__ = None;
10594 while let Some(k) = map_.next_key()? {
10595 match k {
10596 GeneratedField::IncludeNode => {
10597 if include_node__.is_some() {
10598 return Err(serde::de::Error::duplicate_field("includeNode"));
10599 }
10600 include_node__ = map_.next_value()?;
10601 }
10602 }
10603 }
10604 Ok(ListFragmentDistributionRequest {
10605 include_node: include_node__,
10606 })
10607 }
10608 }
10609 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10610 }
10611}
10612impl serde::Serialize for ListFragmentDistributionResponse {
10613 #[allow(deprecated)]
10614 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10615 where
10616 S: serde::Serializer,
10617 {
10618 use serde::ser::SerializeStruct;
10619 let mut len = 0;
10620 if !self.distributions.is_empty() {
10621 len += 1;
10622 }
10623 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
10624 if !self.distributions.is_empty() {
10625 struct_ser.serialize_field("distributions", &self.distributions)?;
10626 }
10627 struct_ser.end()
10628 }
10629}
10630impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
10631 #[allow(deprecated)]
10632 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10633 where
10634 D: serde::Deserializer<'de>,
10635 {
10636 const FIELDS: &[&str] = &[
10637 "distributions",
10638 ];
10639
10640 #[allow(clippy::enum_variant_names)]
10641 enum GeneratedField {
10642 Distributions,
10643 }
10644 impl<'de> serde::Deserialize<'de> for GeneratedField {
10645 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10646 where
10647 D: serde::Deserializer<'de>,
10648 {
10649 struct GeneratedVisitor;
10650
10651 impl serde::de::Visitor<'_> for GeneratedVisitor {
10652 type Value = GeneratedField;
10653
10654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10655 write!(formatter, "expected one of: {:?}", &FIELDS)
10656 }
10657
10658 #[allow(unused_variables)]
10659 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10660 where
10661 E: serde::de::Error,
10662 {
10663 match value {
10664 "distributions" => Ok(GeneratedField::Distributions),
10665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10666 }
10667 }
10668 }
10669 deserializer.deserialize_identifier(GeneratedVisitor)
10670 }
10671 }
10672 struct GeneratedVisitor;
10673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10674 type Value = ListFragmentDistributionResponse;
10675
10676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10677 formatter.write_str("struct meta.ListFragmentDistributionResponse")
10678 }
10679
10680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
10681 where
10682 V: serde::de::MapAccess<'de>,
10683 {
10684 let mut distributions__ = None;
10685 while let Some(k) = map_.next_key()? {
10686 match k {
10687 GeneratedField::Distributions => {
10688 if distributions__.is_some() {
10689 return Err(serde::de::Error::duplicate_field("distributions"));
10690 }
10691 distributions__ = Some(map_.next_value()?);
10692 }
10693 }
10694 }
10695 Ok(ListFragmentDistributionResponse {
10696 distributions: distributions__.unwrap_or_default(),
10697 })
10698 }
10699 }
10700 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10701 }
10702}
10703impl serde::Serialize for ListIcebergCompactionStatusRequest {
10704 #[allow(deprecated)]
10705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10706 where
10707 S: serde::Serializer,
10708 {
10709 use serde::ser::SerializeStruct;
10710 let len = 0;
10711 let struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusRequest", len)?;
10712 struct_ser.end()
10713 }
10714}
10715impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusRequest {
10716 #[allow(deprecated)]
10717 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10718 where
10719 D: serde::Deserializer<'de>,
10720 {
10721 const FIELDS: &[&str] = &[
10722 ];
10723
10724 #[allow(clippy::enum_variant_names)]
10725 enum GeneratedField {
10726 }
10727 impl<'de> serde::Deserialize<'de> for GeneratedField {
10728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10729 where
10730 D: serde::Deserializer<'de>,
10731 {
10732 struct GeneratedVisitor;
10733
10734 impl serde::de::Visitor<'_> for GeneratedVisitor {
10735 type Value = GeneratedField;
10736
10737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10738 write!(formatter, "expected one of: {:?}", &FIELDS)
10739 }
10740
10741 #[allow(unused_variables)]
10742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10743 where
10744 E: serde::de::Error,
10745 {
10746 Err(serde::de::Error::unknown_field(value, FIELDS))
10747 }
10748 }
10749 deserializer.deserialize_identifier(GeneratedVisitor)
10750 }
10751 }
10752 struct GeneratedVisitor;
10753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10754 type Value = ListIcebergCompactionStatusRequest;
10755
10756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10757 formatter.write_str("struct meta.ListIcebergCompactionStatusRequest")
10758 }
10759
10760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusRequest, V::Error>
10761 where
10762 V: serde::de::MapAccess<'de>,
10763 {
10764 while map_.next_key::<GeneratedField>()?.is_some() {
10765 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10766 }
10767 Ok(ListIcebergCompactionStatusRequest {
10768 })
10769 }
10770 }
10771 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusRequest", FIELDS, GeneratedVisitor)
10772 }
10773}
10774impl serde::Serialize for ListIcebergCompactionStatusResponse {
10775 #[allow(deprecated)]
10776 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10777 where
10778 S: serde::Serializer,
10779 {
10780 use serde::ser::SerializeStruct;
10781 let mut len = 0;
10782 if !self.statuses.is_empty() {
10783 len += 1;
10784 }
10785 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse", len)?;
10786 if !self.statuses.is_empty() {
10787 struct_ser.serialize_field("statuses", &self.statuses)?;
10788 }
10789 struct_ser.end()
10790 }
10791}
10792impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusResponse {
10793 #[allow(deprecated)]
10794 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10795 where
10796 D: serde::Deserializer<'de>,
10797 {
10798 const FIELDS: &[&str] = &[
10799 "statuses",
10800 ];
10801
10802 #[allow(clippy::enum_variant_names)]
10803 enum GeneratedField {
10804 Statuses,
10805 }
10806 impl<'de> serde::Deserialize<'de> for GeneratedField {
10807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10808 where
10809 D: serde::Deserializer<'de>,
10810 {
10811 struct GeneratedVisitor;
10812
10813 impl serde::de::Visitor<'_> for GeneratedVisitor {
10814 type Value = GeneratedField;
10815
10816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10817 write!(formatter, "expected one of: {:?}", &FIELDS)
10818 }
10819
10820 #[allow(unused_variables)]
10821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10822 where
10823 E: serde::de::Error,
10824 {
10825 match value {
10826 "statuses" => Ok(GeneratedField::Statuses),
10827 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10828 }
10829 }
10830 }
10831 deserializer.deserialize_identifier(GeneratedVisitor)
10832 }
10833 }
10834 struct GeneratedVisitor;
10835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10836 type Value = ListIcebergCompactionStatusResponse;
10837
10838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10839 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse")
10840 }
10841
10842 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusResponse, V::Error>
10843 where
10844 V: serde::de::MapAccess<'de>,
10845 {
10846 let mut statuses__ = None;
10847 while let Some(k) = map_.next_key()? {
10848 match k {
10849 GeneratedField::Statuses => {
10850 if statuses__.is_some() {
10851 return Err(serde::de::Error::duplicate_field("statuses"));
10852 }
10853 statuses__ = Some(map_.next_value()?);
10854 }
10855 }
10856 }
10857 Ok(ListIcebergCompactionStatusResponse {
10858 statuses: statuses__.unwrap_or_default(),
10859 })
10860 }
10861 }
10862 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse", FIELDS, GeneratedVisitor)
10863 }
10864}
10865impl serde::Serialize for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10866 #[allow(deprecated)]
10867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10868 where
10869 S: serde::Serializer,
10870 {
10871 use serde::ser::SerializeStruct;
10872 let mut len = 0;
10873 if self.sink_id != 0 {
10874 len += 1;
10875 }
10876 if !self.task_type.is_empty() {
10877 len += 1;
10878 }
10879 if self.trigger_interval_sec != 0 {
10880 len += 1;
10881 }
10882 if self.trigger_snapshot_count != 0 {
10883 len += 1;
10884 }
10885 if !self.schedule_state.is_empty() {
10886 len += 1;
10887 }
10888 if self.next_compaction_after_sec.is_some() {
10889 len += 1;
10890 }
10891 if self.pending_snapshot_count.is_some() {
10892 len += 1;
10893 }
10894 if self.is_triggerable {
10895 len += 1;
10896 }
10897 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", len)?;
10898 if self.sink_id != 0 {
10899 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10900 }
10901 if !self.task_type.is_empty() {
10902 struct_ser.serialize_field("taskType", &self.task_type)?;
10903 }
10904 if self.trigger_interval_sec != 0 {
10905 #[allow(clippy::needless_borrow)]
10906 #[allow(clippy::needless_borrows_for_generic_args)]
10907 struct_ser.serialize_field("triggerIntervalSec", ToString::to_string(&self.trigger_interval_sec).as_str())?;
10908 }
10909 if self.trigger_snapshot_count != 0 {
10910 #[allow(clippy::needless_borrow)]
10911 #[allow(clippy::needless_borrows_for_generic_args)]
10912 struct_ser.serialize_field("triggerSnapshotCount", ToString::to_string(&self.trigger_snapshot_count).as_str())?;
10913 }
10914 if !self.schedule_state.is_empty() {
10915 struct_ser.serialize_field("scheduleState", &self.schedule_state)?;
10916 }
10917 if let Some(v) = self.next_compaction_after_sec.as_ref() {
10918 #[allow(clippy::needless_borrow)]
10919 #[allow(clippy::needless_borrows_for_generic_args)]
10920 struct_ser.serialize_field("nextCompactionAfterSec", ToString::to_string(&v).as_str())?;
10921 }
10922 if let Some(v) = self.pending_snapshot_count.as_ref() {
10923 #[allow(clippy::needless_borrow)]
10924 #[allow(clippy::needless_borrows_for_generic_args)]
10925 struct_ser.serialize_field("pendingSnapshotCount", ToString::to_string(&v).as_str())?;
10926 }
10927 if self.is_triggerable {
10928 struct_ser.serialize_field("isTriggerable", &self.is_triggerable)?;
10929 }
10930 struct_ser.end()
10931 }
10932}
10933impl<'de> serde::Deserialize<'de> for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10934 #[allow(deprecated)]
10935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10936 where
10937 D: serde::Deserializer<'de>,
10938 {
10939 const FIELDS: &[&str] = &[
10940 "sink_id",
10941 "sinkId",
10942 "task_type",
10943 "taskType",
10944 "trigger_interval_sec",
10945 "triggerIntervalSec",
10946 "trigger_snapshot_count",
10947 "triggerSnapshotCount",
10948 "schedule_state",
10949 "scheduleState",
10950 "next_compaction_after_sec",
10951 "nextCompactionAfterSec",
10952 "pending_snapshot_count",
10953 "pendingSnapshotCount",
10954 "is_triggerable",
10955 "isTriggerable",
10956 ];
10957
10958 #[allow(clippy::enum_variant_names)]
10959 enum GeneratedField {
10960 SinkId,
10961 TaskType,
10962 TriggerIntervalSec,
10963 TriggerSnapshotCount,
10964 ScheduleState,
10965 NextCompactionAfterSec,
10966 PendingSnapshotCount,
10967 IsTriggerable,
10968 }
10969 impl<'de> serde::Deserialize<'de> for GeneratedField {
10970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10971 where
10972 D: serde::Deserializer<'de>,
10973 {
10974 struct GeneratedVisitor;
10975
10976 impl serde::de::Visitor<'_> for GeneratedVisitor {
10977 type Value = GeneratedField;
10978
10979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10980 write!(formatter, "expected one of: {:?}", &FIELDS)
10981 }
10982
10983 #[allow(unused_variables)]
10984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10985 where
10986 E: serde::de::Error,
10987 {
10988 match value {
10989 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10990 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
10991 "triggerIntervalSec" | "trigger_interval_sec" => Ok(GeneratedField::TriggerIntervalSec),
10992 "triggerSnapshotCount" | "trigger_snapshot_count" => Ok(GeneratedField::TriggerSnapshotCount),
10993 "scheduleState" | "schedule_state" => Ok(GeneratedField::ScheduleState),
10994 "nextCompactionAfterSec" | "next_compaction_after_sec" => Ok(GeneratedField::NextCompactionAfterSec),
10995 "pendingSnapshotCount" | "pending_snapshot_count" => Ok(GeneratedField::PendingSnapshotCount),
10996 "isTriggerable" | "is_triggerable" => Ok(GeneratedField::IsTriggerable),
10997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10998 }
10999 }
11000 }
11001 deserializer.deserialize_identifier(GeneratedVisitor)
11002 }
11003 }
11004 struct GeneratedVisitor;
11005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11006 type Value = list_iceberg_compaction_status_response::IcebergCompactionStatus;
11007
11008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11009 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus")
11010 }
11011
11012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_compaction_status_response::IcebergCompactionStatus, V::Error>
11013 where
11014 V: serde::de::MapAccess<'de>,
11015 {
11016 let mut sink_id__ = None;
11017 let mut task_type__ = None;
11018 let mut trigger_interval_sec__ = None;
11019 let mut trigger_snapshot_count__ = None;
11020 let mut schedule_state__ = None;
11021 let mut next_compaction_after_sec__ = None;
11022 let mut pending_snapshot_count__ = None;
11023 let mut is_triggerable__ = None;
11024 while let Some(k) = map_.next_key()? {
11025 match k {
11026 GeneratedField::SinkId => {
11027 if sink_id__.is_some() {
11028 return Err(serde::de::Error::duplicate_field("sinkId"));
11029 }
11030 sink_id__ =
11031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11032 ;
11033 }
11034 GeneratedField::TaskType => {
11035 if task_type__.is_some() {
11036 return Err(serde::de::Error::duplicate_field("taskType"));
11037 }
11038 task_type__ = Some(map_.next_value()?);
11039 }
11040 GeneratedField::TriggerIntervalSec => {
11041 if trigger_interval_sec__.is_some() {
11042 return Err(serde::de::Error::duplicate_field("triggerIntervalSec"));
11043 }
11044 trigger_interval_sec__ =
11045 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11046 ;
11047 }
11048 GeneratedField::TriggerSnapshotCount => {
11049 if trigger_snapshot_count__.is_some() {
11050 return Err(serde::de::Error::duplicate_field("triggerSnapshotCount"));
11051 }
11052 trigger_snapshot_count__ =
11053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11054 ;
11055 }
11056 GeneratedField::ScheduleState => {
11057 if schedule_state__.is_some() {
11058 return Err(serde::de::Error::duplicate_field("scheduleState"));
11059 }
11060 schedule_state__ = Some(map_.next_value()?);
11061 }
11062 GeneratedField::NextCompactionAfterSec => {
11063 if next_compaction_after_sec__.is_some() {
11064 return Err(serde::de::Error::duplicate_field("nextCompactionAfterSec"));
11065 }
11066 next_compaction_after_sec__ =
11067 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11068 ;
11069 }
11070 GeneratedField::PendingSnapshotCount => {
11071 if pending_snapshot_count__.is_some() {
11072 return Err(serde::de::Error::duplicate_field("pendingSnapshotCount"));
11073 }
11074 pending_snapshot_count__ =
11075 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11076 ;
11077 }
11078 GeneratedField::IsTriggerable => {
11079 if is_triggerable__.is_some() {
11080 return Err(serde::de::Error::duplicate_field("isTriggerable"));
11081 }
11082 is_triggerable__ = Some(map_.next_value()?);
11083 }
11084 }
11085 }
11086 Ok(list_iceberg_compaction_status_response::IcebergCompactionStatus {
11087 sink_id: sink_id__.unwrap_or_default(),
11088 task_type: task_type__.unwrap_or_default(),
11089 trigger_interval_sec: trigger_interval_sec__.unwrap_or_default(),
11090 trigger_snapshot_count: trigger_snapshot_count__.unwrap_or_default(),
11091 schedule_state: schedule_state__.unwrap_or_default(),
11092 next_compaction_after_sec: next_compaction_after_sec__,
11093 pending_snapshot_count: pending_snapshot_count__,
11094 is_triggerable: is_triggerable__.unwrap_or_default(),
11095 })
11096 }
11097 }
11098 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", FIELDS, GeneratedVisitor)
11099 }
11100}
11101impl serde::Serialize for ListIcebergTablesRequest {
11102 #[allow(deprecated)]
11103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11104 where
11105 S: serde::Serializer,
11106 {
11107 use serde::ser::SerializeStruct;
11108 let len = 0;
11109 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
11110 struct_ser.end()
11111 }
11112}
11113impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
11114 #[allow(deprecated)]
11115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11116 where
11117 D: serde::Deserializer<'de>,
11118 {
11119 const FIELDS: &[&str] = &[
11120 ];
11121
11122 #[allow(clippy::enum_variant_names)]
11123 enum GeneratedField {
11124 }
11125 impl<'de> serde::Deserialize<'de> for GeneratedField {
11126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11127 where
11128 D: serde::Deserializer<'de>,
11129 {
11130 struct GeneratedVisitor;
11131
11132 impl serde::de::Visitor<'_> for GeneratedVisitor {
11133 type Value = GeneratedField;
11134
11135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11136 write!(formatter, "expected one of: {:?}", &FIELDS)
11137 }
11138
11139 #[allow(unused_variables)]
11140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11141 where
11142 E: serde::de::Error,
11143 {
11144 Err(serde::de::Error::unknown_field(value, FIELDS))
11145 }
11146 }
11147 deserializer.deserialize_identifier(GeneratedVisitor)
11148 }
11149 }
11150 struct GeneratedVisitor;
11151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11152 type Value = ListIcebergTablesRequest;
11153
11154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11155 formatter.write_str("struct meta.ListIcebergTablesRequest")
11156 }
11157
11158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
11159 where
11160 V: serde::de::MapAccess<'de>,
11161 {
11162 while map_.next_key::<GeneratedField>()?.is_some() {
11163 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11164 }
11165 Ok(ListIcebergTablesRequest {
11166 })
11167 }
11168 }
11169 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
11170 }
11171}
11172impl serde::Serialize for ListIcebergTablesResponse {
11173 #[allow(deprecated)]
11174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11175 where
11176 S: serde::Serializer,
11177 {
11178 use serde::ser::SerializeStruct;
11179 let mut len = 0;
11180 if !self.iceberg_tables.is_empty() {
11181 len += 1;
11182 }
11183 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
11184 if !self.iceberg_tables.is_empty() {
11185 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
11186 }
11187 struct_ser.end()
11188 }
11189}
11190impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
11191 #[allow(deprecated)]
11192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11193 where
11194 D: serde::Deserializer<'de>,
11195 {
11196 const FIELDS: &[&str] = &[
11197 "iceberg_tables",
11198 "icebergTables",
11199 ];
11200
11201 #[allow(clippy::enum_variant_names)]
11202 enum GeneratedField {
11203 IcebergTables,
11204 }
11205 impl<'de> serde::Deserialize<'de> for GeneratedField {
11206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11207 where
11208 D: serde::Deserializer<'de>,
11209 {
11210 struct GeneratedVisitor;
11211
11212 impl serde::de::Visitor<'_> for GeneratedVisitor {
11213 type Value = GeneratedField;
11214
11215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11216 write!(formatter, "expected one of: {:?}", &FIELDS)
11217 }
11218
11219 #[allow(unused_variables)]
11220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11221 where
11222 E: serde::de::Error,
11223 {
11224 match value {
11225 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
11226 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11227 }
11228 }
11229 }
11230 deserializer.deserialize_identifier(GeneratedVisitor)
11231 }
11232 }
11233 struct GeneratedVisitor;
11234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11235 type Value = ListIcebergTablesResponse;
11236
11237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11238 formatter.write_str("struct meta.ListIcebergTablesResponse")
11239 }
11240
11241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
11242 where
11243 V: serde::de::MapAccess<'de>,
11244 {
11245 let mut iceberg_tables__ = None;
11246 while let Some(k) = map_.next_key()? {
11247 match k {
11248 GeneratedField::IcebergTables => {
11249 if iceberg_tables__.is_some() {
11250 return Err(serde::de::Error::duplicate_field("icebergTables"));
11251 }
11252 iceberg_tables__ = Some(map_.next_value()?);
11253 }
11254 }
11255 }
11256 Ok(ListIcebergTablesResponse {
11257 iceberg_tables: iceberg_tables__.unwrap_or_default(),
11258 })
11259 }
11260 }
11261 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
11262 }
11263}
11264impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
11265 #[allow(deprecated)]
11266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11267 where
11268 S: serde::Serializer,
11269 {
11270 use serde::ser::SerializeStruct;
11271 let mut len = 0;
11272 if !self.catalog_name.is_empty() {
11273 len += 1;
11274 }
11275 if !self.table_namespace.is_empty() {
11276 len += 1;
11277 }
11278 if !self.table_name.is_empty() {
11279 len += 1;
11280 }
11281 if self.metadata_location.is_some() {
11282 len += 1;
11283 }
11284 if self.previous_metadata_location.is_some() {
11285 len += 1;
11286 }
11287 if self.iceberg_type.is_some() {
11288 len += 1;
11289 }
11290 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
11291 if !self.catalog_name.is_empty() {
11292 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
11293 }
11294 if !self.table_namespace.is_empty() {
11295 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
11296 }
11297 if !self.table_name.is_empty() {
11298 struct_ser.serialize_field("tableName", &self.table_name)?;
11299 }
11300 if let Some(v) = self.metadata_location.as_ref() {
11301 struct_ser.serialize_field("metadataLocation", v)?;
11302 }
11303 if let Some(v) = self.previous_metadata_location.as_ref() {
11304 struct_ser.serialize_field("previousMetadataLocation", v)?;
11305 }
11306 if let Some(v) = self.iceberg_type.as_ref() {
11307 struct_ser.serialize_field("icebergType", v)?;
11308 }
11309 struct_ser.end()
11310 }
11311}
11312impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
11313 #[allow(deprecated)]
11314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11315 where
11316 D: serde::Deserializer<'de>,
11317 {
11318 const FIELDS: &[&str] = &[
11319 "catalog_name",
11320 "catalogName",
11321 "table_namespace",
11322 "tableNamespace",
11323 "table_name",
11324 "tableName",
11325 "metadata_location",
11326 "metadataLocation",
11327 "previous_metadata_location",
11328 "previousMetadataLocation",
11329 "iceberg_type",
11330 "icebergType",
11331 ];
11332
11333 #[allow(clippy::enum_variant_names)]
11334 enum GeneratedField {
11335 CatalogName,
11336 TableNamespace,
11337 TableName,
11338 MetadataLocation,
11339 PreviousMetadataLocation,
11340 IcebergType,
11341 }
11342 impl<'de> serde::Deserialize<'de> for GeneratedField {
11343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11344 where
11345 D: serde::Deserializer<'de>,
11346 {
11347 struct GeneratedVisitor;
11348
11349 impl serde::de::Visitor<'_> for GeneratedVisitor {
11350 type Value = GeneratedField;
11351
11352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11353 write!(formatter, "expected one of: {:?}", &FIELDS)
11354 }
11355
11356 #[allow(unused_variables)]
11357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11358 where
11359 E: serde::de::Error,
11360 {
11361 match value {
11362 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
11363 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
11364 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11365 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
11366 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
11367 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
11368 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11369 }
11370 }
11371 }
11372 deserializer.deserialize_identifier(GeneratedVisitor)
11373 }
11374 }
11375 struct GeneratedVisitor;
11376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11377 type Value = list_iceberg_tables_response::IcebergTable;
11378
11379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11380 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
11381 }
11382
11383 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
11384 where
11385 V: serde::de::MapAccess<'de>,
11386 {
11387 let mut catalog_name__ = None;
11388 let mut table_namespace__ = None;
11389 let mut table_name__ = None;
11390 let mut metadata_location__ = None;
11391 let mut previous_metadata_location__ = None;
11392 let mut iceberg_type__ = None;
11393 while let Some(k) = map_.next_key()? {
11394 match k {
11395 GeneratedField::CatalogName => {
11396 if catalog_name__.is_some() {
11397 return Err(serde::de::Error::duplicate_field("catalogName"));
11398 }
11399 catalog_name__ = Some(map_.next_value()?);
11400 }
11401 GeneratedField::TableNamespace => {
11402 if table_namespace__.is_some() {
11403 return Err(serde::de::Error::duplicate_field("tableNamespace"));
11404 }
11405 table_namespace__ = Some(map_.next_value()?);
11406 }
11407 GeneratedField::TableName => {
11408 if table_name__.is_some() {
11409 return Err(serde::de::Error::duplicate_field("tableName"));
11410 }
11411 table_name__ = Some(map_.next_value()?);
11412 }
11413 GeneratedField::MetadataLocation => {
11414 if metadata_location__.is_some() {
11415 return Err(serde::de::Error::duplicate_field("metadataLocation"));
11416 }
11417 metadata_location__ = map_.next_value()?;
11418 }
11419 GeneratedField::PreviousMetadataLocation => {
11420 if previous_metadata_location__.is_some() {
11421 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
11422 }
11423 previous_metadata_location__ = map_.next_value()?;
11424 }
11425 GeneratedField::IcebergType => {
11426 if iceberg_type__.is_some() {
11427 return Err(serde::de::Error::duplicate_field("icebergType"));
11428 }
11429 iceberg_type__ = map_.next_value()?;
11430 }
11431 }
11432 }
11433 Ok(list_iceberg_tables_response::IcebergTable {
11434 catalog_name: catalog_name__.unwrap_or_default(),
11435 table_namespace: table_namespace__.unwrap_or_default(),
11436 table_name: table_name__.unwrap_or_default(),
11437 metadata_location: metadata_location__,
11438 previous_metadata_location: previous_metadata_location__,
11439 iceberg_type: iceberg_type__,
11440 })
11441 }
11442 }
11443 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
11444 }
11445}
11446impl serde::Serialize for ListRateLimitsRequest {
11447 #[allow(deprecated)]
11448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11449 where
11450 S: serde::Serializer,
11451 {
11452 use serde::ser::SerializeStruct;
11453 let len = 0;
11454 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
11455 struct_ser.end()
11456 }
11457}
11458impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
11459 #[allow(deprecated)]
11460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11461 where
11462 D: serde::Deserializer<'de>,
11463 {
11464 const FIELDS: &[&str] = &[
11465 ];
11466
11467 #[allow(clippy::enum_variant_names)]
11468 enum GeneratedField {
11469 }
11470 impl<'de> serde::Deserialize<'de> for GeneratedField {
11471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11472 where
11473 D: serde::Deserializer<'de>,
11474 {
11475 struct GeneratedVisitor;
11476
11477 impl serde::de::Visitor<'_> for GeneratedVisitor {
11478 type Value = GeneratedField;
11479
11480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11481 write!(formatter, "expected one of: {:?}", &FIELDS)
11482 }
11483
11484 #[allow(unused_variables)]
11485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11486 where
11487 E: serde::de::Error,
11488 {
11489 Err(serde::de::Error::unknown_field(value, FIELDS))
11490 }
11491 }
11492 deserializer.deserialize_identifier(GeneratedVisitor)
11493 }
11494 }
11495 struct GeneratedVisitor;
11496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11497 type Value = ListRateLimitsRequest;
11498
11499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11500 formatter.write_str("struct meta.ListRateLimitsRequest")
11501 }
11502
11503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
11504 where
11505 V: serde::de::MapAccess<'de>,
11506 {
11507 while map_.next_key::<GeneratedField>()?.is_some() {
11508 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11509 }
11510 Ok(ListRateLimitsRequest {
11511 })
11512 }
11513 }
11514 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
11515 }
11516}
11517impl serde::Serialize for ListRateLimitsResponse {
11518 #[allow(deprecated)]
11519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11520 where
11521 S: serde::Serializer,
11522 {
11523 use serde::ser::SerializeStruct;
11524 let mut len = 0;
11525 if !self.rate_limits.is_empty() {
11526 len += 1;
11527 }
11528 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
11529 if !self.rate_limits.is_empty() {
11530 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
11531 }
11532 struct_ser.end()
11533 }
11534}
11535impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
11536 #[allow(deprecated)]
11537 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11538 where
11539 D: serde::Deserializer<'de>,
11540 {
11541 const FIELDS: &[&str] = &[
11542 "rate_limits",
11543 "rateLimits",
11544 ];
11545
11546 #[allow(clippy::enum_variant_names)]
11547 enum GeneratedField {
11548 RateLimits,
11549 }
11550 impl<'de> serde::Deserialize<'de> for GeneratedField {
11551 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11552 where
11553 D: serde::Deserializer<'de>,
11554 {
11555 struct GeneratedVisitor;
11556
11557 impl serde::de::Visitor<'_> for GeneratedVisitor {
11558 type Value = GeneratedField;
11559
11560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11561 write!(formatter, "expected one of: {:?}", &FIELDS)
11562 }
11563
11564 #[allow(unused_variables)]
11565 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11566 where
11567 E: serde::de::Error,
11568 {
11569 match value {
11570 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
11571 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11572 }
11573 }
11574 }
11575 deserializer.deserialize_identifier(GeneratedVisitor)
11576 }
11577 }
11578 struct GeneratedVisitor;
11579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11580 type Value = ListRateLimitsResponse;
11581
11582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11583 formatter.write_str("struct meta.ListRateLimitsResponse")
11584 }
11585
11586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
11587 where
11588 V: serde::de::MapAccess<'de>,
11589 {
11590 let mut rate_limits__ = None;
11591 while let Some(k) = map_.next_key()? {
11592 match k {
11593 GeneratedField::RateLimits => {
11594 if rate_limits__.is_some() {
11595 return Err(serde::de::Error::duplicate_field("rateLimits"));
11596 }
11597 rate_limits__ = Some(map_.next_value()?);
11598 }
11599 }
11600 }
11601 Ok(ListRateLimitsResponse {
11602 rate_limits: rate_limits__.unwrap_or_default(),
11603 })
11604 }
11605 }
11606 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
11607 }
11608}
11609impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
11610 #[allow(deprecated)]
11611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11612 where
11613 S: serde::Serializer,
11614 {
11615 use serde::ser::SerializeStruct;
11616 let mut len = 0;
11617 if self.fragment_id != 0 {
11618 len += 1;
11619 }
11620 if self.job_id != 0 {
11621 len += 1;
11622 }
11623 if self.fragment_type_mask != 0 {
11624 len += 1;
11625 }
11626 if self.rate_limit != 0 {
11627 len += 1;
11628 }
11629 if !self.node_name.is_empty() {
11630 len += 1;
11631 }
11632 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
11633 if self.fragment_id != 0 {
11634 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11635 }
11636 if self.job_id != 0 {
11637 struct_ser.serialize_field("jobId", &self.job_id)?;
11638 }
11639 if self.fragment_type_mask != 0 {
11640 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11641 }
11642 if self.rate_limit != 0 {
11643 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
11644 }
11645 if !self.node_name.is_empty() {
11646 struct_ser.serialize_field("nodeName", &self.node_name)?;
11647 }
11648 struct_ser.end()
11649 }
11650}
11651impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
11652 #[allow(deprecated)]
11653 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11654 where
11655 D: serde::Deserializer<'de>,
11656 {
11657 const FIELDS: &[&str] = &[
11658 "fragment_id",
11659 "fragmentId",
11660 "job_id",
11661 "jobId",
11662 "fragment_type_mask",
11663 "fragmentTypeMask",
11664 "rate_limit",
11665 "rateLimit",
11666 "node_name",
11667 "nodeName",
11668 ];
11669
11670 #[allow(clippy::enum_variant_names)]
11671 enum GeneratedField {
11672 FragmentId,
11673 JobId,
11674 FragmentTypeMask,
11675 RateLimit,
11676 NodeName,
11677 }
11678 impl<'de> serde::Deserialize<'de> for GeneratedField {
11679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11680 where
11681 D: serde::Deserializer<'de>,
11682 {
11683 struct GeneratedVisitor;
11684
11685 impl serde::de::Visitor<'_> for GeneratedVisitor {
11686 type Value = GeneratedField;
11687
11688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11689 write!(formatter, "expected one of: {:?}", &FIELDS)
11690 }
11691
11692 #[allow(unused_variables)]
11693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11694 where
11695 E: serde::de::Error,
11696 {
11697 match value {
11698 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11699 "jobId" | "job_id" => Ok(GeneratedField::JobId),
11700 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11701 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11702 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
11703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11704 }
11705 }
11706 }
11707 deserializer.deserialize_identifier(GeneratedVisitor)
11708 }
11709 }
11710 struct GeneratedVisitor;
11711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11712 type Value = list_rate_limits_response::RateLimitInfo;
11713
11714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11715 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
11716 }
11717
11718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
11719 where
11720 V: serde::de::MapAccess<'de>,
11721 {
11722 let mut fragment_id__ = None;
11723 let mut job_id__ = None;
11724 let mut fragment_type_mask__ = None;
11725 let mut rate_limit__ = None;
11726 let mut node_name__ = None;
11727 while let Some(k) = map_.next_key()? {
11728 match k {
11729 GeneratedField::FragmentId => {
11730 if fragment_id__.is_some() {
11731 return Err(serde::de::Error::duplicate_field("fragmentId"));
11732 }
11733 fragment_id__ =
11734 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11735 ;
11736 }
11737 GeneratedField::JobId => {
11738 if job_id__.is_some() {
11739 return Err(serde::de::Error::duplicate_field("jobId"));
11740 }
11741 job_id__ =
11742 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11743 ;
11744 }
11745 GeneratedField::FragmentTypeMask => {
11746 if fragment_type_mask__.is_some() {
11747 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11748 }
11749 fragment_type_mask__ =
11750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11751 ;
11752 }
11753 GeneratedField::RateLimit => {
11754 if rate_limit__.is_some() {
11755 return Err(serde::de::Error::duplicate_field("rateLimit"));
11756 }
11757 rate_limit__ =
11758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11759 ;
11760 }
11761 GeneratedField::NodeName => {
11762 if node_name__.is_some() {
11763 return Err(serde::de::Error::duplicate_field("nodeName"));
11764 }
11765 node_name__ = Some(map_.next_value()?);
11766 }
11767 }
11768 }
11769 Ok(list_rate_limits_response::RateLimitInfo {
11770 fragment_id: fragment_id__.unwrap_or_default(),
11771 job_id: job_id__.unwrap_or_default(),
11772 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11773 rate_limit: rate_limit__.unwrap_or_default(),
11774 node_name: node_name__.unwrap_or_default(),
11775 })
11776 }
11777 }
11778 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
11779 }
11780}
11781impl serde::Serialize for ListRefreshTableStatesRequest {
11782 #[allow(deprecated)]
11783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11784 where
11785 S: serde::Serializer,
11786 {
11787 use serde::ser::SerializeStruct;
11788 let len = 0;
11789 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
11790 struct_ser.end()
11791 }
11792}
11793impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11794 #[allow(deprecated)]
11795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11796 where
11797 D: serde::Deserializer<'de>,
11798 {
11799 const FIELDS: &[&str] = &[
11800 ];
11801
11802 #[allow(clippy::enum_variant_names)]
11803 enum GeneratedField {
11804 }
11805 impl<'de> serde::Deserialize<'de> for GeneratedField {
11806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11807 where
11808 D: serde::Deserializer<'de>,
11809 {
11810 struct GeneratedVisitor;
11811
11812 impl serde::de::Visitor<'_> for GeneratedVisitor {
11813 type Value = GeneratedField;
11814
11815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11816 write!(formatter, "expected one of: {:?}", &FIELDS)
11817 }
11818
11819 #[allow(unused_variables)]
11820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11821 where
11822 E: serde::de::Error,
11823 {
11824 Err(serde::de::Error::unknown_field(value, FIELDS))
11825 }
11826 }
11827 deserializer.deserialize_identifier(GeneratedVisitor)
11828 }
11829 }
11830 struct GeneratedVisitor;
11831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11832 type Value = ListRefreshTableStatesRequest;
11833
11834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11835 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11836 }
11837
11838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11839 where
11840 V: serde::de::MapAccess<'de>,
11841 {
11842 while map_.next_key::<GeneratedField>()?.is_some() {
11843 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11844 }
11845 Ok(ListRefreshTableStatesRequest {
11846 })
11847 }
11848 }
11849 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11850 }
11851}
11852impl serde::Serialize for ListRefreshTableStatesResponse {
11853 #[allow(deprecated)]
11854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11855 where
11856 S: serde::Serializer,
11857 {
11858 use serde::ser::SerializeStruct;
11859 let mut len = 0;
11860 if !self.states.is_empty() {
11861 len += 1;
11862 }
11863 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11864 if !self.states.is_empty() {
11865 struct_ser.serialize_field("states", &self.states)?;
11866 }
11867 struct_ser.end()
11868 }
11869}
11870impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11871 #[allow(deprecated)]
11872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11873 where
11874 D: serde::Deserializer<'de>,
11875 {
11876 const FIELDS: &[&str] = &[
11877 "states",
11878 ];
11879
11880 #[allow(clippy::enum_variant_names)]
11881 enum GeneratedField {
11882 States,
11883 }
11884 impl<'de> serde::Deserialize<'de> for GeneratedField {
11885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11886 where
11887 D: serde::Deserializer<'de>,
11888 {
11889 struct GeneratedVisitor;
11890
11891 impl serde::de::Visitor<'_> for GeneratedVisitor {
11892 type Value = GeneratedField;
11893
11894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11895 write!(formatter, "expected one of: {:?}", &FIELDS)
11896 }
11897
11898 #[allow(unused_variables)]
11899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11900 where
11901 E: serde::de::Error,
11902 {
11903 match value {
11904 "states" => Ok(GeneratedField::States),
11905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11906 }
11907 }
11908 }
11909 deserializer.deserialize_identifier(GeneratedVisitor)
11910 }
11911 }
11912 struct GeneratedVisitor;
11913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11914 type Value = ListRefreshTableStatesResponse;
11915
11916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11917 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11918 }
11919
11920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11921 where
11922 V: serde::de::MapAccess<'de>,
11923 {
11924 let mut states__ = None;
11925 while let Some(k) = map_.next_key()? {
11926 match k {
11927 GeneratedField::States => {
11928 if states__.is_some() {
11929 return Err(serde::de::Error::duplicate_field("states"));
11930 }
11931 states__ = Some(map_.next_value()?);
11932 }
11933 }
11934 }
11935 Ok(ListRefreshTableStatesResponse {
11936 states: states__.unwrap_or_default(),
11937 })
11938 }
11939 }
11940 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11941 }
11942}
11943impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11944 #[allow(deprecated)]
11945 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11946 where
11947 S: serde::Serializer,
11948 {
11949 use serde::ser::SerializeStruct;
11950 let mut len = 0;
11951 if self.table_id != 0 {
11952 len += 1;
11953 }
11954 if !self.current_status.is_empty() {
11955 len += 1;
11956 }
11957 if self.last_trigger_time.is_some() {
11958 len += 1;
11959 }
11960 if self.trigger_interval_secs.is_some() {
11961 len += 1;
11962 }
11963 if self.last_success_time.is_some() {
11964 len += 1;
11965 }
11966 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11967 if self.table_id != 0 {
11968 struct_ser.serialize_field("tableId", &self.table_id)?;
11969 }
11970 if !self.current_status.is_empty() {
11971 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11972 }
11973 if let Some(v) = self.last_trigger_time.as_ref() {
11974 struct_ser.serialize_field("lastTriggerTime", v)?;
11975 }
11976 if let Some(v) = self.trigger_interval_secs.as_ref() {
11977 #[allow(clippy::needless_borrow)]
11978 #[allow(clippy::needless_borrows_for_generic_args)]
11979 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11980 }
11981 if let Some(v) = self.last_success_time.as_ref() {
11982 struct_ser.serialize_field("lastSuccessTime", v)?;
11983 }
11984 struct_ser.end()
11985 }
11986}
11987impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11988 #[allow(deprecated)]
11989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11990 where
11991 D: serde::Deserializer<'de>,
11992 {
11993 const FIELDS: &[&str] = &[
11994 "table_id",
11995 "tableId",
11996 "current_status",
11997 "currentStatus",
11998 "last_trigger_time",
11999 "lastTriggerTime",
12000 "trigger_interval_secs",
12001 "triggerIntervalSecs",
12002 "last_success_time",
12003 "lastSuccessTime",
12004 ];
12005
12006 #[allow(clippy::enum_variant_names)]
12007 enum GeneratedField {
12008 TableId,
12009 CurrentStatus,
12010 LastTriggerTime,
12011 TriggerIntervalSecs,
12012 LastSuccessTime,
12013 }
12014 impl<'de> serde::Deserialize<'de> for GeneratedField {
12015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12016 where
12017 D: serde::Deserializer<'de>,
12018 {
12019 struct GeneratedVisitor;
12020
12021 impl serde::de::Visitor<'_> for GeneratedVisitor {
12022 type Value = GeneratedField;
12023
12024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12025 write!(formatter, "expected one of: {:?}", &FIELDS)
12026 }
12027
12028 #[allow(unused_variables)]
12029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12030 where
12031 E: serde::de::Error,
12032 {
12033 match value {
12034 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12035 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
12036 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
12037 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
12038 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
12039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12040 }
12041 }
12042 }
12043 deserializer.deserialize_identifier(GeneratedVisitor)
12044 }
12045 }
12046 struct GeneratedVisitor;
12047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12048 type Value = list_refresh_table_states_response::RefreshTableState;
12049
12050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12051 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
12052 }
12053
12054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
12055 where
12056 V: serde::de::MapAccess<'de>,
12057 {
12058 let mut table_id__ = None;
12059 let mut current_status__ = None;
12060 let mut last_trigger_time__ = None;
12061 let mut trigger_interval_secs__ = None;
12062 let mut last_success_time__ = None;
12063 while let Some(k) = map_.next_key()? {
12064 match k {
12065 GeneratedField::TableId => {
12066 if table_id__.is_some() {
12067 return Err(serde::de::Error::duplicate_field("tableId"));
12068 }
12069 table_id__ =
12070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12071 ;
12072 }
12073 GeneratedField::CurrentStatus => {
12074 if current_status__.is_some() {
12075 return Err(serde::de::Error::duplicate_field("currentStatus"));
12076 }
12077 current_status__ = Some(map_.next_value()?);
12078 }
12079 GeneratedField::LastTriggerTime => {
12080 if last_trigger_time__.is_some() {
12081 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
12082 }
12083 last_trigger_time__ = map_.next_value()?;
12084 }
12085 GeneratedField::TriggerIntervalSecs => {
12086 if trigger_interval_secs__.is_some() {
12087 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
12088 }
12089 trigger_interval_secs__ =
12090 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12091 ;
12092 }
12093 GeneratedField::LastSuccessTime => {
12094 if last_success_time__.is_some() {
12095 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
12096 }
12097 last_success_time__ = map_.next_value()?;
12098 }
12099 }
12100 }
12101 Ok(list_refresh_table_states_response::RefreshTableState {
12102 table_id: table_id__.unwrap_or_default(),
12103 current_status: current_status__.unwrap_or_default(),
12104 last_trigger_time: last_trigger_time__,
12105 trigger_interval_secs: trigger_interval_secs__,
12106 last_success_time: last_success_time__,
12107 })
12108 }
12109 }
12110 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
12111 }
12112}
12113impl serde::Serialize for ListSinkLogStoreTablesRequest {
12114 #[allow(deprecated)]
12115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12116 where
12117 S: serde::Serializer,
12118 {
12119 use serde::ser::SerializeStruct;
12120 let len = 0;
12121 let struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesRequest", len)?;
12122 struct_ser.end()
12123 }
12124}
12125impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesRequest {
12126 #[allow(deprecated)]
12127 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12128 where
12129 D: serde::Deserializer<'de>,
12130 {
12131 const FIELDS: &[&str] = &[
12132 ];
12133
12134 #[allow(clippy::enum_variant_names)]
12135 enum GeneratedField {
12136 }
12137 impl<'de> serde::Deserialize<'de> for GeneratedField {
12138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12139 where
12140 D: serde::Deserializer<'de>,
12141 {
12142 struct GeneratedVisitor;
12143
12144 impl serde::de::Visitor<'_> for GeneratedVisitor {
12145 type Value = GeneratedField;
12146
12147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12148 write!(formatter, "expected one of: {:?}", &FIELDS)
12149 }
12150
12151 #[allow(unused_variables)]
12152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12153 where
12154 E: serde::de::Error,
12155 {
12156 Err(serde::de::Error::unknown_field(value, FIELDS))
12157 }
12158 }
12159 deserializer.deserialize_identifier(GeneratedVisitor)
12160 }
12161 }
12162 struct GeneratedVisitor;
12163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12164 type Value = ListSinkLogStoreTablesRequest;
12165
12166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12167 formatter.write_str("struct meta.ListSinkLogStoreTablesRequest")
12168 }
12169
12170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesRequest, V::Error>
12171 where
12172 V: serde::de::MapAccess<'de>,
12173 {
12174 while map_.next_key::<GeneratedField>()?.is_some() {
12175 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12176 }
12177 Ok(ListSinkLogStoreTablesRequest {
12178 })
12179 }
12180 }
12181 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesRequest", FIELDS, GeneratedVisitor)
12182 }
12183}
12184impl serde::Serialize for ListSinkLogStoreTablesResponse {
12185 #[allow(deprecated)]
12186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12187 where
12188 S: serde::Serializer,
12189 {
12190 use serde::ser::SerializeStruct;
12191 let mut len = 0;
12192 if !self.tables.is_empty() {
12193 len += 1;
12194 }
12195 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse", len)?;
12196 if !self.tables.is_empty() {
12197 struct_ser.serialize_field("tables", &self.tables)?;
12198 }
12199 struct_ser.end()
12200 }
12201}
12202impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesResponse {
12203 #[allow(deprecated)]
12204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12205 where
12206 D: serde::Deserializer<'de>,
12207 {
12208 const FIELDS: &[&str] = &[
12209 "tables",
12210 ];
12211
12212 #[allow(clippy::enum_variant_names)]
12213 enum GeneratedField {
12214 Tables,
12215 }
12216 impl<'de> serde::Deserialize<'de> for GeneratedField {
12217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12218 where
12219 D: serde::Deserializer<'de>,
12220 {
12221 struct GeneratedVisitor;
12222
12223 impl serde::de::Visitor<'_> for GeneratedVisitor {
12224 type Value = GeneratedField;
12225
12226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12227 write!(formatter, "expected one of: {:?}", &FIELDS)
12228 }
12229
12230 #[allow(unused_variables)]
12231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12232 where
12233 E: serde::de::Error,
12234 {
12235 match value {
12236 "tables" => Ok(GeneratedField::Tables),
12237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12238 }
12239 }
12240 }
12241 deserializer.deserialize_identifier(GeneratedVisitor)
12242 }
12243 }
12244 struct GeneratedVisitor;
12245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12246 type Value = ListSinkLogStoreTablesResponse;
12247
12248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12249 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse")
12250 }
12251
12252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesResponse, V::Error>
12253 where
12254 V: serde::de::MapAccess<'de>,
12255 {
12256 let mut tables__ = None;
12257 while let Some(k) = map_.next_key()? {
12258 match k {
12259 GeneratedField::Tables => {
12260 if tables__.is_some() {
12261 return Err(serde::de::Error::duplicate_field("tables"));
12262 }
12263 tables__ = Some(map_.next_value()?);
12264 }
12265 }
12266 }
12267 Ok(ListSinkLogStoreTablesResponse {
12268 tables: tables__.unwrap_or_default(),
12269 })
12270 }
12271 }
12272 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse", FIELDS, GeneratedVisitor)
12273 }
12274}
12275impl serde::Serialize for list_sink_log_store_tables_response::SinkLogStoreTable {
12276 #[allow(deprecated)]
12277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12278 where
12279 S: serde::Serializer,
12280 {
12281 use serde::ser::SerializeStruct;
12282 let mut len = 0;
12283 if self.sink_id != 0 {
12284 len += 1;
12285 }
12286 if self.internal_table_id != 0 {
12287 len += 1;
12288 }
12289 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", len)?;
12290 if self.sink_id != 0 {
12291 struct_ser.serialize_field("sinkId", &self.sink_id)?;
12292 }
12293 if self.internal_table_id != 0 {
12294 struct_ser.serialize_field("internalTableId", &self.internal_table_id)?;
12295 }
12296 struct_ser.end()
12297 }
12298}
12299impl<'de> serde::Deserialize<'de> for list_sink_log_store_tables_response::SinkLogStoreTable {
12300 #[allow(deprecated)]
12301 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12302 where
12303 D: serde::Deserializer<'de>,
12304 {
12305 const FIELDS: &[&str] = &[
12306 "sink_id",
12307 "sinkId",
12308 "internal_table_id",
12309 "internalTableId",
12310 ];
12311
12312 #[allow(clippy::enum_variant_names)]
12313 enum GeneratedField {
12314 SinkId,
12315 InternalTableId,
12316 }
12317 impl<'de> serde::Deserialize<'de> for GeneratedField {
12318 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12319 where
12320 D: serde::Deserializer<'de>,
12321 {
12322 struct GeneratedVisitor;
12323
12324 impl serde::de::Visitor<'_> for GeneratedVisitor {
12325 type Value = GeneratedField;
12326
12327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12328 write!(formatter, "expected one of: {:?}", &FIELDS)
12329 }
12330
12331 #[allow(unused_variables)]
12332 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12333 where
12334 E: serde::de::Error,
12335 {
12336 match value {
12337 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
12338 "internalTableId" | "internal_table_id" => Ok(GeneratedField::InternalTableId),
12339 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12340 }
12341 }
12342 }
12343 deserializer.deserialize_identifier(GeneratedVisitor)
12344 }
12345 }
12346 struct GeneratedVisitor;
12347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12348 type Value = list_sink_log_store_tables_response::SinkLogStoreTable;
12349
12350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12351 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable")
12352 }
12353
12354 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_sink_log_store_tables_response::SinkLogStoreTable, V::Error>
12355 where
12356 V: serde::de::MapAccess<'de>,
12357 {
12358 let mut sink_id__ = None;
12359 let mut internal_table_id__ = None;
12360 while let Some(k) = map_.next_key()? {
12361 match k {
12362 GeneratedField::SinkId => {
12363 if sink_id__.is_some() {
12364 return Err(serde::de::Error::duplicate_field("sinkId"));
12365 }
12366 sink_id__ =
12367 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12368 ;
12369 }
12370 GeneratedField::InternalTableId => {
12371 if internal_table_id__.is_some() {
12372 return Err(serde::de::Error::duplicate_field("internalTableId"));
12373 }
12374 internal_table_id__ =
12375 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12376 ;
12377 }
12378 }
12379 }
12380 Ok(list_sink_log_store_tables_response::SinkLogStoreTable {
12381 sink_id: sink_id__.unwrap_or_default(),
12382 internal_table_id: internal_table_id__.unwrap_or_default(),
12383 })
12384 }
12385 }
12386 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", FIELDS, GeneratedVisitor)
12387 }
12388}
12389impl serde::Serialize for ListStreamingJobStatesRequest {
12390 #[allow(deprecated)]
12391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12392 where
12393 S: serde::Serializer,
12394 {
12395 use serde::ser::SerializeStruct;
12396 let len = 0;
12397 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
12398 struct_ser.end()
12399 }
12400}
12401impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
12402 #[allow(deprecated)]
12403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12404 where
12405 D: serde::Deserializer<'de>,
12406 {
12407 const FIELDS: &[&str] = &[
12408 ];
12409
12410 #[allow(clippy::enum_variant_names)]
12411 enum GeneratedField {
12412 }
12413 impl<'de> serde::Deserialize<'de> for GeneratedField {
12414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12415 where
12416 D: serde::Deserializer<'de>,
12417 {
12418 struct GeneratedVisitor;
12419
12420 impl serde::de::Visitor<'_> for GeneratedVisitor {
12421 type Value = GeneratedField;
12422
12423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12424 write!(formatter, "expected one of: {:?}", &FIELDS)
12425 }
12426
12427 #[allow(unused_variables)]
12428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12429 where
12430 E: serde::de::Error,
12431 {
12432 Err(serde::de::Error::unknown_field(value, FIELDS))
12433 }
12434 }
12435 deserializer.deserialize_identifier(GeneratedVisitor)
12436 }
12437 }
12438 struct GeneratedVisitor;
12439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12440 type Value = ListStreamingJobStatesRequest;
12441
12442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12443 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
12444 }
12445
12446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
12447 where
12448 V: serde::de::MapAccess<'de>,
12449 {
12450 while map_.next_key::<GeneratedField>()?.is_some() {
12451 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12452 }
12453 Ok(ListStreamingJobStatesRequest {
12454 })
12455 }
12456 }
12457 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
12458 }
12459}
12460impl serde::Serialize for ListStreamingJobStatesResponse {
12461 #[allow(deprecated)]
12462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12463 where
12464 S: serde::Serializer,
12465 {
12466 use serde::ser::SerializeStruct;
12467 let mut len = 0;
12468 if !self.states.is_empty() {
12469 len += 1;
12470 }
12471 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
12472 if !self.states.is_empty() {
12473 struct_ser.serialize_field("states", &self.states)?;
12474 }
12475 struct_ser.end()
12476 }
12477}
12478impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
12479 #[allow(deprecated)]
12480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12481 where
12482 D: serde::Deserializer<'de>,
12483 {
12484 const FIELDS: &[&str] = &[
12485 "states",
12486 ];
12487
12488 #[allow(clippy::enum_variant_names)]
12489 enum GeneratedField {
12490 States,
12491 }
12492 impl<'de> serde::Deserialize<'de> for GeneratedField {
12493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12494 where
12495 D: serde::Deserializer<'de>,
12496 {
12497 struct GeneratedVisitor;
12498
12499 impl serde::de::Visitor<'_> for GeneratedVisitor {
12500 type Value = GeneratedField;
12501
12502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12503 write!(formatter, "expected one of: {:?}", &FIELDS)
12504 }
12505
12506 #[allow(unused_variables)]
12507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12508 where
12509 E: serde::de::Error,
12510 {
12511 match value {
12512 "states" => Ok(GeneratedField::States),
12513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12514 }
12515 }
12516 }
12517 deserializer.deserialize_identifier(GeneratedVisitor)
12518 }
12519 }
12520 struct GeneratedVisitor;
12521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12522 type Value = ListStreamingJobStatesResponse;
12523
12524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12525 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
12526 }
12527
12528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
12529 where
12530 V: serde::de::MapAccess<'de>,
12531 {
12532 let mut states__ = None;
12533 while let Some(k) = map_.next_key()? {
12534 match k {
12535 GeneratedField::States => {
12536 if states__.is_some() {
12537 return Err(serde::de::Error::duplicate_field("states"));
12538 }
12539 states__ = Some(map_.next_value()?);
12540 }
12541 }
12542 }
12543 Ok(ListStreamingJobStatesResponse {
12544 states: states__.unwrap_or_default(),
12545 })
12546 }
12547 }
12548 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
12549 }
12550}
12551impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
12552 #[allow(deprecated)]
12553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12554 where
12555 S: serde::Serializer,
12556 {
12557 use serde::ser::SerializeStruct;
12558 let mut len = 0;
12559 if self.table_id != 0 {
12560 len += 1;
12561 }
12562 if self.state != 0 {
12563 len += 1;
12564 }
12565 if self.parallelism.is_some() {
12566 len += 1;
12567 }
12568 if self.max_parallelism != 0 {
12569 len += 1;
12570 }
12571 if !self.name.is_empty() {
12572 len += 1;
12573 }
12574 if !self.resource_group.is_empty() {
12575 len += 1;
12576 }
12577 if !self.config_override.is_empty() {
12578 len += 1;
12579 }
12580 if self.database_id != 0 {
12581 len += 1;
12582 }
12583 if self.schema_id != 0 {
12584 len += 1;
12585 }
12586 if self.adaptive_parallelism_strategy.is_some() {
12587 len += 1;
12588 }
12589 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12590 if self.table_id != 0 {
12591 struct_ser.serialize_field("tableId", &self.table_id)?;
12592 }
12593 if self.state != 0 {
12594 let v = table_fragments::State::try_from(self.state)
12595 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12596 struct_ser.serialize_field("state", &v)?;
12597 }
12598 if let Some(v) = self.parallelism.as_ref() {
12599 struct_ser.serialize_field("parallelism", v)?;
12600 }
12601 if self.max_parallelism != 0 {
12602 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12603 }
12604 if !self.name.is_empty() {
12605 struct_ser.serialize_field("name", &self.name)?;
12606 }
12607 if !self.resource_group.is_empty() {
12608 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12609 }
12610 if !self.config_override.is_empty() {
12611 struct_ser.serialize_field("configOverride", &self.config_override)?;
12612 }
12613 if self.database_id != 0 {
12614 struct_ser.serialize_field("databaseId", &self.database_id)?;
12615 }
12616 if self.schema_id != 0 {
12617 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12618 }
12619 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
12620 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
12621 }
12622 struct_ser.end()
12623 }
12624}
12625impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12626 #[allow(deprecated)]
12627 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12628 where
12629 D: serde::Deserializer<'de>,
12630 {
12631 const FIELDS: &[&str] = &[
12632 "table_id",
12633 "tableId",
12634 "state",
12635 "parallelism",
12636 "max_parallelism",
12637 "maxParallelism",
12638 "name",
12639 "resource_group",
12640 "resourceGroup",
12641 "config_override",
12642 "configOverride",
12643 "database_id",
12644 "databaseId",
12645 "schema_id",
12646 "schemaId",
12647 "adaptive_parallelism_strategy",
12648 "adaptiveParallelismStrategy",
12649 ];
12650
12651 #[allow(clippy::enum_variant_names)]
12652 enum GeneratedField {
12653 TableId,
12654 State,
12655 Parallelism,
12656 MaxParallelism,
12657 Name,
12658 ResourceGroup,
12659 ConfigOverride,
12660 DatabaseId,
12661 SchemaId,
12662 AdaptiveParallelismStrategy,
12663 }
12664 impl<'de> serde::Deserialize<'de> for GeneratedField {
12665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12666 where
12667 D: serde::Deserializer<'de>,
12668 {
12669 struct GeneratedVisitor;
12670
12671 impl serde::de::Visitor<'_> for GeneratedVisitor {
12672 type Value = GeneratedField;
12673
12674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12675 write!(formatter, "expected one of: {:?}", &FIELDS)
12676 }
12677
12678 #[allow(unused_variables)]
12679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12680 where
12681 E: serde::de::Error,
12682 {
12683 match value {
12684 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12685 "state" => Ok(GeneratedField::State),
12686 "parallelism" => Ok(GeneratedField::Parallelism),
12687 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12688 "name" => Ok(GeneratedField::Name),
12689 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12690 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12691 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12692 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12693 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12695 }
12696 }
12697 }
12698 deserializer.deserialize_identifier(GeneratedVisitor)
12699 }
12700 }
12701 struct GeneratedVisitor;
12702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12703 type Value = list_streaming_job_states_response::StreamingJobState;
12704
12705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12706 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12707 }
12708
12709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12710 where
12711 V: serde::de::MapAccess<'de>,
12712 {
12713 let mut table_id__ = None;
12714 let mut state__ = None;
12715 let mut parallelism__ = None;
12716 let mut max_parallelism__ = None;
12717 let mut name__ = None;
12718 let mut resource_group__ = None;
12719 let mut config_override__ = None;
12720 let mut database_id__ = None;
12721 let mut schema_id__ = None;
12722 let mut adaptive_parallelism_strategy__ = None;
12723 while let Some(k) = map_.next_key()? {
12724 match k {
12725 GeneratedField::TableId => {
12726 if table_id__.is_some() {
12727 return Err(serde::de::Error::duplicate_field("tableId"));
12728 }
12729 table_id__ =
12730 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12731 ;
12732 }
12733 GeneratedField::State => {
12734 if state__.is_some() {
12735 return Err(serde::de::Error::duplicate_field("state"));
12736 }
12737 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12738 }
12739 GeneratedField::Parallelism => {
12740 if parallelism__.is_some() {
12741 return Err(serde::de::Error::duplicate_field("parallelism"));
12742 }
12743 parallelism__ = map_.next_value()?;
12744 }
12745 GeneratedField::MaxParallelism => {
12746 if max_parallelism__.is_some() {
12747 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12748 }
12749 max_parallelism__ =
12750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12751 ;
12752 }
12753 GeneratedField::Name => {
12754 if name__.is_some() {
12755 return Err(serde::de::Error::duplicate_field("name"));
12756 }
12757 name__ = Some(map_.next_value()?);
12758 }
12759 GeneratedField::ResourceGroup => {
12760 if resource_group__.is_some() {
12761 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12762 }
12763 resource_group__ = Some(map_.next_value()?);
12764 }
12765 GeneratedField::ConfigOverride => {
12766 if config_override__.is_some() {
12767 return Err(serde::de::Error::duplicate_field("configOverride"));
12768 }
12769 config_override__ = Some(map_.next_value()?);
12770 }
12771 GeneratedField::DatabaseId => {
12772 if database_id__.is_some() {
12773 return Err(serde::de::Error::duplicate_field("databaseId"));
12774 }
12775 database_id__ =
12776 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12777 ;
12778 }
12779 GeneratedField::SchemaId => {
12780 if schema_id__.is_some() {
12781 return Err(serde::de::Error::duplicate_field("schemaId"));
12782 }
12783 schema_id__ =
12784 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12785 ;
12786 }
12787 GeneratedField::AdaptiveParallelismStrategy => {
12788 if adaptive_parallelism_strategy__.is_some() {
12789 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12790 }
12791 adaptive_parallelism_strategy__ = map_.next_value()?;
12792 }
12793 }
12794 }
12795 Ok(list_streaming_job_states_response::StreamingJobState {
12796 table_id: table_id__.unwrap_or_default(),
12797 state: state__.unwrap_or_default(),
12798 parallelism: parallelism__,
12799 max_parallelism: max_parallelism__.unwrap_or_default(),
12800 name: name__.unwrap_or_default(),
12801 resource_group: resource_group__.unwrap_or_default(),
12802 config_override: config_override__.unwrap_or_default(),
12803 database_id: database_id__.unwrap_or_default(),
12804 schema_id: schema_id__.unwrap_or_default(),
12805 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
12806 })
12807 }
12808 }
12809 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12810 }
12811}
12812impl serde::Serialize for ListTableFragmentsRequest {
12813 #[allow(deprecated)]
12814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12815 where
12816 S: serde::Serializer,
12817 {
12818 use serde::ser::SerializeStruct;
12819 let mut len = 0;
12820 if !self.table_ids.is_empty() {
12821 len += 1;
12822 }
12823 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12824 if !self.table_ids.is_empty() {
12825 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12826 }
12827 struct_ser.end()
12828 }
12829}
12830impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12831 #[allow(deprecated)]
12832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12833 where
12834 D: serde::Deserializer<'de>,
12835 {
12836 const FIELDS: &[&str] = &[
12837 "table_ids",
12838 "tableIds",
12839 ];
12840
12841 #[allow(clippy::enum_variant_names)]
12842 enum GeneratedField {
12843 TableIds,
12844 }
12845 impl<'de> serde::Deserialize<'de> for GeneratedField {
12846 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12847 where
12848 D: serde::Deserializer<'de>,
12849 {
12850 struct GeneratedVisitor;
12851
12852 impl serde::de::Visitor<'_> for GeneratedVisitor {
12853 type Value = GeneratedField;
12854
12855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12856 write!(formatter, "expected one of: {:?}", &FIELDS)
12857 }
12858
12859 #[allow(unused_variables)]
12860 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12861 where
12862 E: serde::de::Error,
12863 {
12864 match value {
12865 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12866 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12867 }
12868 }
12869 }
12870 deserializer.deserialize_identifier(GeneratedVisitor)
12871 }
12872 }
12873 struct GeneratedVisitor;
12874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12875 type Value = ListTableFragmentsRequest;
12876
12877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12878 formatter.write_str("struct meta.ListTableFragmentsRequest")
12879 }
12880
12881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12882 where
12883 V: serde::de::MapAccess<'de>,
12884 {
12885 let mut table_ids__ = None;
12886 while let Some(k) = map_.next_key()? {
12887 match k {
12888 GeneratedField::TableIds => {
12889 if table_ids__.is_some() {
12890 return Err(serde::de::Error::duplicate_field("tableIds"));
12891 }
12892 table_ids__ =
12893 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12894 .into_iter().map(|x| x.0).collect())
12895 ;
12896 }
12897 }
12898 }
12899 Ok(ListTableFragmentsRequest {
12900 table_ids: table_ids__.unwrap_or_default(),
12901 })
12902 }
12903 }
12904 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12905 }
12906}
12907impl serde::Serialize for ListTableFragmentsResponse {
12908 #[allow(deprecated)]
12909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12910 where
12911 S: serde::Serializer,
12912 {
12913 use serde::ser::SerializeStruct;
12914 let mut len = 0;
12915 if !self.table_fragments.is_empty() {
12916 len += 1;
12917 }
12918 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12919 if !self.table_fragments.is_empty() {
12920 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12921 }
12922 struct_ser.end()
12923 }
12924}
12925impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12926 #[allow(deprecated)]
12927 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12928 where
12929 D: serde::Deserializer<'de>,
12930 {
12931 const FIELDS: &[&str] = &[
12932 "table_fragments",
12933 "tableFragments",
12934 ];
12935
12936 #[allow(clippy::enum_variant_names)]
12937 enum GeneratedField {
12938 TableFragments,
12939 }
12940 impl<'de> serde::Deserialize<'de> for GeneratedField {
12941 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12942 where
12943 D: serde::Deserializer<'de>,
12944 {
12945 struct GeneratedVisitor;
12946
12947 impl serde::de::Visitor<'_> for GeneratedVisitor {
12948 type Value = GeneratedField;
12949
12950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12951 write!(formatter, "expected one of: {:?}", &FIELDS)
12952 }
12953
12954 #[allow(unused_variables)]
12955 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12956 where
12957 E: serde::de::Error,
12958 {
12959 match value {
12960 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
12961 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12962 }
12963 }
12964 }
12965 deserializer.deserialize_identifier(GeneratedVisitor)
12966 }
12967 }
12968 struct GeneratedVisitor;
12969 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12970 type Value = ListTableFragmentsResponse;
12971
12972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12973 formatter.write_str("struct meta.ListTableFragmentsResponse")
12974 }
12975
12976 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12977 where
12978 V: serde::de::MapAccess<'de>,
12979 {
12980 let mut table_fragments__ = None;
12981 while let Some(k) = map_.next_key()? {
12982 match k {
12983 GeneratedField::TableFragments => {
12984 if table_fragments__.is_some() {
12985 return Err(serde::de::Error::duplicate_field("tableFragments"));
12986 }
12987 table_fragments__ = Some(
12988 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12989 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12990 );
12991 }
12992 }
12993 }
12994 Ok(ListTableFragmentsResponse {
12995 table_fragments: table_fragments__.unwrap_or_default(),
12996 })
12997 }
12998 }
12999 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
13000 }
13001}
13002impl serde::Serialize for list_table_fragments_response::ActorInfo {
13003 #[allow(deprecated)]
13004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13005 where
13006 S: serde::Serializer,
13007 {
13008 use serde::ser::SerializeStruct;
13009 let mut len = 0;
13010 if self.id != 0 {
13011 len += 1;
13012 }
13013 if self.node.is_some() {
13014 len += 1;
13015 }
13016 if !self.dispatcher.is_empty() {
13017 len += 1;
13018 }
13019 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
13020 if self.id != 0 {
13021 struct_ser.serialize_field("id", &self.id)?;
13022 }
13023 if let Some(v) = self.node.as_ref() {
13024 struct_ser.serialize_field("node", v)?;
13025 }
13026 if !self.dispatcher.is_empty() {
13027 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
13028 }
13029 struct_ser.end()
13030 }
13031}
13032impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
13033 #[allow(deprecated)]
13034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13035 where
13036 D: serde::Deserializer<'de>,
13037 {
13038 const FIELDS: &[&str] = &[
13039 "id",
13040 "node",
13041 "dispatcher",
13042 ];
13043
13044 #[allow(clippy::enum_variant_names)]
13045 enum GeneratedField {
13046 Id,
13047 Node,
13048 Dispatcher,
13049 }
13050 impl<'de> serde::Deserialize<'de> for GeneratedField {
13051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13052 where
13053 D: serde::Deserializer<'de>,
13054 {
13055 struct GeneratedVisitor;
13056
13057 impl serde::de::Visitor<'_> for GeneratedVisitor {
13058 type Value = GeneratedField;
13059
13060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13061 write!(formatter, "expected one of: {:?}", &FIELDS)
13062 }
13063
13064 #[allow(unused_variables)]
13065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13066 where
13067 E: serde::de::Error,
13068 {
13069 match value {
13070 "id" => Ok(GeneratedField::Id),
13071 "node" => Ok(GeneratedField::Node),
13072 "dispatcher" => Ok(GeneratedField::Dispatcher),
13073 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13074 }
13075 }
13076 }
13077 deserializer.deserialize_identifier(GeneratedVisitor)
13078 }
13079 }
13080 struct GeneratedVisitor;
13081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13082 type Value = list_table_fragments_response::ActorInfo;
13083
13084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13085 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
13086 }
13087
13088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
13089 where
13090 V: serde::de::MapAccess<'de>,
13091 {
13092 let mut id__ = None;
13093 let mut node__ = None;
13094 let mut dispatcher__ = None;
13095 while let Some(k) = map_.next_key()? {
13096 match k {
13097 GeneratedField::Id => {
13098 if id__.is_some() {
13099 return Err(serde::de::Error::duplicate_field("id"));
13100 }
13101 id__ =
13102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13103 ;
13104 }
13105 GeneratedField::Node => {
13106 if node__.is_some() {
13107 return Err(serde::de::Error::duplicate_field("node"));
13108 }
13109 node__ = map_.next_value()?;
13110 }
13111 GeneratedField::Dispatcher => {
13112 if dispatcher__.is_some() {
13113 return Err(serde::de::Error::duplicate_field("dispatcher"));
13114 }
13115 dispatcher__ = Some(map_.next_value()?);
13116 }
13117 }
13118 }
13119 Ok(list_table_fragments_response::ActorInfo {
13120 id: id__.unwrap_or_default(),
13121 node: node__,
13122 dispatcher: dispatcher__.unwrap_or_default(),
13123 })
13124 }
13125 }
13126 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
13127 }
13128}
13129impl serde::Serialize for list_table_fragments_response::FragmentInfo {
13130 #[allow(deprecated)]
13131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13132 where
13133 S: serde::Serializer,
13134 {
13135 use serde::ser::SerializeStruct;
13136 let mut len = 0;
13137 if self.id != 0 {
13138 len += 1;
13139 }
13140 if !self.actors.is_empty() {
13141 len += 1;
13142 }
13143 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
13144 if self.id != 0 {
13145 struct_ser.serialize_field("id", &self.id)?;
13146 }
13147 if !self.actors.is_empty() {
13148 struct_ser.serialize_field("actors", &self.actors)?;
13149 }
13150 struct_ser.end()
13151 }
13152}
13153impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
13154 #[allow(deprecated)]
13155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13156 where
13157 D: serde::Deserializer<'de>,
13158 {
13159 const FIELDS: &[&str] = &[
13160 "id",
13161 "actors",
13162 ];
13163
13164 #[allow(clippy::enum_variant_names)]
13165 enum GeneratedField {
13166 Id,
13167 Actors,
13168 }
13169 impl<'de> serde::Deserialize<'de> for GeneratedField {
13170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13171 where
13172 D: serde::Deserializer<'de>,
13173 {
13174 struct GeneratedVisitor;
13175
13176 impl serde::de::Visitor<'_> for GeneratedVisitor {
13177 type Value = GeneratedField;
13178
13179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13180 write!(formatter, "expected one of: {:?}", &FIELDS)
13181 }
13182
13183 #[allow(unused_variables)]
13184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13185 where
13186 E: serde::de::Error,
13187 {
13188 match value {
13189 "id" => Ok(GeneratedField::Id),
13190 "actors" => Ok(GeneratedField::Actors),
13191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13192 }
13193 }
13194 }
13195 deserializer.deserialize_identifier(GeneratedVisitor)
13196 }
13197 }
13198 struct GeneratedVisitor;
13199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13200 type Value = list_table_fragments_response::FragmentInfo;
13201
13202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13203 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
13204 }
13205
13206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
13207 where
13208 V: serde::de::MapAccess<'de>,
13209 {
13210 let mut id__ = None;
13211 let mut actors__ = None;
13212 while let Some(k) = map_.next_key()? {
13213 match k {
13214 GeneratedField::Id => {
13215 if id__.is_some() {
13216 return Err(serde::de::Error::duplicate_field("id"));
13217 }
13218 id__ =
13219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13220 ;
13221 }
13222 GeneratedField::Actors => {
13223 if actors__.is_some() {
13224 return Err(serde::de::Error::duplicate_field("actors"));
13225 }
13226 actors__ = Some(map_.next_value()?);
13227 }
13228 }
13229 }
13230 Ok(list_table_fragments_response::FragmentInfo {
13231 id: id__.unwrap_or_default(),
13232 actors: actors__.unwrap_or_default(),
13233 })
13234 }
13235 }
13236 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
13237 }
13238}
13239impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
13240 #[allow(deprecated)]
13241 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13242 where
13243 S: serde::Serializer,
13244 {
13245 use serde::ser::SerializeStruct;
13246 let mut len = 0;
13247 if !self.fragments.is_empty() {
13248 len += 1;
13249 }
13250 if self.ctx.is_some() {
13251 len += 1;
13252 }
13253 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
13254 if !self.fragments.is_empty() {
13255 struct_ser.serialize_field("fragments", &self.fragments)?;
13256 }
13257 if let Some(v) = self.ctx.as_ref() {
13258 struct_ser.serialize_field("ctx", v)?;
13259 }
13260 struct_ser.end()
13261 }
13262}
13263impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
13264 #[allow(deprecated)]
13265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13266 where
13267 D: serde::Deserializer<'de>,
13268 {
13269 const FIELDS: &[&str] = &[
13270 "fragments",
13271 "ctx",
13272 ];
13273
13274 #[allow(clippy::enum_variant_names)]
13275 enum GeneratedField {
13276 Fragments,
13277 Ctx,
13278 }
13279 impl<'de> serde::Deserialize<'de> for GeneratedField {
13280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13281 where
13282 D: serde::Deserializer<'de>,
13283 {
13284 struct GeneratedVisitor;
13285
13286 impl serde::de::Visitor<'_> for GeneratedVisitor {
13287 type Value = GeneratedField;
13288
13289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13290 write!(formatter, "expected one of: {:?}", &FIELDS)
13291 }
13292
13293 #[allow(unused_variables)]
13294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13295 where
13296 E: serde::de::Error,
13297 {
13298 match value {
13299 "fragments" => Ok(GeneratedField::Fragments),
13300 "ctx" => Ok(GeneratedField::Ctx),
13301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13302 }
13303 }
13304 }
13305 deserializer.deserialize_identifier(GeneratedVisitor)
13306 }
13307 }
13308 struct GeneratedVisitor;
13309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13310 type Value = list_table_fragments_response::TableFragmentInfo;
13311
13312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13313 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
13314 }
13315
13316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
13317 where
13318 V: serde::de::MapAccess<'de>,
13319 {
13320 let mut fragments__ = None;
13321 let mut ctx__ = None;
13322 while let Some(k) = map_.next_key()? {
13323 match k {
13324 GeneratedField::Fragments => {
13325 if fragments__.is_some() {
13326 return Err(serde::de::Error::duplicate_field("fragments"));
13327 }
13328 fragments__ = Some(map_.next_value()?);
13329 }
13330 GeneratedField::Ctx => {
13331 if ctx__.is_some() {
13332 return Err(serde::de::Error::duplicate_field("ctx"));
13333 }
13334 ctx__ = map_.next_value()?;
13335 }
13336 }
13337 }
13338 Ok(list_table_fragments_response::TableFragmentInfo {
13339 fragments: fragments__.unwrap_or_default(),
13340 ctx: ctx__,
13341 })
13342 }
13343 }
13344 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
13345 }
13346}
13347impl serde::Serialize for ListUnmigratedTablesRequest {
13348 #[allow(deprecated)]
13349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13350 where
13351 S: serde::Serializer,
13352 {
13353 use serde::ser::SerializeStruct;
13354 let len = 0;
13355 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
13356 struct_ser.end()
13357 }
13358}
13359impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
13360 #[allow(deprecated)]
13361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13362 where
13363 D: serde::Deserializer<'de>,
13364 {
13365 const FIELDS: &[&str] = &[
13366 ];
13367
13368 #[allow(clippy::enum_variant_names)]
13369 enum GeneratedField {
13370 }
13371 impl<'de> serde::Deserialize<'de> for GeneratedField {
13372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13373 where
13374 D: serde::Deserializer<'de>,
13375 {
13376 struct GeneratedVisitor;
13377
13378 impl serde::de::Visitor<'_> for GeneratedVisitor {
13379 type Value = GeneratedField;
13380
13381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13382 write!(formatter, "expected one of: {:?}", &FIELDS)
13383 }
13384
13385 #[allow(unused_variables)]
13386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13387 where
13388 E: serde::de::Error,
13389 {
13390 Err(serde::de::Error::unknown_field(value, FIELDS))
13391 }
13392 }
13393 deserializer.deserialize_identifier(GeneratedVisitor)
13394 }
13395 }
13396 struct GeneratedVisitor;
13397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13398 type Value = ListUnmigratedTablesRequest;
13399
13400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13401 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
13402 }
13403
13404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
13405 where
13406 V: serde::de::MapAccess<'de>,
13407 {
13408 while map_.next_key::<GeneratedField>()?.is_some() {
13409 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13410 }
13411 Ok(ListUnmigratedTablesRequest {
13412 })
13413 }
13414 }
13415 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
13416 }
13417}
13418impl serde::Serialize for ListUnmigratedTablesResponse {
13419 #[allow(deprecated)]
13420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13421 where
13422 S: serde::Serializer,
13423 {
13424 use serde::ser::SerializeStruct;
13425 let mut len = 0;
13426 if !self.tables.is_empty() {
13427 len += 1;
13428 }
13429 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
13430 if !self.tables.is_empty() {
13431 struct_ser.serialize_field("tables", &self.tables)?;
13432 }
13433 struct_ser.end()
13434 }
13435}
13436impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
13437 #[allow(deprecated)]
13438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13439 where
13440 D: serde::Deserializer<'de>,
13441 {
13442 const FIELDS: &[&str] = &[
13443 "tables",
13444 ];
13445
13446 #[allow(clippy::enum_variant_names)]
13447 enum GeneratedField {
13448 Tables,
13449 }
13450 impl<'de> serde::Deserialize<'de> for GeneratedField {
13451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13452 where
13453 D: serde::Deserializer<'de>,
13454 {
13455 struct GeneratedVisitor;
13456
13457 impl serde::de::Visitor<'_> for GeneratedVisitor {
13458 type Value = GeneratedField;
13459
13460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13461 write!(formatter, "expected one of: {:?}", &FIELDS)
13462 }
13463
13464 #[allow(unused_variables)]
13465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13466 where
13467 E: serde::de::Error,
13468 {
13469 match value {
13470 "tables" => Ok(GeneratedField::Tables),
13471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13472 }
13473 }
13474 }
13475 deserializer.deserialize_identifier(GeneratedVisitor)
13476 }
13477 }
13478 struct GeneratedVisitor;
13479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13480 type Value = ListUnmigratedTablesResponse;
13481
13482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13483 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
13484 }
13485
13486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
13487 where
13488 V: serde::de::MapAccess<'de>,
13489 {
13490 let mut tables__ = None;
13491 while let Some(k) = map_.next_key()? {
13492 match k {
13493 GeneratedField::Tables => {
13494 if tables__.is_some() {
13495 return Err(serde::de::Error::duplicate_field("tables"));
13496 }
13497 tables__ = Some(map_.next_value()?);
13498 }
13499 }
13500 }
13501 Ok(ListUnmigratedTablesResponse {
13502 tables: tables__.unwrap_or_default(),
13503 })
13504 }
13505 }
13506 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
13507 }
13508}
13509impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
13510 #[allow(deprecated)]
13511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13512 where
13513 S: serde::Serializer,
13514 {
13515 use serde::ser::SerializeStruct;
13516 let mut len = 0;
13517 if self.table_id != 0 {
13518 len += 1;
13519 }
13520 if !self.table_name.is_empty() {
13521 len += 1;
13522 }
13523 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
13524 if self.table_id != 0 {
13525 struct_ser.serialize_field("tableId", &self.table_id)?;
13526 }
13527 if !self.table_name.is_empty() {
13528 struct_ser.serialize_field("tableName", &self.table_name)?;
13529 }
13530 struct_ser.end()
13531 }
13532}
13533impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
13534 #[allow(deprecated)]
13535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13536 where
13537 D: serde::Deserializer<'de>,
13538 {
13539 const FIELDS: &[&str] = &[
13540 "table_id",
13541 "tableId",
13542 "table_name",
13543 "tableName",
13544 ];
13545
13546 #[allow(clippy::enum_variant_names)]
13547 enum GeneratedField {
13548 TableId,
13549 TableName,
13550 }
13551 impl<'de> serde::Deserialize<'de> for GeneratedField {
13552 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13553 where
13554 D: serde::Deserializer<'de>,
13555 {
13556 struct GeneratedVisitor;
13557
13558 impl serde::de::Visitor<'_> for GeneratedVisitor {
13559 type Value = GeneratedField;
13560
13561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13562 write!(formatter, "expected one of: {:?}", &FIELDS)
13563 }
13564
13565 #[allow(unused_variables)]
13566 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13567 where
13568 E: serde::de::Error,
13569 {
13570 match value {
13571 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13572 "tableName" | "table_name" => Ok(GeneratedField::TableName),
13573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13574 }
13575 }
13576 }
13577 deserializer.deserialize_identifier(GeneratedVisitor)
13578 }
13579 }
13580 struct GeneratedVisitor;
13581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13582 type Value = list_unmigrated_tables_response::UnmigratedTable;
13583
13584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13585 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
13586 }
13587
13588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
13589 where
13590 V: serde::de::MapAccess<'de>,
13591 {
13592 let mut table_id__ = None;
13593 let mut table_name__ = None;
13594 while let Some(k) = map_.next_key()? {
13595 match k {
13596 GeneratedField::TableId => {
13597 if table_id__.is_some() {
13598 return Err(serde::de::Error::duplicate_field("tableId"));
13599 }
13600 table_id__ =
13601 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13602 ;
13603 }
13604 GeneratedField::TableName => {
13605 if table_name__.is_some() {
13606 return Err(serde::de::Error::duplicate_field("tableName"));
13607 }
13608 table_name__ = Some(map_.next_value()?);
13609 }
13610 }
13611 }
13612 Ok(list_unmigrated_tables_response::UnmigratedTable {
13613 table_id: table_id__.unwrap_or_default(),
13614 table_name: table_name__.unwrap_or_default(),
13615 })
13616 }
13617 }
13618 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13619 }
13620}
13621impl serde::Serialize for MembersRequest {
13622 #[allow(deprecated)]
13623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13624 where
13625 S: serde::Serializer,
13626 {
13627 use serde::ser::SerializeStruct;
13628 let len = 0;
13629 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13630 struct_ser.end()
13631 }
13632}
13633impl<'de> serde::Deserialize<'de> for MembersRequest {
13634 #[allow(deprecated)]
13635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13636 where
13637 D: serde::Deserializer<'de>,
13638 {
13639 const FIELDS: &[&str] = &[
13640 ];
13641
13642 #[allow(clippy::enum_variant_names)]
13643 enum GeneratedField {
13644 }
13645 impl<'de> serde::Deserialize<'de> for GeneratedField {
13646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13647 where
13648 D: serde::Deserializer<'de>,
13649 {
13650 struct GeneratedVisitor;
13651
13652 impl serde::de::Visitor<'_> for GeneratedVisitor {
13653 type Value = GeneratedField;
13654
13655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13656 write!(formatter, "expected one of: {:?}", &FIELDS)
13657 }
13658
13659 #[allow(unused_variables)]
13660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13661 where
13662 E: serde::de::Error,
13663 {
13664 Err(serde::de::Error::unknown_field(value, FIELDS))
13665 }
13666 }
13667 deserializer.deserialize_identifier(GeneratedVisitor)
13668 }
13669 }
13670 struct GeneratedVisitor;
13671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13672 type Value = MembersRequest;
13673
13674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13675 formatter.write_str("struct meta.MembersRequest")
13676 }
13677
13678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13679 where
13680 V: serde::de::MapAccess<'de>,
13681 {
13682 while map_.next_key::<GeneratedField>()?.is_some() {
13683 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13684 }
13685 Ok(MembersRequest {
13686 })
13687 }
13688 }
13689 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13690 }
13691}
13692impl serde::Serialize for MembersResponse {
13693 #[allow(deprecated)]
13694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13695 where
13696 S: serde::Serializer,
13697 {
13698 use serde::ser::SerializeStruct;
13699 let mut len = 0;
13700 if !self.members.is_empty() {
13701 len += 1;
13702 }
13703 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13704 if !self.members.is_empty() {
13705 struct_ser.serialize_field("members", &self.members)?;
13706 }
13707 struct_ser.end()
13708 }
13709}
13710impl<'de> serde::Deserialize<'de> for MembersResponse {
13711 #[allow(deprecated)]
13712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13713 where
13714 D: serde::Deserializer<'de>,
13715 {
13716 const FIELDS: &[&str] = &[
13717 "members",
13718 ];
13719
13720 #[allow(clippy::enum_variant_names)]
13721 enum GeneratedField {
13722 Members,
13723 }
13724 impl<'de> serde::Deserialize<'de> for GeneratedField {
13725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13726 where
13727 D: serde::Deserializer<'de>,
13728 {
13729 struct GeneratedVisitor;
13730
13731 impl serde::de::Visitor<'_> for GeneratedVisitor {
13732 type Value = GeneratedField;
13733
13734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13735 write!(formatter, "expected one of: {:?}", &FIELDS)
13736 }
13737
13738 #[allow(unused_variables)]
13739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13740 where
13741 E: serde::de::Error,
13742 {
13743 match value {
13744 "members" => Ok(GeneratedField::Members),
13745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13746 }
13747 }
13748 }
13749 deserializer.deserialize_identifier(GeneratedVisitor)
13750 }
13751 }
13752 struct GeneratedVisitor;
13753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13754 type Value = MembersResponse;
13755
13756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13757 formatter.write_str("struct meta.MembersResponse")
13758 }
13759
13760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13761 where
13762 V: serde::de::MapAccess<'de>,
13763 {
13764 let mut members__ = None;
13765 while let Some(k) = map_.next_key()? {
13766 match k {
13767 GeneratedField::Members => {
13768 if members__.is_some() {
13769 return Err(serde::de::Error::duplicate_field("members"));
13770 }
13771 members__ = Some(map_.next_value()?);
13772 }
13773 }
13774 }
13775 Ok(MembersResponse {
13776 members: members__.unwrap_or_default(),
13777 })
13778 }
13779 }
13780 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13781 }
13782}
13783impl serde::Serialize for MetaMember {
13784 #[allow(deprecated)]
13785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13786 where
13787 S: serde::Serializer,
13788 {
13789 use serde::ser::SerializeStruct;
13790 let mut len = 0;
13791 if self.address.is_some() {
13792 len += 1;
13793 }
13794 if self.is_leader {
13795 len += 1;
13796 }
13797 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13798 if let Some(v) = self.address.as_ref() {
13799 struct_ser.serialize_field("address", v)?;
13800 }
13801 if self.is_leader {
13802 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13803 }
13804 struct_ser.end()
13805 }
13806}
13807impl<'de> serde::Deserialize<'de> for MetaMember {
13808 #[allow(deprecated)]
13809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13810 where
13811 D: serde::Deserializer<'de>,
13812 {
13813 const FIELDS: &[&str] = &[
13814 "address",
13815 "is_leader",
13816 "isLeader",
13817 ];
13818
13819 #[allow(clippy::enum_variant_names)]
13820 enum GeneratedField {
13821 Address,
13822 IsLeader,
13823 }
13824 impl<'de> serde::Deserialize<'de> for GeneratedField {
13825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13826 where
13827 D: serde::Deserializer<'de>,
13828 {
13829 struct GeneratedVisitor;
13830
13831 impl serde::de::Visitor<'_> for GeneratedVisitor {
13832 type Value = GeneratedField;
13833
13834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13835 write!(formatter, "expected one of: {:?}", &FIELDS)
13836 }
13837
13838 #[allow(unused_variables)]
13839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13840 where
13841 E: serde::de::Error,
13842 {
13843 match value {
13844 "address" => Ok(GeneratedField::Address),
13845 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13847 }
13848 }
13849 }
13850 deserializer.deserialize_identifier(GeneratedVisitor)
13851 }
13852 }
13853 struct GeneratedVisitor;
13854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13855 type Value = MetaMember;
13856
13857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13858 formatter.write_str("struct meta.MetaMember")
13859 }
13860
13861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13862 where
13863 V: serde::de::MapAccess<'de>,
13864 {
13865 let mut address__ = None;
13866 let mut is_leader__ = None;
13867 while let Some(k) = map_.next_key()? {
13868 match k {
13869 GeneratedField::Address => {
13870 if address__.is_some() {
13871 return Err(serde::de::Error::duplicate_field("address"));
13872 }
13873 address__ = map_.next_value()?;
13874 }
13875 GeneratedField::IsLeader => {
13876 if is_leader__.is_some() {
13877 return Err(serde::de::Error::duplicate_field("isLeader"));
13878 }
13879 is_leader__ = Some(map_.next_value()?);
13880 }
13881 }
13882 }
13883 Ok(MetaMember {
13884 address: address__,
13885 is_leader: is_leader__.unwrap_or_default(),
13886 })
13887 }
13888 }
13889 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13890 }
13891}
13892impl serde::Serialize for MetaSnapshot {
13893 #[allow(deprecated)]
13894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13895 where
13896 S: serde::Serializer,
13897 {
13898 use serde::ser::SerializeStruct;
13899 let mut len = 0;
13900 if !self.databases.is_empty() {
13901 len += 1;
13902 }
13903 if !self.schemas.is_empty() {
13904 len += 1;
13905 }
13906 if !self.sources.is_empty() {
13907 len += 1;
13908 }
13909 if !self.sinks.is_empty() {
13910 len += 1;
13911 }
13912 if !self.tables.is_empty() {
13913 len += 1;
13914 }
13915 if !self.indexes.is_empty() {
13916 len += 1;
13917 }
13918 if !self.views.is_empty() {
13919 len += 1;
13920 }
13921 if !self.functions.is_empty() {
13922 len += 1;
13923 }
13924 if !self.connections.is_empty() {
13925 len += 1;
13926 }
13927 if !self.subscriptions.is_empty() {
13928 len += 1;
13929 }
13930 if !self.users.is_empty() {
13931 len += 1;
13932 }
13933 if self.session_params.is_some() {
13934 len += 1;
13935 }
13936 if !self.secrets.is_empty() {
13937 len += 1;
13938 }
13939 if self.cluster_resource.is_some() {
13940 len += 1;
13941 }
13942 if !self.nodes.is_empty() {
13943 len += 1;
13944 }
13945 if self.hummock_version.is_some() {
13946 len += 1;
13947 }
13948 if self.meta_backup_manifest_id.is_some() {
13949 len += 1;
13950 }
13951 if self.hummock_write_limits.is_some() {
13952 len += 1;
13953 }
13954 if !self.streaming_worker_slot_mappings.is_empty() {
13955 len += 1;
13956 }
13957 if !self.serving_worker_slot_mappings.is_empty() {
13958 len += 1;
13959 }
13960 if !self.object_dependencies.is_empty() {
13961 len += 1;
13962 }
13963 if self.table_refill_runtime_config.is_some() {
13964 len += 1;
13965 }
13966 if self.version.is_some() {
13967 len += 1;
13968 }
13969 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13970 if !self.databases.is_empty() {
13971 struct_ser.serialize_field("databases", &self.databases)?;
13972 }
13973 if !self.schemas.is_empty() {
13974 struct_ser.serialize_field("schemas", &self.schemas)?;
13975 }
13976 if !self.sources.is_empty() {
13977 struct_ser.serialize_field("sources", &self.sources)?;
13978 }
13979 if !self.sinks.is_empty() {
13980 struct_ser.serialize_field("sinks", &self.sinks)?;
13981 }
13982 if !self.tables.is_empty() {
13983 struct_ser.serialize_field("tables", &self.tables)?;
13984 }
13985 if !self.indexes.is_empty() {
13986 struct_ser.serialize_field("indexes", &self.indexes)?;
13987 }
13988 if !self.views.is_empty() {
13989 struct_ser.serialize_field("views", &self.views)?;
13990 }
13991 if !self.functions.is_empty() {
13992 struct_ser.serialize_field("functions", &self.functions)?;
13993 }
13994 if !self.connections.is_empty() {
13995 struct_ser.serialize_field("connections", &self.connections)?;
13996 }
13997 if !self.subscriptions.is_empty() {
13998 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13999 }
14000 if !self.users.is_empty() {
14001 struct_ser.serialize_field("users", &self.users)?;
14002 }
14003 if let Some(v) = self.session_params.as_ref() {
14004 struct_ser.serialize_field("sessionParams", v)?;
14005 }
14006 if !self.secrets.is_empty() {
14007 struct_ser.serialize_field("secrets", &self.secrets)?;
14008 }
14009 if let Some(v) = self.cluster_resource.as_ref() {
14010 struct_ser.serialize_field("clusterResource", v)?;
14011 }
14012 if !self.nodes.is_empty() {
14013 struct_ser.serialize_field("nodes", &self.nodes)?;
14014 }
14015 if let Some(v) = self.hummock_version.as_ref() {
14016 struct_ser.serialize_field("hummockVersion", v)?;
14017 }
14018 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
14019 struct_ser.serialize_field("metaBackupManifestId", v)?;
14020 }
14021 if let Some(v) = self.hummock_write_limits.as_ref() {
14022 struct_ser.serialize_field("hummockWriteLimits", v)?;
14023 }
14024 if !self.streaming_worker_slot_mappings.is_empty() {
14025 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
14026 }
14027 if !self.serving_worker_slot_mappings.is_empty() {
14028 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
14029 }
14030 if !self.object_dependencies.is_empty() {
14031 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
14032 }
14033 if let Some(v) = self.table_refill_runtime_config.as_ref() {
14034 struct_ser.serialize_field("tableRefillRuntimeConfig", v)?;
14035 }
14036 if let Some(v) = self.version.as_ref() {
14037 struct_ser.serialize_field("version", v)?;
14038 }
14039 struct_ser.end()
14040 }
14041}
14042impl<'de> serde::Deserialize<'de> for MetaSnapshot {
14043 #[allow(deprecated)]
14044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14045 where
14046 D: serde::Deserializer<'de>,
14047 {
14048 const FIELDS: &[&str] = &[
14049 "databases",
14050 "schemas",
14051 "sources",
14052 "sinks",
14053 "tables",
14054 "indexes",
14055 "views",
14056 "functions",
14057 "connections",
14058 "subscriptions",
14059 "users",
14060 "session_params",
14061 "sessionParams",
14062 "secrets",
14063 "cluster_resource",
14064 "clusterResource",
14065 "nodes",
14066 "hummock_version",
14067 "hummockVersion",
14068 "meta_backup_manifest_id",
14069 "metaBackupManifestId",
14070 "hummock_write_limits",
14071 "hummockWriteLimits",
14072 "streaming_worker_slot_mappings",
14073 "streamingWorkerSlotMappings",
14074 "serving_worker_slot_mappings",
14075 "servingWorkerSlotMappings",
14076 "object_dependencies",
14077 "objectDependencies",
14078 "table_refill_runtime_config",
14079 "tableRefillRuntimeConfig",
14080 "version",
14081 ];
14082
14083 #[allow(clippy::enum_variant_names)]
14084 enum GeneratedField {
14085 Databases,
14086 Schemas,
14087 Sources,
14088 Sinks,
14089 Tables,
14090 Indexes,
14091 Views,
14092 Functions,
14093 Connections,
14094 Subscriptions,
14095 Users,
14096 SessionParams,
14097 Secrets,
14098 ClusterResource,
14099 Nodes,
14100 HummockVersion,
14101 MetaBackupManifestId,
14102 HummockWriteLimits,
14103 StreamingWorkerSlotMappings,
14104 ServingWorkerSlotMappings,
14105 ObjectDependencies,
14106 TableRefillRuntimeConfig,
14107 Version,
14108 }
14109 impl<'de> serde::Deserialize<'de> for GeneratedField {
14110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14111 where
14112 D: serde::Deserializer<'de>,
14113 {
14114 struct GeneratedVisitor;
14115
14116 impl serde::de::Visitor<'_> for GeneratedVisitor {
14117 type Value = GeneratedField;
14118
14119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14120 write!(formatter, "expected one of: {:?}", &FIELDS)
14121 }
14122
14123 #[allow(unused_variables)]
14124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14125 where
14126 E: serde::de::Error,
14127 {
14128 match value {
14129 "databases" => Ok(GeneratedField::Databases),
14130 "schemas" => Ok(GeneratedField::Schemas),
14131 "sources" => Ok(GeneratedField::Sources),
14132 "sinks" => Ok(GeneratedField::Sinks),
14133 "tables" => Ok(GeneratedField::Tables),
14134 "indexes" => Ok(GeneratedField::Indexes),
14135 "views" => Ok(GeneratedField::Views),
14136 "functions" => Ok(GeneratedField::Functions),
14137 "connections" => Ok(GeneratedField::Connections),
14138 "subscriptions" => Ok(GeneratedField::Subscriptions),
14139 "users" => Ok(GeneratedField::Users),
14140 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
14141 "secrets" => Ok(GeneratedField::Secrets),
14142 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
14143 "nodes" => Ok(GeneratedField::Nodes),
14144 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
14145 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14146 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14147 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
14148 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14149 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
14150 "tableRefillRuntimeConfig" | "table_refill_runtime_config" => Ok(GeneratedField::TableRefillRuntimeConfig),
14151 "version" => Ok(GeneratedField::Version),
14152 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14153 }
14154 }
14155 }
14156 deserializer.deserialize_identifier(GeneratedVisitor)
14157 }
14158 }
14159 struct GeneratedVisitor;
14160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14161 type Value = MetaSnapshot;
14162
14163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14164 formatter.write_str("struct meta.MetaSnapshot")
14165 }
14166
14167 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
14168 where
14169 V: serde::de::MapAccess<'de>,
14170 {
14171 let mut databases__ = None;
14172 let mut schemas__ = None;
14173 let mut sources__ = None;
14174 let mut sinks__ = None;
14175 let mut tables__ = None;
14176 let mut indexes__ = None;
14177 let mut views__ = None;
14178 let mut functions__ = None;
14179 let mut connections__ = None;
14180 let mut subscriptions__ = None;
14181 let mut users__ = None;
14182 let mut session_params__ = None;
14183 let mut secrets__ = None;
14184 let mut cluster_resource__ = None;
14185 let mut nodes__ = None;
14186 let mut hummock_version__ = None;
14187 let mut meta_backup_manifest_id__ = None;
14188 let mut hummock_write_limits__ = None;
14189 let mut streaming_worker_slot_mappings__ = None;
14190 let mut serving_worker_slot_mappings__ = None;
14191 let mut object_dependencies__ = None;
14192 let mut table_refill_runtime_config__ = None;
14193 let mut version__ = None;
14194 while let Some(k) = map_.next_key()? {
14195 match k {
14196 GeneratedField::Databases => {
14197 if databases__.is_some() {
14198 return Err(serde::de::Error::duplicate_field("databases"));
14199 }
14200 databases__ = Some(map_.next_value()?);
14201 }
14202 GeneratedField::Schemas => {
14203 if schemas__.is_some() {
14204 return Err(serde::de::Error::duplicate_field("schemas"));
14205 }
14206 schemas__ = Some(map_.next_value()?);
14207 }
14208 GeneratedField::Sources => {
14209 if sources__.is_some() {
14210 return Err(serde::de::Error::duplicate_field("sources"));
14211 }
14212 sources__ = Some(map_.next_value()?);
14213 }
14214 GeneratedField::Sinks => {
14215 if sinks__.is_some() {
14216 return Err(serde::de::Error::duplicate_field("sinks"));
14217 }
14218 sinks__ = Some(map_.next_value()?);
14219 }
14220 GeneratedField::Tables => {
14221 if tables__.is_some() {
14222 return Err(serde::de::Error::duplicate_field("tables"));
14223 }
14224 tables__ = Some(map_.next_value()?);
14225 }
14226 GeneratedField::Indexes => {
14227 if indexes__.is_some() {
14228 return Err(serde::de::Error::duplicate_field("indexes"));
14229 }
14230 indexes__ = Some(map_.next_value()?);
14231 }
14232 GeneratedField::Views => {
14233 if views__.is_some() {
14234 return Err(serde::de::Error::duplicate_field("views"));
14235 }
14236 views__ = Some(map_.next_value()?);
14237 }
14238 GeneratedField::Functions => {
14239 if functions__.is_some() {
14240 return Err(serde::de::Error::duplicate_field("functions"));
14241 }
14242 functions__ = Some(map_.next_value()?);
14243 }
14244 GeneratedField::Connections => {
14245 if connections__.is_some() {
14246 return Err(serde::de::Error::duplicate_field("connections"));
14247 }
14248 connections__ = Some(map_.next_value()?);
14249 }
14250 GeneratedField::Subscriptions => {
14251 if subscriptions__.is_some() {
14252 return Err(serde::de::Error::duplicate_field("subscriptions"));
14253 }
14254 subscriptions__ = Some(map_.next_value()?);
14255 }
14256 GeneratedField::Users => {
14257 if users__.is_some() {
14258 return Err(serde::de::Error::duplicate_field("users"));
14259 }
14260 users__ = Some(map_.next_value()?);
14261 }
14262 GeneratedField::SessionParams => {
14263 if session_params__.is_some() {
14264 return Err(serde::de::Error::duplicate_field("sessionParams"));
14265 }
14266 session_params__ = map_.next_value()?;
14267 }
14268 GeneratedField::Secrets => {
14269 if secrets__.is_some() {
14270 return Err(serde::de::Error::duplicate_field("secrets"));
14271 }
14272 secrets__ = Some(map_.next_value()?);
14273 }
14274 GeneratedField::ClusterResource => {
14275 if cluster_resource__.is_some() {
14276 return Err(serde::de::Error::duplicate_field("clusterResource"));
14277 }
14278 cluster_resource__ = map_.next_value()?;
14279 }
14280 GeneratedField::Nodes => {
14281 if nodes__.is_some() {
14282 return Err(serde::de::Error::duplicate_field("nodes"));
14283 }
14284 nodes__ = Some(map_.next_value()?);
14285 }
14286 GeneratedField::HummockVersion => {
14287 if hummock_version__.is_some() {
14288 return Err(serde::de::Error::duplicate_field("hummockVersion"));
14289 }
14290 hummock_version__ = map_.next_value()?;
14291 }
14292 GeneratedField::MetaBackupManifestId => {
14293 if meta_backup_manifest_id__.is_some() {
14294 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14295 }
14296 meta_backup_manifest_id__ = map_.next_value()?;
14297 }
14298 GeneratedField::HummockWriteLimits => {
14299 if hummock_write_limits__.is_some() {
14300 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14301 }
14302 hummock_write_limits__ = map_.next_value()?;
14303 }
14304 GeneratedField::StreamingWorkerSlotMappings => {
14305 if streaming_worker_slot_mappings__.is_some() {
14306 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
14307 }
14308 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
14309 }
14310 GeneratedField::ServingWorkerSlotMappings => {
14311 if serving_worker_slot_mappings__.is_some() {
14312 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14313 }
14314 serving_worker_slot_mappings__ = Some(map_.next_value()?);
14315 }
14316 GeneratedField::ObjectDependencies => {
14317 if object_dependencies__.is_some() {
14318 return Err(serde::de::Error::duplicate_field("objectDependencies"));
14319 }
14320 object_dependencies__ = Some(map_.next_value()?);
14321 }
14322 GeneratedField::TableRefillRuntimeConfig => {
14323 if table_refill_runtime_config__.is_some() {
14324 return Err(serde::de::Error::duplicate_field("tableRefillRuntimeConfig"));
14325 }
14326 table_refill_runtime_config__ = map_.next_value()?;
14327 }
14328 GeneratedField::Version => {
14329 if version__.is_some() {
14330 return Err(serde::de::Error::duplicate_field("version"));
14331 }
14332 version__ = map_.next_value()?;
14333 }
14334 }
14335 }
14336 Ok(MetaSnapshot {
14337 databases: databases__.unwrap_or_default(),
14338 schemas: schemas__.unwrap_or_default(),
14339 sources: sources__.unwrap_or_default(),
14340 sinks: sinks__.unwrap_or_default(),
14341 tables: tables__.unwrap_or_default(),
14342 indexes: indexes__.unwrap_or_default(),
14343 views: views__.unwrap_or_default(),
14344 functions: functions__.unwrap_or_default(),
14345 connections: connections__.unwrap_or_default(),
14346 subscriptions: subscriptions__.unwrap_or_default(),
14347 users: users__.unwrap_or_default(),
14348 session_params: session_params__,
14349 secrets: secrets__.unwrap_or_default(),
14350 cluster_resource: cluster_resource__,
14351 nodes: nodes__.unwrap_or_default(),
14352 hummock_version: hummock_version__,
14353 meta_backup_manifest_id: meta_backup_manifest_id__,
14354 hummock_write_limits: hummock_write_limits__,
14355 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
14356 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
14357 object_dependencies: object_dependencies__.unwrap_or_default(),
14358 table_refill_runtime_config: table_refill_runtime_config__,
14359 version: version__,
14360 })
14361 }
14362 }
14363 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
14364 }
14365}
14366impl serde::Serialize for meta_snapshot::SnapshotVersion {
14367 #[allow(deprecated)]
14368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14369 where
14370 S: serde::Serializer,
14371 {
14372 use serde::ser::SerializeStruct;
14373 let mut len = 0;
14374 if self.catalog_version != 0 {
14375 len += 1;
14376 }
14377 if self.worker_node_version != 0 {
14378 len += 1;
14379 }
14380 if self.streaming_worker_slot_mapping_version != 0 {
14381 len += 1;
14382 }
14383 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
14384 if self.catalog_version != 0 {
14385 #[allow(clippy::needless_borrow)]
14386 #[allow(clippy::needless_borrows_for_generic_args)]
14387 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
14388 }
14389 if self.worker_node_version != 0 {
14390 #[allow(clippy::needless_borrow)]
14391 #[allow(clippy::needless_borrows_for_generic_args)]
14392 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
14393 }
14394 if self.streaming_worker_slot_mapping_version != 0 {
14395 #[allow(clippy::needless_borrow)]
14396 #[allow(clippy::needless_borrows_for_generic_args)]
14397 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
14398 }
14399 struct_ser.end()
14400 }
14401}
14402impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
14403 #[allow(deprecated)]
14404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14405 where
14406 D: serde::Deserializer<'de>,
14407 {
14408 const FIELDS: &[&str] = &[
14409 "catalog_version",
14410 "catalogVersion",
14411 "worker_node_version",
14412 "workerNodeVersion",
14413 "streaming_worker_slot_mapping_version",
14414 "streamingWorkerSlotMappingVersion",
14415 ];
14416
14417 #[allow(clippy::enum_variant_names)]
14418 enum GeneratedField {
14419 CatalogVersion,
14420 WorkerNodeVersion,
14421 StreamingWorkerSlotMappingVersion,
14422 }
14423 impl<'de> serde::Deserialize<'de> for GeneratedField {
14424 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14425 where
14426 D: serde::Deserializer<'de>,
14427 {
14428 struct GeneratedVisitor;
14429
14430 impl serde::de::Visitor<'_> for GeneratedVisitor {
14431 type Value = GeneratedField;
14432
14433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14434 write!(formatter, "expected one of: {:?}", &FIELDS)
14435 }
14436
14437 #[allow(unused_variables)]
14438 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14439 where
14440 E: serde::de::Error,
14441 {
14442 match value {
14443 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
14444 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
14445 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
14446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14447 }
14448 }
14449 }
14450 deserializer.deserialize_identifier(GeneratedVisitor)
14451 }
14452 }
14453 struct GeneratedVisitor;
14454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14455 type Value = meta_snapshot::SnapshotVersion;
14456
14457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14458 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
14459 }
14460
14461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
14462 where
14463 V: serde::de::MapAccess<'de>,
14464 {
14465 let mut catalog_version__ = None;
14466 let mut worker_node_version__ = None;
14467 let mut streaming_worker_slot_mapping_version__ = None;
14468 while let Some(k) = map_.next_key()? {
14469 match k {
14470 GeneratedField::CatalogVersion => {
14471 if catalog_version__.is_some() {
14472 return Err(serde::de::Error::duplicate_field("catalogVersion"));
14473 }
14474 catalog_version__ =
14475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14476 ;
14477 }
14478 GeneratedField::WorkerNodeVersion => {
14479 if worker_node_version__.is_some() {
14480 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
14481 }
14482 worker_node_version__ =
14483 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14484 ;
14485 }
14486 GeneratedField::StreamingWorkerSlotMappingVersion => {
14487 if streaming_worker_slot_mapping_version__.is_some() {
14488 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
14489 }
14490 streaming_worker_slot_mapping_version__ =
14491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14492 ;
14493 }
14494 }
14495 }
14496 Ok(meta_snapshot::SnapshotVersion {
14497 catalog_version: catalog_version__.unwrap_or_default(),
14498 worker_node_version: worker_node_version__.unwrap_or_default(),
14499 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
14500 })
14501 }
14502 }
14503 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
14504 }
14505}
14506impl serde::Serialize for MigrationPlan {
14507 #[allow(deprecated)]
14508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14509 where
14510 S: serde::Serializer,
14511 {
14512 use serde::ser::SerializeStruct;
14513 let mut len = 0;
14514 if !self.worker_slot_migration_plan.is_empty() {
14515 len += 1;
14516 }
14517 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
14518 if !self.worker_slot_migration_plan.is_empty() {
14519 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
14520 .map(|(k, v)| (k, v.to_string())).collect();
14521 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
14522 }
14523 struct_ser.end()
14524 }
14525}
14526impl<'de> serde::Deserialize<'de> for MigrationPlan {
14527 #[allow(deprecated)]
14528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14529 where
14530 D: serde::Deserializer<'de>,
14531 {
14532 const FIELDS: &[&str] = &[
14533 "worker_slot_migration_plan",
14534 "workerSlotMigrationPlan",
14535 ];
14536
14537 #[allow(clippy::enum_variant_names)]
14538 enum GeneratedField {
14539 WorkerSlotMigrationPlan,
14540 }
14541 impl<'de> serde::Deserialize<'de> for GeneratedField {
14542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14543 where
14544 D: serde::Deserializer<'de>,
14545 {
14546 struct GeneratedVisitor;
14547
14548 impl serde::de::Visitor<'_> for GeneratedVisitor {
14549 type Value = GeneratedField;
14550
14551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14552 write!(formatter, "expected one of: {:?}", &FIELDS)
14553 }
14554
14555 #[allow(unused_variables)]
14556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14557 where
14558 E: serde::de::Error,
14559 {
14560 match value {
14561 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
14562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14563 }
14564 }
14565 }
14566 deserializer.deserialize_identifier(GeneratedVisitor)
14567 }
14568 }
14569 struct GeneratedVisitor;
14570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14571 type Value = MigrationPlan;
14572
14573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14574 formatter.write_str("struct meta.MigrationPlan")
14575 }
14576
14577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
14578 where
14579 V: serde::de::MapAccess<'de>,
14580 {
14581 let mut worker_slot_migration_plan__ = None;
14582 while let Some(k) = map_.next_key()? {
14583 match k {
14584 GeneratedField::WorkerSlotMigrationPlan => {
14585 if worker_slot_migration_plan__.is_some() {
14586 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
14587 }
14588 worker_slot_migration_plan__ = Some(
14589 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14590 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
14591 );
14592 }
14593 }
14594 }
14595 Ok(MigrationPlan {
14596 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
14597 })
14598 }
14599 }
14600 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
14601 }
14602}
14603impl serde::Serialize for Object {
14604 #[allow(deprecated)]
14605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14606 where
14607 S: serde::Serializer,
14608 {
14609 use serde::ser::SerializeStruct;
14610 let mut len = 0;
14611 if self.object_info.is_some() {
14612 len += 1;
14613 }
14614 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
14615 if let Some(v) = self.object_info.as_ref() {
14616 match v {
14617 object::ObjectInfo::Database(v) => {
14618 struct_ser.serialize_field("database", v)?;
14619 }
14620 object::ObjectInfo::Schema(v) => {
14621 struct_ser.serialize_field("schema", v)?;
14622 }
14623 object::ObjectInfo::Table(v) => {
14624 struct_ser.serialize_field("table", v)?;
14625 }
14626 object::ObjectInfo::Index(v) => {
14627 struct_ser.serialize_field("index", v)?;
14628 }
14629 object::ObjectInfo::Source(v) => {
14630 struct_ser.serialize_field("source", v)?;
14631 }
14632 object::ObjectInfo::Sink(v) => {
14633 struct_ser.serialize_field("sink", v)?;
14634 }
14635 object::ObjectInfo::View(v) => {
14636 struct_ser.serialize_field("view", v)?;
14637 }
14638 object::ObjectInfo::Function(v) => {
14639 struct_ser.serialize_field("function", v)?;
14640 }
14641 object::ObjectInfo::Connection(v) => {
14642 struct_ser.serialize_field("connection", v)?;
14643 }
14644 object::ObjectInfo::Subscription(v) => {
14645 struct_ser.serialize_field("subscription", v)?;
14646 }
14647 object::ObjectInfo::Secret(v) => {
14648 struct_ser.serialize_field("secret", v)?;
14649 }
14650 }
14651 }
14652 struct_ser.end()
14653 }
14654}
14655impl<'de> serde::Deserialize<'de> for Object {
14656 #[allow(deprecated)]
14657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14658 where
14659 D: serde::Deserializer<'de>,
14660 {
14661 const FIELDS: &[&str] = &[
14662 "database",
14663 "schema",
14664 "table",
14665 "index",
14666 "source",
14667 "sink",
14668 "view",
14669 "function",
14670 "connection",
14671 "subscription",
14672 "secret",
14673 ];
14674
14675 #[allow(clippy::enum_variant_names)]
14676 enum GeneratedField {
14677 Database,
14678 Schema,
14679 Table,
14680 Index,
14681 Source,
14682 Sink,
14683 View,
14684 Function,
14685 Connection,
14686 Subscription,
14687 Secret,
14688 }
14689 impl<'de> serde::Deserialize<'de> for GeneratedField {
14690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14691 where
14692 D: serde::Deserializer<'de>,
14693 {
14694 struct GeneratedVisitor;
14695
14696 impl serde::de::Visitor<'_> for GeneratedVisitor {
14697 type Value = GeneratedField;
14698
14699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14700 write!(formatter, "expected one of: {:?}", &FIELDS)
14701 }
14702
14703 #[allow(unused_variables)]
14704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14705 where
14706 E: serde::de::Error,
14707 {
14708 match value {
14709 "database" => Ok(GeneratedField::Database),
14710 "schema" => Ok(GeneratedField::Schema),
14711 "table" => Ok(GeneratedField::Table),
14712 "index" => Ok(GeneratedField::Index),
14713 "source" => Ok(GeneratedField::Source),
14714 "sink" => Ok(GeneratedField::Sink),
14715 "view" => Ok(GeneratedField::View),
14716 "function" => Ok(GeneratedField::Function),
14717 "connection" => Ok(GeneratedField::Connection),
14718 "subscription" => Ok(GeneratedField::Subscription),
14719 "secret" => Ok(GeneratedField::Secret),
14720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14721 }
14722 }
14723 }
14724 deserializer.deserialize_identifier(GeneratedVisitor)
14725 }
14726 }
14727 struct GeneratedVisitor;
14728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14729 type Value = Object;
14730
14731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14732 formatter.write_str("struct meta.Object")
14733 }
14734
14735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14736 where
14737 V: serde::de::MapAccess<'de>,
14738 {
14739 let mut object_info__ = None;
14740 while let Some(k) = map_.next_key()? {
14741 match k {
14742 GeneratedField::Database => {
14743 if object_info__.is_some() {
14744 return Err(serde::de::Error::duplicate_field("database"));
14745 }
14746 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14747;
14748 }
14749 GeneratedField::Schema => {
14750 if object_info__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("schema"));
14752 }
14753 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14754;
14755 }
14756 GeneratedField::Table => {
14757 if object_info__.is_some() {
14758 return Err(serde::de::Error::duplicate_field("table"));
14759 }
14760 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14761;
14762 }
14763 GeneratedField::Index => {
14764 if object_info__.is_some() {
14765 return Err(serde::de::Error::duplicate_field("index"));
14766 }
14767 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14768;
14769 }
14770 GeneratedField::Source => {
14771 if object_info__.is_some() {
14772 return Err(serde::de::Error::duplicate_field("source"));
14773 }
14774 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14775;
14776 }
14777 GeneratedField::Sink => {
14778 if object_info__.is_some() {
14779 return Err(serde::de::Error::duplicate_field("sink"));
14780 }
14781 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14782;
14783 }
14784 GeneratedField::View => {
14785 if object_info__.is_some() {
14786 return Err(serde::de::Error::duplicate_field("view"));
14787 }
14788 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14789;
14790 }
14791 GeneratedField::Function => {
14792 if object_info__.is_some() {
14793 return Err(serde::de::Error::duplicate_field("function"));
14794 }
14795 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14796;
14797 }
14798 GeneratedField::Connection => {
14799 if object_info__.is_some() {
14800 return Err(serde::de::Error::duplicate_field("connection"));
14801 }
14802 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14803;
14804 }
14805 GeneratedField::Subscription => {
14806 if object_info__.is_some() {
14807 return Err(serde::de::Error::duplicate_field("subscription"));
14808 }
14809 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14810;
14811 }
14812 GeneratedField::Secret => {
14813 if object_info__.is_some() {
14814 return Err(serde::de::Error::duplicate_field("secret"));
14815 }
14816 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14817;
14818 }
14819 }
14820 }
14821 Ok(Object {
14822 object_info: object_info__,
14823 })
14824 }
14825 }
14826 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14827 }
14828}
14829impl serde::Serialize for ObjectDependency {
14830 #[allow(deprecated)]
14831 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14832 where
14833 S: serde::Serializer,
14834 {
14835 use serde::ser::SerializeStruct;
14836 let mut len = 0;
14837 if self.object_id != 0 {
14838 len += 1;
14839 }
14840 if self.referenced_object_id != 0 {
14841 len += 1;
14842 }
14843 if self.referenced_object_type != 0 {
14844 len += 1;
14845 }
14846 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14847 if self.object_id != 0 {
14848 struct_ser.serialize_field("objectId", &self.object_id)?;
14849 }
14850 if self.referenced_object_id != 0 {
14851 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14852 }
14853 if self.referenced_object_type != 0 {
14854 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14855 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14856 struct_ser.serialize_field("referencedObjectType", &v)?;
14857 }
14858 struct_ser.end()
14859 }
14860}
14861impl<'de> serde::Deserialize<'de> for ObjectDependency {
14862 #[allow(deprecated)]
14863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14864 where
14865 D: serde::Deserializer<'de>,
14866 {
14867 const FIELDS: &[&str] = &[
14868 "object_id",
14869 "objectId",
14870 "referenced_object_id",
14871 "referencedObjectId",
14872 "referenced_object_type",
14873 "referencedObjectType",
14874 ];
14875
14876 #[allow(clippy::enum_variant_names)]
14877 enum GeneratedField {
14878 ObjectId,
14879 ReferencedObjectId,
14880 ReferencedObjectType,
14881 }
14882 impl<'de> serde::Deserialize<'de> for GeneratedField {
14883 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14884 where
14885 D: serde::Deserializer<'de>,
14886 {
14887 struct GeneratedVisitor;
14888
14889 impl serde::de::Visitor<'_> for GeneratedVisitor {
14890 type Value = GeneratedField;
14891
14892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14893 write!(formatter, "expected one of: {:?}", &FIELDS)
14894 }
14895
14896 #[allow(unused_variables)]
14897 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14898 where
14899 E: serde::de::Error,
14900 {
14901 match value {
14902 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14903 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14904 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14906 }
14907 }
14908 }
14909 deserializer.deserialize_identifier(GeneratedVisitor)
14910 }
14911 }
14912 struct GeneratedVisitor;
14913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14914 type Value = ObjectDependency;
14915
14916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14917 formatter.write_str("struct meta.ObjectDependency")
14918 }
14919
14920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14921 where
14922 V: serde::de::MapAccess<'de>,
14923 {
14924 let mut object_id__ = None;
14925 let mut referenced_object_id__ = None;
14926 let mut referenced_object_type__ = None;
14927 while let Some(k) = map_.next_key()? {
14928 match k {
14929 GeneratedField::ObjectId => {
14930 if object_id__.is_some() {
14931 return Err(serde::de::Error::duplicate_field("objectId"));
14932 }
14933 object_id__ =
14934 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14935 ;
14936 }
14937 GeneratedField::ReferencedObjectId => {
14938 if referenced_object_id__.is_some() {
14939 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14940 }
14941 referenced_object_id__ =
14942 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14943 ;
14944 }
14945 GeneratedField::ReferencedObjectType => {
14946 if referenced_object_type__.is_some() {
14947 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14948 }
14949 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14950 }
14951 }
14952 }
14953 Ok(ObjectDependency {
14954 object_id: object_id__.unwrap_or_default(),
14955 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14956 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14957 })
14958 }
14959 }
14960 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14961 }
14962}
14963impl serde::Serialize for ObjectGroup {
14964 #[allow(deprecated)]
14965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14966 where
14967 S: serde::Serializer,
14968 {
14969 use serde::ser::SerializeStruct;
14970 let mut len = 0;
14971 if !self.objects.is_empty() {
14972 len += 1;
14973 }
14974 if !self.dependencies.is_empty() {
14975 len += 1;
14976 }
14977 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14978 if !self.objects.is_empty() {
14979 struct_ser.serialize_field("objects", &self.objects)?;
14980 }
14981 if !self.dependencies.is_empty() {
14982 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14983 }
14984 struct_ser.end()
14985 }
14986}
14987impl<'de> serde::Deserialize<'de> for ObjectGroup {
14988 #[allow(deprecated)]
14989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14990 where
14991 D: serde::Deserializer<'de>,
14992 {
14993 const FIELDS: &[&str] = &[
14994 "objects",
14995 "dependencies",
14996 ];
14997
14998 #[allow(clippy::enum_variant_names)]
14999 enum GeneratedField {
15000 Objects,
15001 Dependencies,
15002 }
15003 impl<'de> serde::Deserialize<'de> for GeneratedField {
15004 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15005 where
15006 D: serde::Deserializer<'de>,
15007 {
15008 struct GeneratedVisitor;
15009
15010 impl serde::de::Visitor<'_> for GeneratedVisitor {
15011 type Value = GeneratedField;
15012
15013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15014 write!(formatter, "expected one of: {:?}", &FIELDS)
15015 }
15016
15017 #[allow(unused_variables)]
15018 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15019 where
15020 E: serde::de::Error,
15021 {
15022 match value {
15023 "objects" => Ok(GeneratedField::Objects),
15024 "dependencies" => Ok(GeneratedField::Dependencies),
15025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15026 }
15027 }
15028 }
15029 deserializer.deserialize_identifier(GeneratedVisitor)
15030 }
15031 }
15032 struct GeneratedVisitor;
15033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15034 type Value = ObjectGroup;
15035
15036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15037 formatter.write_str("struct meta.ObjectGroup")
15038 }
15039
15040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
15041 where
15042 V: serde::de::MapAccess<'de>,
15043 {
15044 let mut objects__ = None;
15045 let mut dependencies__ = None;
15046 while let Some(k) = map_.next_key()? {
15047 match k {
15048 GeneratedField::Objects => {
15049 if objects__.is_some() {
15050 return Err(serde::de::Error::duplicate_field("objects"));
15051 }
15052 objects__ = Some(map_.next_value()?);
15053 }
15054 GeneratedField::Dependencies => {
15055 if dependencies__.is_some() {
15056 return Err(serde::de::Error::duplicate_field("dependencies"));
15057 }
15058 dependencies__ = Some(map_.next_value()?);
15059 }
15060 }
15061 }
15062 Ok(ObjectGroup {
15063 objects: objects__.unwrap_or_default(),
15064 dependencies: dependencies__.unwrap_or_default(),
15065 })
15066 }
15067 }
15068 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
15069 }
15070}
15071impl serde::Serialize for PauseRequest {
15072 #[allow(deprecated)]
15073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15074 where
15075 S: serde::Serializer,
15076 {
15077 use serde::ser::SerializeStruct;
15078 let len = 0;
15079 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
15080 struct_ser.end()
15081 }
15082}
15083impl<'de> serde::Deserialize<'de> for PauseRequest {
15084 #[allow(deprecated)]
15085 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15086 where
15087 D: serde::Deserializer<'de>,
15088 {
15089 const FIELDS: &[&str] = &[
15090 ];
15091
15092 #[allow(clippy::enum_variant_names)]
15093 enum GeneratedField {
15094 }
15095 impl<'de> serde::Deserialize<'de> for GeneratedField {
15096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15097 where
15098 D: serde::Deserializer<'de>,
15099 {
15100 struct GeneratedVisitor;
15101
15102 impl serde::de::Visitor<'_> for GeneratedVisitor {
15103 type Value = GeneratedField;
15104
15105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15106 write!(formatter, "expected one of: {:?}", &FIELDS)
15107 }
15108
15109 #[allow(unused_variables)]
15110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15111 where
15112 E: serde::de::Error,
15113 {
15114 Err(serde::de::Error::unknown_field(value, FIELDS))
15115 }
15116 }
15117 deserializer.deserialize_identifier(GeneratedVisitor)
15118 }
15119 }
15120 struct GeneratedVisitor;
15121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15122 type Value = PauseRequest;
15123
15124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15125 formatter.write_str("struct meta.PauseRequest")
15126 }
15127
15128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
15129 where
15130 V: serde::de::MapAccess<'de>,
15131 {
15132 while map_.next_key::<GeneratedField>()?.is_some() {
15133 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15134 }
15135 Ok(PauseRequest {
15136 })
15137 }
15138 }
15139 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
15140 }
15141}
15142impl serde::Serialize for PauseResponse {
15143 #[allow(deprecated)]
15144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15145 where
15146 S: serde::Serializer,
15147 {
15148 use serde::ser::SerializeStruct;
15149 let len = 0;
15150 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
15151 struct_ser.end()
15152 }
15153}
15154impl<'de> serde::Deserialize<'de> for PauseResponse {
15155 #[allow(deprecated)]
15156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15157 where
15158 D: serde::Deserializer<'de>,
15159 {
15160 const FIELDS: &[&str] = &[
15161 ];
15162
15163 #[allow(clippy::enum_variant_names)]
15164 enum GeneratedField {
15165 }
15166 impl<'de> serde::Deserialize<'de> for GeneratedField {
15167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15168 where
15169 D: serde::Deserializer<'de>,
15170 {
15171 struct GeneratedVisitor;
15172
15173 impl serde::de::Visitor<'_> for GeneratedVisitor {
15174 type Value = GeneratedField;
15175
15176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15177 write!(formatter, "expected one of: {:?}", &FIELDS)
15178 }
15179
15180 #[allow(unused_variables)]
15181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15182 where
15183 E: serde::de::Error,
15184 {
15185 Err(serde::de::Error::unknown_field(value, FIELDS))
15186 }
15187 }
15188 deserializer.deserialize_identifier(GeneratedVisitor)
15189 }
15190 }
15191 struct GeneratedVisitor;
15192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15193 type Value = PauseResponse;
15194
15195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15196 formatter.write_str("struct meta.PauseResponse")
15197 }
15198
15199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
15200 where
15201 V: serde::de::MapAccess<'de>,
15202 {
15203 while map_.next_key::<GeneratedField>()?.is_some() {
15204 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15205 }
15206 Ok(PauseResponse {
15207 })
15208 }
15209 }
15210 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
15211 }
15212}
15213impl serde::Serialize for PropertyUpdateOptions {
15214 #[allow(deprecated)]
15215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15216 where
15217 S: serde::Serializer,
15218 {
15219 use serde::ser::SerializeStruct;
15220 let mut len = 0;
15221 if self.reset_splits {
15222 len += 1;
15223 }
15224 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
15225 if self.reset_splits {
15226 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
15227 }
15228 struct_ser.end()
15229 }
15230}
15231impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
15232 #[allow(deprecated)]
15233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15234 where
15235 D: serde::Deserializer<'de>,
15236 {
15237 const FIELDS: &[&str] = &[
15238 "reset_splits",
15239 "resetSplits",
15240 ];
15241
15242 #[allow(clippy::enum_variant_names)]
15243 enum GeneratedField {
15244 ResetSplits,
15245 }
15246 impl<'de> serde::Deserialize<'de> for GeneratedField {
15247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15248 where
15249 D: serde::Deserializer<'de>,
15250 {
15251 struct GeneratedVisitor;
15252
15253 impl serde::de::Visitor<'_> for GeneratedVisitor {
15254 type Value = GeneratedField;
15255
15256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15257 write!(formatter, "expected one of: {:?}", &FIELDS)
15258 }
15259
15260 #[allow(unused_variables)]
15261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15262 where
15263 E: serde::de::Error,
15264 {
15265 match value {
15266 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
15267 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15268 }
15269 }
15270 }
15271 deserializer.deserialize_identifier(GeneratedVisitor)
15272 }
15273 }
15274 struct GeneratedVisitor;
15275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15276 type Value = PropertyUpdateOptions;
15277
15278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15279 formatter.write_str("struct meta.PropertyUpdateOptions")
15280 }
15281
15282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
15283 where
15284 V: serde::de::MapAccess<'de>,
15285 {
15286 let mut reset_splits__ = None;
15287 while let Some(k) = map_.next_key()? {
15288 match k {
15289 GeneratedField::ResetSplits => {
15290 if reset_splits__.is_some() {
15291 return Err(serde::de::Error::duplicate_field("resetSplits"));
15292 }
15293 reset_splits__ = Some(map_.next_value()?);
15294 }
15295 }
15296 }
15297 Ok(PropertyUpdateOptions {
15298 reset_splits: reset_splits__.unwrap_or_default(),
15299 })
15300 }
15301 }
15302 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
15303 }
15304}
15305impl serde::Serialize for RecoverRequest {
15306 #[allow(deprecated)]
15307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15308 where
15309 S: serde::Serializer,
15310 {
15311 use serde::ser::SerializeStruct;
15312 let len = 0;
15313 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
15314 struct_ser.end()
15315 }
15316}
15317impl<'de> serde::Deserialize<'de> for RecoverRequest {
15318 #[allow(deprecated)]
15319 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15320 where
15321 D: serde::Deserializer<'de>,
15322 {
15323 const FIELDS: &[&str] = &[
15324 ];
15325
15326 #[allow(clippy::enum_variant_names)]
15327 enum GeneratedField {
15328 }
15329 impl<'de> serde::Deserialize<'de> for GeneratedField {
15330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15331 where
15332 D: serde::Deserializer<'de>,
15333 {
15334 struct GeneratedVisitor;
15335
15336 impl serde::de::Visitor<'_> for GeneratedVisitor {
15337 type Value = GeneratedField;
15338
15339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15340 write!(formatter, "expected one of: {:?}", &FIELDS)
15341 }
15342
15343 #[allow(unused_variables)]
15344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15345 where
15346 E: serde::de::Error,
15347 {
15348 Err(serde::de::Error::unknown_field(value, FIELDS))
15349 }
15350 }
15351 deserializer.deserialize_identifier(GeneratedVisitor)
15352 }
15353 }
15354 struct GeneratedVisitor;
15355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15356 type Value = RecoverRequest;
15357
15358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15359 formatter.write_str("struct meta.RecoverRequest")
15360 }
15361
15362 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
15363 where
15364 V: serde::de::MapAccess<'de>,
15365 {
15366 while map_.next_key::<GeneratedField>()?.is_some() {
15367 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15368 }
15369 Ok(RecoverRequest {
15370 })
15371 }
15372 }
15373 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
15374 }
15375}
15376impl serde::Serialize for RecoverResponse {
15377 #[allow(deprecated)]
15378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15379 where
15380 S: serde::Serializer,
15381 {
15382 use serde::ser::SerializeStruct;
15383 let len = 0;
15384 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
15385 struct_ser.end()
15386 }
15387}
15388impl<'de> serde::Deserialize<'de> for RecoverResponse {
15389 #[allow(deprecated)]
15390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15391 where
15392 D: serde::Deserializer<'de>,
15393 {
15394 const FIELDS: &[&str] = &[
15395 ];
15396
15397 #[allow(clippy::enum_variant_names)]
15398 enum GeneratedField {
15399 }
15400 impl<'de> serde::Deserialize<'de> for GeneratedField {
15401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15402 where
15403 D: serde::Deserializer<'de>,
15404 {
15405 struct GeneratedVisitor;
15406
15407 impl serde::de::Visitor<'_> for GeneratedVisitor {
15408 type Value = GeneratedField;
15409
15410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15411 write!(formatter, "expected one of: {:?}", &FIELDS)
15412 }
15413
15414 #[allow(unused_variables)]
15415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15416 where
15417 E: serde::de::Error,
15418 {
15419 Err(serde::de::Error::unknown_field(value, FIELDS))
15420 }
15421 }
15422 deserializer.deserialize_identifier(GeneratedVisitor)
15423 }
15424 }
15425 struct GeneratedVisitor;
15426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15427 type Value = RecoverResponse;
15428
15429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15430 formatter.write_str("struct meta.RecoverResponse")
15431 }
15432
15433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
15434 where
15435 V: serde::de::MapAccess<'de>,
15436 {
15437 while map_.next_key::<GeneratedField>()?.is_some() {
15438 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15439 }
15440 Ok(RecoverResponse {
15441 })
15442 }
15443 }
15444 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
15445 }
15446}
15447impl serde::Serialize for Recovery {
15448 #[allow(deprecated)]
15449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15450 where
15451 S: serde::Serializer,
15452 {
15453 use serde::ser::SerializeStruct;
15454 let len = 0;
15455 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
15456 struct_ser.end()
15457 }
15458}
15459impl<'de> serde::Deserialize<'de> for Recovery {
15460 #[allow(deprecated)]
15461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15462 where
15463 D: serde::Deserializer<'de>,
15464 {
15465 const FIELDS: &[&str] = &[
15466 ];
15467
15468 #[allow(clippy::enum_variant_names)]
15469 enum GeneratedField {
15470 }
15471 impl<'de> serde::Deserialize<'de> for GeneratedField {
15472 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15473 where
15474 D: serde::Deserializer<'de>,
15475 {
15476 struct GeneratedVisitor;
15477
15478 impl serde::de::Visitor<'_> for GeneratedVisitor {
15479 type Value = GeneratedField;
15480
15481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15482 write!(formatter, "expected one of: {:?}", &FIELDS)
15483 }
15484
15485 #[allow(unused_variables)]
15486 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15487 where
15488 E: serde::de::Error,
15489 {
15490 Err(serde::de::Error::unknown_field(value, FIELDS))
15491 }
15492 }
15493 deserializer.deserialize_identifier(GeneratedVisitor)
15494 }
15495 }
15496 struct GeneratedVisitor;
15497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15498 type Value = Recovery;
15499
15500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15501 formatter.write_str("struct meta.Recovery")
15502 }
15503
15504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
15505 where
15506 V: serde::de::MapAccess<'de>,
15507 {
15508 while map_.next_key::<GeneratedField>()?.is_some() {
15509 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15510 }
15511 Ok(Recovery {
15512 })
15513 }
15514 }
15515 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
15516 }
15517}
15518impl serde::Serialize for RecoveryStatus {
15519 #[allow(deprecated)]
15520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15521 where
15522 S: serde::Serializer,
15523 {
15524 let variant = match self {
15525 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
15526 Self::StatusStarting => "STATUS_STARTING",
15527 Self::StatusRecovering => "STATUS_RECOVERING",
15528 Self::StatusRunning => "STATUS_RUNNING",
15529 };
15530 serializer.serialize_str(variant)
15531 }
15532}
15533impl<'de> serde::Deserialize<'de> for RecoveryStatus {
15534 #[allow(deprecated)]
15535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15536 where
15537 D: serde::Deserializer<'de>,
15538 {
15539 const FIELDS: &[&str] = &[
15540 "STATUS_UNSPECIFIED",
15541 "STATUS_STARTING",
15542 "STATUS_RECOVERING",
15543 "STATUS_RUNNING",
15544 ];
15545
15546 struct GeneratedVisitor;
15547
15548 impl serde::de::Visitor<'_> for GeneratedVisitor {
15549 type Value = RecoveryStatus;
15550
15551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15552 write!(formatter, "expected one of: {:?}", &FIELDS)
15553 }
15554
15555 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15556 where
15557 E: serde::de::Error,
15558 {
15559 i32::try_from(v)
15560 .ok()
15561 .and_then(|x| x.try_into().ok())
15562 .ok_or_else(|| {
15563 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15564 })
15565 }
15566
15567 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15568 where
15569 E: serde::de::Error,
15570 {
15571 i32::try_from(v)
15572 .ok()
15573 .and_then(|x| x.try_into().ok())
15574 .ok_or_else(|| {
15575 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15576 })
15577 }
15578
15579 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15580 where
15581 E: serde::de::Error,
15582 {
15583 match value {
15584 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
15585 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
15586 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
15587 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
15588 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15589 }
15590 }
15591 }
15592 deserializer.deserialize_any(GeneratedVisitor)
15593 }
15594}
15595impl serde::Serialize for RefreshRequest {
15596 #[allow(deprecated)]
15597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15598 where
15599 S: serde::Serializer,
15600 {
15601 use serde::ser::SerializeStruct;
15602 let mut len = 0;
15603 if self.table_id != 0 {
15604 len += 1;
15605 }
15606 if self.associated_source_id != 0 {
15607 len += 1;
15608 }
15609 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
15610 if self.table_id != 0 {
15611 struct_ser.serialize_field("tableId", &self.table_id)?;
15612 }
15613 if self.associated_source_id != 0 {
15614 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
15615 }
15616 struct_ser.end()
15617 }
15618}
15619impl<'de> serde::Deserialize<'de> for RefreshRequest {
15620 #[allow(deprecated)]
15621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15622 where
15623 D: serde::Deserializer<'de>,
15624 {
15625 const FIELDS: &[&str] = &[
15626 "table_id",
15627 "tableId",
15628 "associated_source_id",
15629 "associatedSourceId",
15630 ];
15631
15632 #[allow(clippy::enum_variant_names)]
15633 enum GeneratedField {
15634 TableId,
15635 AssociatedSourceId,
15636 }
15637 impl<'de> serde::Deserialize<'de> for GeneratedField {
15638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15639 where
15640 D: serde::Deserializer<'de>,
15641 {
15642 struct GeneratedVisitor;
15643
15644 impl serde::de::Visitor<'_> for GeneratedVisitor {
15645 type Value = GeneratedField;
15646
15647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15648 write!(formatter, "expected one of: {:?}", &FIELDS)
15649 }
15650
15651 #[allow(unused_variables)]
15652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15653 where
15654 E: serde::de::Error,
15655 {
15656 match value {
15657 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15658 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15660 }
15661 }
15662 }
15663 deserializer.deserialize_identifier(GeneratedVisitor)
15664 }
15665 }
15666 struct GeneratedVisitor;
15667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15668 type Value = RefreshRequest;
15669
15670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15671 formatter.write_str("struct meta.RefreshRequest")
15672 }
15673
15674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15675 where
15676 V: serde::de::MapAccess<'de>,
15677 {
15678 let mut table_id__ = None;
15679 let mut associated_source_id__ = None;
15680 while let Some(k) = map_.next_key()? {
15681 match k {
15682 GeneratedField::TableId => {
15683 if table_id__.is_some() {
15684 return Err(serde::de::Error::duplicate_field("tableId"));
15685 }
15686 table_id__ =
15687 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15688 ;
15689 }
15690 GeneratedField::AssociatedSourceId => {
15691 if associated_source_id__.is_some() {
15692 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15693 }
15694 associated_source_id__ =
15695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15696 ;
15697 }
15698 }
15699 }
15700 Ok(RefreshRequest {
15701 table_id: table_id__.unwrap_or_default(),
15702 associated_source_id: associated_source_id__.unwrap_or_default(),
15703 })
15704 }
15705 }
15706 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15707 }
15708}
15709impl serde::Serialize for RefreshResponse {
15710 #[allow(deprecated)]
15711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15712 where
15713 S: serde::Serializer,
15714 {
15715 use serde::ser::SerializeStruct;
15716 let mut len = 0;
15717 if self.status.is_some() {
15718 len += 1;
15719 }
15720 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15721 if let Some(v) = self.status.as_ref() {
15722 struct_ser.serialize_field("status", v)?;
15723 }
15724 struct_ser.end()
15725 }
15726}
15727impl<'de> serde::Deserialize<'de> for RefreshResponse {
15728 #[allow(deprecated)]
15729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15730 where
15731 D: serde::Deserializer<'de>,
15732 {
15733 const FIELDS: &[&str] = &[
15734 "status",
15735 ];
15736
15737 #[allow(clippy::enum_variant_names)]
15738 enum GeneratedField {
15739 Status,
15740 }
15741 impl<'de> serde::Deserialize<'de> for GeneratedField {
15742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15743 where
15744 D: serde::Deserializer<'de>,
15745 {
15746 struct GeneratedVisitor;
15747
15748 impl serde::de::Visitor<'_> for GeneratedVisitor {
15749 type Value = GeneratedField;
15750
15751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15752 write!(formatter, "expected one of: {:?}", &FIELDS)
15753 }
15754
15755 #[allow(unused_variables)]
15756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15757 where
15758 E: serde::de::Error,
15759 {
15760 match value {
15761 "status" => Ok(GeneratedField::Status),
15762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15763 }
15764 }
15765 }
15766 deserializer.deserialize_identifier(GeneratedVisitor)
15767 }
15768 }
15769 struct GeneratedVisitor;
15770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15771 type Value = RefreshResponse;
15772
15773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15774 formatter.write_str("struct meta.RefreshResponse")
15775 }
15776
15777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15778 where
15779 V: serde::de::MapAccess<'de>,
15780 {
15781 let mut status__ = None;
15782 while let Some(k) = map_.next_key()? {
15783 match k {
15784 GeneratedField::Status => {
15785 if status__.is_some() {
15786 return Err(serde::de::Error::duplicate_field("status"));
15787 }
15788 status__ = map_.next_value()?;
15789 }
15790 }
15791 }
15792 Ok(RefreshResponse {
15793 status: status__,
15794 })
15795 }
15796 }
15797 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15798 }
15799}
15800impl serde::Serialize for RelationIdInfos {
15801 #[allow(deprecated)]
15802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15803 where
15804 S: serde::Serializer,
15805 {
15806 use serde::ser::SerializeStruct;
15807 let mut len = 0;
15808 if !self.map.is_empty() {
15809 len += 1;
15810 }
15811 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15812 if !self.map.is_empty() {
15813 struct_ser.serialize_field("map", &self.map)?;
15814 }
15815 struct_ser.end()
15816 }
15817}
15818impl<'de> serde::Deserialize<'de> for RelationIdInfos {
15819 #[allow(deprecated)]
15820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15821 where
15822 D: serde::Deserializer<'de>,
15823 {
15824 const FIELDS: &[&str] = &[
15825 "map",
15826 ];
15827
15828 #[allow(clippy::enum_variant_names)]
15829 enum GeneratedField {
15830 Map,
15831 }
15832 impl<'de> serde::Deserialize<'de> for GeneratedField {
15833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15834 where
15835 D: serde::Deserializer<'de>,
15836 {
15837 struct GeneratedVisitor;
15838
15839 impl serde::de::Visitor<'_> for GeneratedVisitor {
15840 type Value = GeneratedField;
15841
15842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15843 write!(formatter, "expected one of: {:?}", &FIELDS)
15844 }
15845
15846 #[allow(unused_variables)]
15847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15848 where
15849 E: serde::de::Error,
15850 {
15851 match value {
15852 "map" => Ok(GeneratedField::Map),
15853 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15854 }
15855 }
15856 }
15857 deserializer.deserialize_identifier(GeneratedVisitor)
15858 }
15859 }
15860 struct GeneratedVisitor;
15861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15862 type Value = RelationIdInfos;
15863
15864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15865 formatter.write_str("struct meta.RelationIdInfos")
15866 }
15867
15868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15869 where
15870 V: serde::de::MapAccess<'de>,
15871 {
15872 let mut map__ = None;
15873 while let Some(k) = map_.next_key()? {
15874 match k {
15875 GeneratedField::Map => {
15876 if map__.is_some() {
15877 return Err(serde::de::Error::duplicate_field("map"));
15878 }
15879 map__ = Some(
15880 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15881 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15882 );
15883 }
15884 }
15885 }
15886 Ok(RelationIdInfos {
15887 map: map__.unwrap_or_default(),
15888 })
15889 }
15890 }
15891 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15892 }
15893}
15894impl serde::Serialize for RescheduleRequest {
15895 #[allow(deprecated)]
15896 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15897 where
15898 S: serde::Serializer,
15899 {
15900 use serde::ser::SerializeStruct;
15901 let mut len = 0;
15902 if self.revision != 0 {
15903 len += 1;
15904 }
15905 if self.resolve_no_shuffle_upstream {
15906 len += 1;
15907 }
15908 if !self.worker_reschedules.is_empty() {
15909 len += 1;
15910 }
15911 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15912 if self.revision != 0 {
15913 #[allow(clippy::needless_borrow)]
15914 #[allow(clippy::needless_borrows_for_generic_args)]
15915 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15916 }
15917 if self.resolve_no_shuffle_upstream {
15918 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15919 }
15920 if !self.worker_reschedules.is_empty() {
15921 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15922 }
15923 struct_ser.end()
15924 }
15925}
15926impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15927 #[allow(deprecated)]
15928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15929 where
15930 D: serde::Deserializer<'de>,
15931 {
15932 const FIELDS: &[&str] = &[
15933 "revision",
15934 "resolve_no_shuffle_upstream",
15935 "resolveNoShuffleUpstream",
15936 "worker_reschedules",
15937 "workerReschedules",
15938 ];
15939
15940 #[allow(clippy::enum_variant_names)]
15941 enum GeneratedField {
15942 Revision,
15943 ResolveNoShuffleUpstream,
15944 WorkerReschedules,
15945 }
15946 impl<'de> serde::Deserialize<'de> for GeneratedField {
15947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15948 where
15949 D: serde::Deserializer<'de>,
15950 {
15951 struct GeneratedVisitor;
15952
15953 impl serde::de::Visitor<'_> for GeneratedVisitor {
15954 type Value = GeneratedField;
15955
15956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15957 write!(formatter, "expected one of: {:?}", &FIELDS)
15958 }
15959
15960 #[allow(unused_variables)]
15961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15962 where
15963 E: serde::de::Error,
15964 {
15965 match value {
15966 "revision" => Ok(GeneratedField::Revision),
15967 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15968 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15969 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15970 }
15971 }
15972 }
15973 deserializer.deserialize_identifier(GeneratedVisitor)
15974 }
15975 }
15976 struct GeneratedVisitor;
15977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15978 type Value = RescheduleRequest;
15979
15980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15981 formatter.write_str("struct meta.RescheduleRequest")
15982 }
15983
15984 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15985 where
15986 V: serde::de::MapAccess<'de>,
15987 {
15988 let mut revision__ = None;
15989 let mut resolve_no_shuffle_upstream__ = None;
15990 let mut worker_reschedules__ = None;
15991 while let Some(k) = map_.next_key()? {
15992 match k {
15993 GeneratedField::Revision => {
15994 if revision__.is_some() {
15995 return Err(serde::de::Error::duplicate_field("revision"));
15996 }
15997 revision__ =
15998 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15999 ;
16000 }
16001 GeneratedField::ResolveNoShuffleUpstream => {
16002 if resolve_no_shuffle_upstream__.is_some() {
16003 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
16004 }
16005 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
16006 }
16007 GeneratedField::WorkerReschedules => {
16008 if worker_reschedules__.is_some() {
16009 return Err(serde::de::Error::duplicate_field("workerReschedules"));
16010 }
16011 worker_reschedules__ = Some(
16012 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16013 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16014 );
16015 }
16016 }
16017 }
16018 Ok(RescheduleRequest {
16019 revision: revision__.unwrap_or_default(),
16020 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
16021 worker_reschedules: worker_reschedules__.unwrap_or_default(),
16022 })
16023 }
16024 }
16025 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
16026 }
16027}
16028impl serde::Serialize for RescheduleResponse {
16029 #[allow(deprecated)]
16030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16031 where
16032 S: serde::Serializer,
16033 {
16034 use serde::ser::SerializeStruct;
16035 let mut len = 0;
16036 if self.success {
16037 len += 1;
16038 }
16039 if self.revision != 0 {
16040 len += 1;
16041 }
16042 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
16043 if self.success {
16044 struct_ser.serialize_field("success", &self.success)?;
16045 }
16046 if self.revision != 0 {
16047 #[allow(clippy::needless_borrow)]
16048 #[allow(clippy::needless_borrows_for_generic_args)]
16049 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
16050 }
16051 struct_ser.end()
16052 }
16053}
16054impl<'de> serde::Deserialize<'de> for RescheduleResponse {
16055 #[allow(deprecated)]
16056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16057 where
16058 D: serde::Deserializer<'de>,
16059 {
16060 const FIELDS: &[&str] = &[
16061 "success",
16062 "revision",
16063 ];
16064
16065 #[allow(clippy::enum_variant_names)]
16066 enum GeneratedField {
16067 Success,
16068 Revision,
16069 }
16070 impl<'de> serde::Deserialize<'de> for GeneratedField {
16071 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16072 where
16073 D: serde::Deserializer<'de>,
16074 {
16075 struct GeneratedVisitor;
16076
16077 impl serde::de::Visitor<'_> for GeneratedVisitor {
16078 type Value = GeneratedField;
16079
16080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16081 write!(formatter, "expected one of: {:?}", &FIELDS)
16082 }
16083
16084 #[allow(unused_variables)]
16085 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16086 where
16087 E: serde::de::Error,
16088 {
16089 match value {
16090 "success" => Ok(GeneratedField::Success),
16091 "revision" => Ok(GeneratedField::Revision),
16092 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16093 }
16094 }
16095 }
16096 deserializer.deserialize_identifier(GeneratedVisitor)
16097 }
16098 }
16099 struct GeneratedVisitor;
16100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16101 type Value = RescheduleResponse;
16102
16103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16104 formatter.write_str("struct meta.RescheduleResponse")
16105 }
16106
16107 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
16108 where
16109 V: serde::de::MapAccess<'de>,
16110 {
16111 let mut success__ = None;
16112 let mut revision__ = None;
16113 while let Some(k) = map_.next_key()? {
16114 match k {
16115 GeneratedField::Success => {
16116 if success__.is_some() {
16117 return Err(serde::de::Error::duplicate_field("success"));
16118 }
16119 success__ = Some(map_.next_value()?);
16120 }
16121 GeneratedField::Revision => {
16122 if revision__.is_some() {
16123 return Err(serde::de::Error::duplicate_field("revision"));
16124 }
16125 revision__ =
16126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16127 ;
16128 }
16129 }
16130 }
16131 Ok(RescheduleResponse {
16132 success: success__.unwrap_or_default(),
16133 revision: revision__.unwrap_or_default(),
16134 })
16135 }
16136 }
16137 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
16138 }
16139}
16140impl serde::Serialize for ResetSourceSplitsRequest {
16141 #[allow(deprecated)]
16142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16143 where
16144 S: serde::Serializer,
16145 {
16146 use serde::ser::SerializeStruct;
16147 let mut len = 0;
16148 if self.source_id != 0 {
16149 len += 1;
16150 }
16151 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
16152 if self.source_id != 0 {
16153 struct_ser.serialize_field("sourceId", &self.source_id)?;
16154 }
16155 struct_ser.end()
16156 }
16157}
16158impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
16159 #[allow(deprecated)]
16160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16161 where
16162 D: serde::Deserializer<'de>,
16163 {
16164 const FIELDS: &[&str] = &[
16165 "source_id",
16166 "sourceId",
16167 ];
16168
16169 #[allow(clippy::enum_variant_names)]
16170 enum GeneratedField {
16171 SourceId,
16172 }
16173 impl<'de> serde::Deserialize<'de> for GeneratedField {
16174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16175 where
16176 D: serde::Deserializer<'de>,
16177 {
16178 struct GeneratedVisitor;
16179
16180 impl serde::de::Visitor<'_> for GeneratedVisitor {
16181 type Value = GeneratedField;
16182
16183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16184 write!(formatter, "expected one of: {:?}", &FIELDS)
16185 }
16186
16187 #[allow(unused_variables)]
16188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16189 where
16190 E: serde::de::Error,
16191 {
16192 match value {
16193 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16195 }
16196 }
16197 }
16198 deserializer.deserialize_identifier(GeneratedVisitor)
16199 }
16200 }
16201 struct GeneratedVisitor;
16202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16203 type Value = ResetSourceSplitsRequest;
16204
16205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16206 formatter.write_str("struct meta.ResetSourceSplitsRequest")
16207 }
16208
16209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
16210 where
16211 V: serde::de::MapAccess<'de>,
16212 {
16213 let mut source_id__ = None;
16214 while let Some(k) = map_.next_key()? {
16215 match k {
16216 GeneratedField::SourceId => {
16217 if source_id__.is_some() {
16218 return Err(serde::de::Error::duplicate_field("sourceId"));
16219 }
16220 source_id__ =
16221 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16222 ;
16223 }
16224 }
16225 }
16226 Ok(ResetSourceSplitsRequest {
16227 source_id: source_id__.unwrap_or_default(),
16228 })
16229 }
16230 }
16231 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
16232 }
16233}
16234impl serde::Serialize for ResetSourceSplitsResponse {
16235 #[allow(deprecated)]
16236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16237 where
16238 S: serde::Serializer,
16239 {
16240 use serde::ser::SerializeStruct;
16241 let len = 0;
16242 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
16243 struct_ser.end()
16244 }
16245}
16246impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
16247 #[allow(deprecated)]
16248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16249 where
16250 D: serde::Deserializer<'de>,
16251 {
16252 const FIELDS: &[&str] = &[
16253 ];
16254
16255 #[allow(clippy::enum_variant_names)]
16256 enum GeneratedField {
16257 }
16258 impl<'de> serde::Deserialize<'de> for GeneratedField {
16259 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16260 where
16261 D: serde::Deserializer<'de>,
16262 {
16263 struct GeneratedVisitor;
16264
16265 impl serde::de::Visitor<'_> for GeneratedVisitor {
16266 type Value = GeneratedField;
16267
16268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16269 write!(formatter, "expected one of: {:?}", &FIELDS)
16270 }
16271
16272 #[allow(unused_variables)]
16273 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16274 where
16275 E: serde::de::Error,
16276 {
16277 Err(serde::de::Error::unknown_field(value, FIELDS))
16278 }
16279 }
16280 deserializer.deserialize_identifier(GeneratedVisitor)
16281 }
16282 }
16283 struct GeneratedVisitor;
16284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16285 type Value = ResetSourceSplitsResponse;
16286
16287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16288 formatter.write_str("struct meta.ResetSourceSplitsResponse")
16289 }
16290
16291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
16292 where
16293 V: serde::de::MapAccess<'de>,
16294 {
16295 while map_.next_key::<GeneratedField>()?.is_some() {
16296 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16297 }
16298 Ok(ResetSourceSplitsResponse {
16299 })
16300 }
16301 }
16302 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
16303 }
16304}
16305impl serde::Serialize for ResumeRequest {
16306 #[allow(deprecated)]
16307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16308 where
16309 S: serde::Serializer,
16310 {
16311 use serde::ser::SerializeStruct;
16312 let len = 0;
16313 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
16314 struct_ser.end()
16315 }
16316}
16317impl<'de> serde::Deserialize<'de> for ResumeRequest {
16318 #[allow(deprecated)]
16319 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16320 where
16321 D: serde::Deserializer<'de>,
16322 {
16323 const FIELDS: &[&str] = &[
16324 ];
16325
16326 #[allow(clippy::enum_variant_names)]
16327 enum GeneratedField {
16328 }
16329 impl<'de> serde::Deserialize<'de> for GeneratedField {
16330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16331 where
16332 D: serde::Deserializer<'de>,
16333 {
16334 struct GeneratedVisitor;
16335
16336 impl serde::de::Visitor<'_> for GeneratedVisitor {
16337 type Value = GeneratedField;
16338
16339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16340 write!(formatter, "expected one of: {:?}", &FIELDS)
16341 }
16342
16343 #[allow(unused_variables)]
16344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16345 where
16346 E: serde::de::Error,
16347 {
16348 Err(serde::de::Error::unknown_field(value, FIELDS))
16349 }
16350 }
16351 deserializer.deserialize_identifier(GeneratedVisitor)
16352 }
16353 }
16354 struct GeneratedVisitor;
16355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16356 type Value = ResumeRequest;
16357
16358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16359 formatter.write_str("struct meta.ResumeRequest")
16360 }
16361
16362 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
16363 where
16364 V: serde::de::MapAccess<'de>,
16365 {
16366 while map_.next_key::<GeneratedField>()?.is_some() {
16367 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16368 }
16369 Ok(ResumeRequest {
16370 })
16371 }
16372 }
16373 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
16374 }
16375}
16376impl serde::Serialize for ResumeResponse {
16377 #[allow(deprecated)]
16378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16379 where
16380 S: serde::Serializer,
16381 {
16382 use serde::ser::SerializeStruct;
16383 let len = 0;
16384 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
16385 struct_ser.end()
16386 }
16387}
16388impl<'de> serde::Deserialize<'de> for ResumeResponse {
16389 #[allow(deprecated)]
16390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16391 where
16392 D: serde::Deserializer<'de>,
16393 {
16394 const FIELDS: &[&str] = &[
16395 ];
16396
16397 #[allow(clippy::enum_variant_names)]
16398 enum GeneratedField {
16399 }
16400 impl<'de> serde::Deserialize<'de> for GeneratedField {
16401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16402 where
16403 D: serde::Deserializer<'de>,
16404 {
16405 struct GeneratedVisitor;
16406
16407 impl serde::de::Visitor<'_> for GeneratedVisitor {
16408 type Value = GeneratedField;
16409
16410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16411 write!(formatter, "expected one of: {:?}", &FIELDS)
16412 }
16413
16414 #[allow(unused_variables)]
16415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16416 where
16417 E: serde::de::Error,
16418 {
16419 Err(serde::de::Error::unknown_field(value, FIELDS))
16420 }
16421 }
16422 deserializer.deserialize_identifier(GeneratedVisitor)
16423 }
16424 }
16425 struct GeneratedVisitor;
16426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16427 type Value = ResumeResponse;
16428
16429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16430 formatter.write_str("struct meta.ResumeResponse")
16431 }
16432
16433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
16434 where
16435 V: serde::de::MapAccess<'de>,
16436 {
16437 while map_.next_key::<GeneratedField>()?.is_some() {
16438 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16439 }
16440 Ok(ResumeResponse {
16441 })
16442 }
16443 }
16444 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
16445 }
16446}
16447impl serde::Serialize for ServingTableVnodeMappings {
16448 #[allow(deprecated)]
16449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16450 where
16451 S: serde::Serializer,
16452 {
16453 use serde::ser::SerializeStruct;
16454 let mut len = 0;
16455 if !self.mappings.is_empty() {
16456 len += 1;
16457 }
16458 let mut struct_ser = serializer.serialize_struct("meta.ServingTableVnodeMappings", len)?;
16459 if !self.mappings.is_empty() {
16460 struct_ser.serialize_field("mappings", &self.mappings)?;
16461 }
16462 struct_ser.end()
16463 }
16464}
16465impl<'de> serde::Deserialize<'de> for ServingTableVnodeMappings {
16466 #[allow(deprecated)]
16467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16468 where
16469 D: serde::Deserializer<'de>,
16470 {
16471 const FIELDS: &[&str] = &[
16472 "mappings",
16473 ];
16474
16475 #[allow(clippy::enum_variant_names)]
16476 enum GeneratedField {
16477 Mappings,
16478 }
16479 impl<'de> serde::Deserialize<'de> for GeneratedField {
16480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16481 where
16482 D: serde::Deserializer<'de>,
16483 {
16484 struct GeneratedVisitor;
16485
16486 impl serde::de::Visitor<'_> for GeneratedVisitor {
16487 type Value = GeneratedField;
16488
16489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16490 write!(formatter, "expected one of: {:?}", &FIELDS)
16491 }
16492
16493 #[allow(unused_variables)]
16494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16495 where
16496 E: serde::de::Error,
16497 {
16498 match value {
16499 "mappings" => Ok(GeneratedField::Mappings),
16500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16501 }
16502 }
16503 }
16504 deserializer.deserialize_identifier(GeneratedVisitor)
16505 }
16506 }
16507 struct GeneratedVisitor;
16508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16509 type Value = ServingTableVnodeMappings;
16510
16511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16512 formatter.write_str("struct meta.ServingTableVnodeMappings")
16513 }
16514
16515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ServingTableVnodeMappings, V::Error>
16516 where
16517 V: serde::de::MapAccess<'de>,
16518 {
16519 let mut mappings__ = None;
16520 while let Some(k) = map_.next_key()? {
16521 match k {
16522 GeneratedField::Mappings => {
16523 if mappings__.is_some() {
16524 return Err(serde::de::Error::duplicate_field("mappings"));
16525 }
16526 mappings__ = Some(map_.next_value()?);
16527 }
16528 }
16529 }
16530 Ok(ServingTableVnodeMappings {
16531 mappings: mappings__.unwrap_or_default(),
16532 })
16533 }
16534 }
16535 deserializer.deserialize_struct("meta.ServingTableVnodeMappings", FIELDS, GeneratedVisitor)
16536 }
16537}
16538impl serde::Serialize for serving_table_vnode_mappings::ServingTableVnodeMapping {
16539 #[allow(deprecated)]
16540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16541 where
16542 S: serde::Serializer,
16543 {
16544 use serde::ser::SerializeStruct;
16545 let mut len = 0;
16546 if self.table_id != 0 {
16547 len += 1;
16548 }
16549 if self.bitmap.is_some() {
16550 len += 1;
16551 }
16552 let mut struct_ser = serializer.serialize_struct("meta.ServingTableVnodeMappings.ServingTableVnodeMapping", len)?;
16553 if self.table_id != 0 {
16554 struct_ser.serialize_field("tableId", &self.table_id)?;
16555 }
16556 if let Some(v) = self.bitmap.as_ref() {
16557 struct_ser.serialize_field("bitmap", v)?;
16558 }
16559 struct_ser.end()
16560 }
16561}
16562impl<'de> serde::Deserialize<'de> for serving_table_vnode_mappings::ServingTableVnodeMapping {
16563 #[allow(deprecated)]
16564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16565 where
16566 D: serde::Deserializer<'de>,
16567 {
16568 const FIELDS: &[&str] = &[
16569 "table_id",
16570 "tableId",
16571 "bitmap",
16572 ];
16573
16574 #[allow(clippy::enum_variant_names)]
16575 enum GeneratedField {
16576 TableId,
16577 Bitmap,
16578 }
16579 impl<'de> serde::Deserialize<'de> for GeneratedField {
16580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16581 where
16582 D: serde::Deserializer<'de>,
16583 {
16584 struct GeneratedVisitor;
16585
16586 impl serde::de::Visitor<'_> for GeneratedVisitor {
16587 type Value = GeneratedField;
16588
16589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16590 write!(formatter, "expected one of: {:?}", &FIELDS)
16591 }
16592
16593 #[allow(unused_variables)]
16594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16595 where
16596 E: serde::de::Error,
16597 {
16598 match value {
16599 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16600 "bitmap" => Ok(GeneratedField::Bitmap),
16601 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16602 }
16603 }
16604 }
16605 deserializer.deserialize_identifier(GeneratedVisitor)
16606 }
16607 }
16608 struct GeneratedVisitor;
16609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16610 type Value = serving_table_vnode_mappings::ServingTableVnodeMapping;
16611
16612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16613 formatter.write_str("struct meta.ServingTableVnodeMappings.ServingTableVnodeMapping")
16614 }
16615
16616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<serving_table_vnode_mappings::ServingTableVnodeMapping, V::Error>
16617 where
16618 V: serde::de::MapAccess<'de>,
16619 {
16620 let mut table_id__ = None;
16621 let mut bitmap__ = None;
16622 while let Some(k) = map_.next_key()? {
16623 match k {
16624 GeneratedField::TableId => {
16625 if table_id__.is_some() {
16626 return Err(serde::de::Error::duplicate_field("tableId"));
16627 }
16628 table_id__ =
16629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16630 ;
16631 }
16632 GeneratedField::Bitmap => {
16633 if bitmap__.is_some() {
16634 return Err(serde::de::Error::duplicate_field("bitmap"));
16635 }
16636 bitmap__ = map_.next_value()?;
16637 }
16638 }
16639 }
16640 Ok(serving_table_vnode_mappings::ServingTableVnodeMapping {
16641 table_id: table_id__.unwrap_or_default(),
16642 bitmap: bitmap__,
16643 })
16644 }
16645 }
16646 deserializer.deserialize_struct("meta.ServingTableVnodeMappings.ServingTableVnodeMapping", FIELDS, GeneratedVisitor)
16647 }
16648}
16649impl serde::Serialize for SetSessionParamRequest {
16650 #[allow(deprecated)]
16651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16652 where
16653 S: serde::Serializer,
16654 {
16655 use serde::ser::SerializeStruct;
16656 let mut len = 0;
16657 if !self.param.is_empty() {
16658 len += 1;
16659 }
16660 if self.value.is_some() {
16661 len += 1;
16662 }
16663 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
16664 if !self.param.is_empty() {
16665 struct_ser.serialize_field("param", &self.param)?;
16666 }
16667 if let Some(v) = self.value.as_ref() {
16668 struct_ser.serialize_field("value", v)?;
16669 }
16670 struct_ser.end()
16671 }
16672}
16673impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
16674 #[allow(deprecated)]
16675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16676 where
16677 D: serde::Deserializer<'de>,
16678 {
16679 const FIELDS: &[&str] = &[
16680 "param",
16681 "value",
16682 ];
16683
16684 #[allow(clippy::enum_variant_names)]
16685 enum GeneratedField {
16686 Param,
16687 Value,
16688 }
16689 impl<'de> serde::Deserialize<'de> for GeneratedField {
16690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16691 where
16692 D: serde::Deserializer<'de>,
16693 {
16694 struct GeneratedVisitor;
16695
16696 impl serde::de::Visitor<'_> for GeneratedVisitor {
16697 type Value = GeneratedField;
16698
16699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16700 write!(formatter, "expected one of: {:?}", &FIELDS)
16701 }
16702
16703 #[allow(unused_variables)]
16704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16705 where
16706 E: serde::de::Error,
16707 {
16708 match value {
16709 "param" => Ok(GeneratedField::Param),
16710 "value" => Ok(GeneratedField::Value),
16711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16712 }
16713 }
16714 }
16715 deserializer.deserialize_identifier(GeneratedVisitor)
16716 }
16717 }
16718 struct GeneratedVisitor;
16719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16720 type Value = SetSessionParamRequest;
16721
16722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16723 formatter.write_str("struct meta.SetSessionParamRequest")
16724 }
16725
16726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
16727 where
16728 V: serde::de::MapAccess<'de>,
16729 {
16730 let mut param__ = None;
16731 let mut value__ = None;
16732 while let Some(k) = map_.next_key()? {
16733 match k {
16734 GeneratedField::Param => {
16735 if param__.is_some() {
16736 return Err(serde::de::Error::duplicate_field("param"));
16737 }
16738 param__ = Some(map_.next_value()?);
16739 }
16740 GeneratedField::Value => {
16741 if value__.is_some() {
16742 return Err(serde::de::Error::duplicate_field("value"));
16743 }
16744 value__ = map_.next_value()?;
16745 }
16746 }
16747 }
16748 Ok(SetSessionParamRequest {
16749 param: param__.unwrap_or_default(),
16750 value: value__,
16751 })
16752 }
16753 }
16754 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
16755 }
16756}
16757impl serde::Serialize for SetSessionParamResponse {
16758 #[allow(deprecated)]
16759 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16760 where
16761 S: serde::Serializer,
16762 {
16763 use serde::ser::SerializeStruct;
16764 let mut len = 0;
16765 if !self.param.is_empty() {
16766 len += 1;
16767 }
16768 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
16769 if !self.param.is_empty() {
16770 struct_ser.serialize_field("param", &self.param)?;
16771 }
16772 struct_ser.end()
16773 }
16774}
16775impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
16776 #[allow(deprecated)]
16777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16778 where
16779 D: serde::Deserializer<'de>,
16780 {
16781 const FIELDS: &[&str] = &[
16782 "param",
16783 ];
16784
16785 #[allow(clippy::enum_variant_names)]
16786 enum GeneratedField {
16787 Param,
16788 }
16789 impl<'de> serde::Deserialize<'de> for GeneratedField {
16790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16791 where
16792 D: serde::Deserializer<'de>,
16793 {
16794 struct GeneratedVisitor;
16795
16796 impl serde::de::Visitor<'_> for GeneratedVisitor {
16797 type Value = GeneratedField;
16798
16799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16800 write!(formatter, "expected one of: {:?}", &FIELDS)
16801 }
16802
16803 #[allow(unused_variables)]
16804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16805 where
16806 E: serde::de::Error,
16807 {
16808 match value {
16809 "param" => Ok(GeneratedField::Param),
16810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16811 }
16812 }
16813 }
16814 deserializer.deserialize_identifier(GeneratedVisitor)
16815 }
16816 }
16817 struct GeneratedVisitor;
16818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16819 type Value = SetSessionParamResponse;
16820
16821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16822 formatter.write_str("struct meta.SetSessionParamResponse")
16823 }
16824
16825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16826 where
16827 V: serde::de::MapAccess<'de>,
16828 {
16829 let mut param__ = None;
16830 while let Some(k) = map_.next_key()? {
16831 match k {
16832 GeneratedField::Param => {
16833 if param__.is_some() {
16834 return Err(serde::de::Error::duplicate_field("param"));
16835 }
16836 param__ = Some(map_.next_value()?);
16837 }
16838 }
16839 }
16840 Ok(SetSessionParamResponse {
16841 param: param__.unwrap_or_default(),
16842 })
16843 }
16844 }
16845 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16846 }
16847}
16848impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16849 #[allow(deprecated)]
16850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16851 where
16852 S: serde::Serializer,
16853 {
16854 use serde::ser::SerializeStruct;
16855 let mut len = 0;
16856 if self.job_id != 0 {
16857 len += 1;
16858 }
16859 if self.aligned {
16860 len += 1;
16861 }
16862 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16863 if self.job_id != 0 {
16864 struct_ser.serialize_field("jobId", &self.job_id)?;
16865 }
16866 if self.aligned {
16867 struct_ser.serialize_field("aligned", &self.aligned)?;
16868 }
16869 struct_ser.end()
16870 }
16871}
16872impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16873 #[allow(deprecated)]
16874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16875 where
16876 D: serde::Deserializer<'de>,
16877 {
16878 const FIELDS: &[&str] = &[
16879 "job_id",
16880 "jobId",
16881 "aligned",
16882 ];
16883
16884 #[allow(clippy::enum_variant_names)]
16885 enum GeneratedField {
16886 JobId,
16887 Aligned,
16888 }
16889 impl<'de> serde::Deserialize<'de> for GeneratedField {
16890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16891 where
16892 D: serde::Deserializer<'de>,
16893 {
16894 struct GeneratedVisitor;
16895
16896 impl serde::de::Visitor<'_> for GeneratedVisitor {
16897 type Value = GeneratedField;
16898
16899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16900 write!(formatter, "expected one of: {:?}", &FIELDS)
16901 }
16902
16903 #[allow(unused_variables)]
16904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16905 where
16906 E: serde::de::Error,
16907 {
16908 match value {
16909 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16910 "aligned" => Ok(GeneratedField::Aligned),
16911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16912 }
16913 }
16914 }
16915 deserializer.deserialize_identifier(GeneratedVisitor)
16916 }
16917 }
16918 struct GeneratedVisitor;
16919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16920 type Value = SetSyncLogStoreAlignedRequest;
16921
16922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16923 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16924 }
16925
16926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16927 where
16928 V: serde::de::MapAccess<'de>,
16929 {
16930 let mut job_id__ = None;
16931 let mut aligned__ = None;
16932 while let Some(k) = map_.next_key()? {
16933 match k {
16934 GeneratedField::JobId => {
16935 if job_id__.is_some() {
16936 return Err(serde::de::Error::duplicate_field("jobId"));
16937 }
16938 job_id__ =
16939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16940 ;
16941 }
16942 GeneratedField::Aligned => {
16943 if aligned__.is_some() {
16944 return Err(serde::de::Error::duplicate_field("aligned"));
16945 }
16946 aligned__ = Some(map_.next_value()?);
16947 }
16948 }
16949 }
16950 Ok(SetSyncLogStoreAlignedRequest {
16951 job_id: job_id__.unwrap_or_default(),
16952 aligned: aligned__.unwrap_or_default(),
16953 })
16954 }
16955 }
16956 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16957 }
16958}
16959impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16960 #[allow(deprecated)]
16961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16962 where
16963 S: serde::Serializer,
16964 {
16965 use serde::ser::SerializeStruct;
16966 let len = 0;
16967 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16968 struct_ser.end()
16969 }
16970}
16971impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16972 #[allow(deprecated)]
16973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16974 where
16975 D: serde::Deserializer<'de>,
16976 {
16977 const FIELDS: &[&str] = &[
16978 ];
16979
16980 #[allow(clippy::enum_variant_names)]
16981 enum GeneratedField {
16982 }
16983 impl<'de> serde::Deserialize<'de> for GeneratedField {
16984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16985 where
16986 D: serde::Deserializer<'de>,
16987 {
16988 struct GeneratedVisitor;
16989
16990 impl serde::de::Visitor<'_> for GeneratedVisitor {
16991 type Value = GeneratedField;
16992
16993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16994 write!(formatter, "expected one of: {:?}", &FIELDS)
16995 }
16996
16997 #[allow(unused_variables)]
16998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16999 where
17000 E: serde::de::Error,
17001 {
17002 Err(serde::de::Error::unknown_field(value, FIELDS))
17003 }
17004 }
17005 deserializer.deserialize_identifier(GeneratedVisitor)
17006 }
17007 }
17008 struct GeneratedVisitor;
17009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17010 type Value = SetSyncLogStoreAlignedResponse;
17011
17012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17013 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
17014 }
17015
17016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
17017 where
17018 V: serde::de::MapAccess<'de>,
17019 {
17020 while map_.next_key::<GeneratedField>()?.is_some() {
17021 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17022 }
17023 Ok(SetSyncLogStoreAlignedResponse {
17024 })
17025 }
17026 }
17027 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
17028 }
17029}
17030impl serde::Serialize for SetSystemParamRequest {
17031 #[allow(deprecated)]
17032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17033 where
17034 S: serde::Serializer,
17035 {
17036 use serde::ser::SerializeStruct;
17037 let mut len = 0;
17038 if !self.param.is_empty() {
17039 len += 1;
17040 }
17041 if self.value.is_some() {
17042 len += 1;
17043 }
17044 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
17045 if !self.param.is_empty() {
17046 struct_ser.serialize_field("param", &self.param)?;
17047 }
17048 if let Some(v) = self.value.as_ref() {
17049 struct_ser.serialize_field("value", v)?;
17050 }
17051 struct_ser.end()
17052 }
17053}
17054impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
17055 #[allow(deprecated)]
17056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17057 where
17058 D: serde::Deserializer<'de>,
17059 {
17060 const FIELDS: &[&str] = &[
17061 "param",
17062 "value",
17063 ];
17064
17065 #[allow(clippy::enum_variant_names)]
17066 enum GeneratedField {
17067 Param,
17068 Value,
17069 }
17070 impl<'de> serde::Deserialize<'de> for GeneratedField {
17071 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17072 where
17073 D: serde::Deserializer<'de>,
17074 {
17075 struct GeneratedVisitor;
17076
17077 impl serde::de::Visitor<'_> for GeneratedVisitor {
17078 type Value = GeneratedField;
17079
17080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17081 write!(formatter, "expected one of: {:?}", &FIELDS)
17082 }
17083
17084 #[allow(unused_variables)]
17085 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17086 where
17087 E: serde::de::Error,
17088 {
17089 match value {
17090 "param" => Ok(GeneratedField::Param),
17091 "value" => Ok(GeneratedField::Value),
17092 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17093 }
17094 }
17095 }
17096 deserializer.deserialize_identifier(GeneratedVisitor)
17097 }
17098 }
17099 struct GeneratedVisitor;
17100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17101 type Value = SetSystemParamRequest;
17102
17103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17104 formatter.write_str("struct meta.SetSystemParamRequest")
17105 }
17106
17107 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
17108 where
17109 V: serde::de::MapAccess<'de>,
17110 {
17111 let mut param__ = None;
17112 let mut value__ = None;
17113 while let Some(k) = map_.next_key()? {
17114 match k {
17115 GeneratedField::Param => {
17116 if param__.is_some() {
17117 return Err(serde::de::Error::duplicate_field("param"));
17118 }
17119 param__ = Some(map_.next_value()?);
17120 }
17121 GeneratedField::Value => {
17122 if value__.is_some() {
17123 return Err(serde::de::Error::duplicate_field("value"));
17124 }
17125 value__ = map_.next_value()?;
17126 }
17127 }
17128 }
17129 Ok(SetSystemParamRequest {
17130 param: param__.unwrap_or_default(),
17131 value: value__,
17132 })
17133 }
17134 }
17135 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
17136 }
17137}
17138impl serde::Serialize for SetSystemParamResponse {
17139 #[allow(deprecated)]
17140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17141 where
17142 S: serde::Serializer,
17143 {
17144 use serde::ser::SerializeStruct;
17145 let mut len = 0;
17146 if self.params.is_some() {
17147 len += 1;
17148 }
17149 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
17150 if let Some(v) = self.params.as_ref() {
17151 struct_ser.serialize_field("params", v)?;
17152 }
17153 struct_ser.end()
17154 }
17155}
17156impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
17157 #[allow(deprecated)]
17158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17159 where
17160 D: serde::Deserializer<'de>,
17161 {
17162 const FIELDS: &[&str] = &[
17163 "params",
17164 ];
17165
17166 #[allow(clippy::enum_variant_names)]
17167 enum GeneratedField {
17168 Params,
17169 }
17170 impl<'de> serde::Deserialize<'de> for GeneratedField {
17171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17172 where
17173 D: serde::Deserializer<'de>,
17174 {
17175 struct GeneratedVisitor;
17176
17177 impl serde::de::Visitor<'_> for GeneratedVisitor {
17178 type Value = GeneratedField;
17179
17180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17181 write!(formatter, "expected one of: {:?}", &FIELDS)
17182 }
17183
17184 #[allow(unused_variables)]
17185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17186 where
17187 E: serde::de::Error,
17188 {
17189 match value {
17190 "params" => Ok(GeneratedField::Params),
17191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17192 }
17193 }
17194 }
17195 deserializer.deserialize_identifier(GeneratedVisitor)
17196 }
17197 }
17198 struct GeneratedVisitor;
17199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17200 type Value = SetSystemParamResponse;
17201
17202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17203 formatter.write_str("struct meta.SetSystemParamResponse")
17204 }
17205
17206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
17207 where
17208 V: serde::de::MapAccess<'de>,
17209 {
17210 let mut params__ = None;
17211 while let Some(k) = map_.next_key()? {
17212 match k {
17213 GeneratedField::Params => {
17214 if params__.is_some() {
17215 return Err(serde::de::Error::duplicate_field("params"));
17216 }
17217 params__ = map_.next_value()?;
17218 }
17219 }
17220 }
17221 Ok(SetSystemParamResponse {
17222 params: params__,
17223 })
17224 }
17225 }
17226 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
17227 }
17228}
17229impl serde::Serialize for SubscribeRequest {
17230 #[allow(deprecated)]
17231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17232 where
17233 S: serde::Serializer,
17234 {
17235 use serde::ser::SerializeStruct;
17236 let mut len = 0;
17237 if self.subscribe_type != 0 {
17238 len += 1;
17239 }
17240 if self.host.is_some() {
17241 len += 1;
17242 }
17243 if self.worker_id != 0 {
17244 len += 1;
17245 }
17246 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
17247 if self.subscribe_type != 0 {
17248 let v = SubscribeType::try_from(self.subscribe_type)
17249 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
17250 struct_ser.serialize_field("subscribeType", &v)?;
17251 }
17252 if let Some(v) = self.host.as_ref() {
17253 struct_ser.serialize_field("host", v)?;
17254 }
17255 if self.worker_id != 0 {
17256 struct_ser.serialize_field("workerId", &self.worker_id)?;
17257 }
17258 struct_ser.end()
17259 }
17260}
17261impl<'de> serde::Deserialize<'de> for SubscribeRequest {
17262 #[allow(deprecated)]
17263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17264 where
17265 D: serde::Deserializer<'de>,
17266 {
17267 const FIELDS: &[&str] = &[
17268 "subscribe_type",
17269 "subscribeType",
17270 "host",
17271 "worker_id",
17272 "workerId",
17273 ];
17274
17275 #[allow(clippy::enum_variant_names)]
17276 enum GeneratedField {
17277 SubscribeType,
17278 Host,
17279 WorkerId,
17280 }
17281 impl<'de> serde::Deserialize<'de> for GeneratedField {
17282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17283 where
17284 D: serde::Deserializer<'de>,
17285 {
17286 struct GeneratedVisitor;
17287
17288 impl serde::de::Visitor<'_> for GeneratedVisitor {
17289 type Value = GeneratedField;
17290
17291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17292 write!(formatter, "expected one of: {:?}", &FIELDS)
17293 }
17294
17295 #[allow(unused_variables)]
17296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17297 where
17298 E: serde::de::Error,
17299 {
17300 match value {
17301 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
17302 "host" => Ok(GeneratedField::Host),
17303 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
17304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17305 }
17306 }
17307 }
17308 deserializer.deserialize_identifier(GeneratedVisitor)
17309 }
17310 }
17311 struct GeneratedVisitor;
17312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17313 type Value = SubscribeRequest;
17314
17315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17316 formatter.write_str("struct meta.SubscribeRequest")
17317 }
17318
17319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
17320 where
17321 V: serde::de::MapAccess<'de>,
17322 {
17323 let mut subscribe_type__ = None;
17324 let mut host__ = None;
17325 let mut worker_id__ = None;
17326 while let Some(k) = map_.next_key()? {
17327 match k {
17328 GeneratedField::SubscribeType => {
17329 if subscribe_type__.is_some() {
17330 return Err(serde::de::Error::duplicate_field("subscribeType"));
17331 }
17332 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
17333 }
17334 GeneratedField::Host => {
17335 if host__.is_some() {
17336 return Err(serde::de::Error::duplicate_field("host"));
17337 }
17338 host__ = map_.next_value()?;
17339 }
17340 GeneratedField::WorkerId => {
17341 if worker_id__.is_some() {
17342 return Err(serde::de::Error::duplicate_field("workerId"));
17343 }
17344 worker_id__ =
17345 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17346 ;
17347 }
17348 }
17349 }
17350 Ok(SubscribeRequest {
17351 subscribe_type: subscribe_type__.unwrap_or_default(),
17352 host: host__,
17353 worker_id: worker_id__.unwrap_or_default(),
17354 })
17355 }
17356 }
17357 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
17358 }
17359}
17360impl serde::Serialize for SubscribeResponse {
17361 #[allow(deprecated)]
17362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17363 where
17364 S: serde::Serializer,
17365 {
17366 use serde::ser::SerializeStruct;
17367 let mut len = 0;
17368 if self.status.is_some() {
17369 len += 1;
17370 }
17371 if self.operation != 0 {
17372 len += 1;
17373 }
17374 if self.version != 0 {
17375 len += 1;
17376 }
17377 if self.info.is_some() {
17378 len += 1;
17379 }
17380 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
17381 if let Some(v) = self.status.as_ref() {
17382 struct_ser.serialize_field("status", v)?;
17383 }
17384 if self.operation != 0 {
17385 let v = subscribe_response::Operation::try_from(self.operation)
17386 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
17387 struct_ser.serialize_field("operation", &v)?;
17388 }
17389 if self.version != 0 {
17390 #[allow(clippy::needless_borrow)]
17391 #[allow(clippy::needless_borrows_for_generic_args)]
17392 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
17393 }
17394 if let Some(v) = self.info.as_ref() {
17395 match v {
17396 subscribe_response::Info::Database(v) => {
17397 struct_ser.serialize_field("database", v)?;
17398 }
17399 subscribe_response::Info::Schema(v) => {
17400 struct_ser.serialize_field("schema", v)?;
17401 }
17402 subscribe_response::Info::Function(v) => {
17403 struct_ser.serialize_field("function", v)?;
17404 }
17405 subscribe_response::Info::User(v) => {
17406 struct_ser.serialize_field("user", v)?;
17407 }
17408 subscribe_response::Info::SessionParam(v) => {
17409 struct_ser.serialize_field("sessionParam", v)?;
17410 }
17411 subscribe_response::Info::Node(v) => {
17412 struct_ser.serialize_field("node", v)?;
17413 }
17414 subscribe_response::Info::HummockVersionDeltas(v) => {
17415 struct_ser.serialize_field("hummockVersionDeltas", v)?;
17416 }
17417 subscribe_response::Info::Snapshot(v) => {
17418 struct_ser.serialize_field("snapshot", v)?;
17419 }
17420 subscribe_response::Info::MetaBackupManifestId(v) => {
17421 struct_ser.serialize_field("metaBackupManifestId", v)?;
17422 }
17423 subscribe_response::Info::SystemParams(v) => {
17424 struct_ser.serialize_field("systemParams", v)?;
17425 }
17426 subscribe_response::Info::HummockWriteLimits(v) => {
17427 struct_ser.serialize_field("hummockWriteLimits", v)?;
17428 }
17429 subscribe_response::Info::ObjectGroup(v) => {
17430 struct_ser.serialize_field("objectGroup", v)?;
17431 }
17432 subscribe_response::Info::Connection(v) => {
17433 struct_ser.serialize_field("connection", v)?;
17434 }
17435 subscribe_response::Info::HummockStats(v) => {
17436 struct_ser.serialize_field("hummockStats", v)?;
17437 }
17438 subscribe_response::Info::Recovery(v) => {
17439 struct_ser.serialize_field("recovery", v)?;
17440 }
17441 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
17442 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
17443 }
17444 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
17445 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
17446 }
17447 subscribe_response::Info::Secret(v) => {
17448 struct_ser.serialize_field("secret", v)?;
17449 }
17450 subscribe_response::Info::ClusterResource(v) => {
17451 struct_ser.serialize_field("clusterResource", v)?;
17452 }
17453 subscribe_response::Info::TableRefillRuntimeConfig(v) => {
17454 struct_ser.serialize_field("tableRefillRuntimeConfig", v)?;
17455 }
17456 }
17457 }
17458 struct_ser.end()
17459 }
17460}
17461impl<'de> serde::Deserialize<'de> for SubscribeResponse {
17462 #[allow(deprecated)]
17463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17464 where
17465 D: serde::Deserializer<'de>,
17466 {
17467 const FIELDS: &[&str] = &[
17468 "status",
17469 "operation",
17470 "version",
17471 "database",
17472 "schema",
17473 "function",
17474 "user",
17475 "session_param",
17476 "sessionParam",
17477 "node",
17478 "hummock_version_deltas",
17479 "hummockVersionDeltas",
17480 "snapshot",
17481 "meta_backup_manifest_id",
17482 "metaBackupManifestId",
17483 "system_params",
17484 "systemParams",
17485 "hummock_write_limits",
17486 "hummockWriteLimits",
17487 "object_group",
17488 "objectGroup",
17489 "connection",
17490 "hummock_stats",
17491 "hummockStats",
17492 "recovery",
17493 "streaming_worker_slot_mapping",
17494 "streamingWorkerSlotMapping",
17495 "serving_worker_slot_mappings",
17496 "servingWorkerSlotMappings",
17497 "secret",
17498 "cluster_resource",
17499 "clusterResource",
17500 "table_refill_runtime_config",
17501 "tableRefillRuntimeConfig",
17502 ];
17503
17504 #[allow(clippy::enum_variant_names)]
17505 enum GeneratedField {
17506 Status,
17507 Operation,
17508 Version,
17509 Database,
17510 Schema,
17511 Function,
17512 User,
17513 SessionParam,
17514 Node,
17515 HummockVersionDeltas,
17516 Snapshot,
17517 MetaBackupManifestId,
17518 SystemParams,
17519 HummockWriteLimits,
17520 ObjectGroup,
17521 Connection,
17522 HummockStats,
17523 Recovery,
17524 StreamingWorkerSlotMapping,
17525 ServingWorkerSlotMappings,
17526 Secret,
17527 ClusterResource,
17528 TableRefillRuntimeConfig,
17529 }
17530 impl<'de> serde::Deserialize<'de> for GeneratedField {
17531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17532 where
17533 D: serde::Deserializer<'de>,
17534 {
17535 struct GeneratedVisitor;
17536
17537 impl serde::de::Visitor<'_> for GeneratedVisitor {
17538 type Value = GeneratedField;
17539
17540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17541 write!(formatter, "expected one of: {:?}", &FIELDS)
17542 }
17543
17544 #[allow(unused_variables)]
17545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17546 where
17547 E: serde::de::Error,
17548 {
17549 match value {
17550 "status" => Ok(GeneratedField::Status),
17551 "operation" => Ok(GeneratedField::Operation),
17552 "version" => Ok(GeneratedField::Version),
17553 "database" => Ok(GeneratedField::Database),
17554 "schema" => Ok(GeneratedField::Schema),
17555 "function" => Ok(GeneratedField::Function),
17556 "user" => Ok(GeneratedField::User),
17557 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
17558 "node" => Ok(GeneratedField::Node),
17559 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
17560 "snapshot" => Ok(GeneratedField::Snapshot),
17561 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
17562 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
17563 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
17564 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
17565 "connection" => Ok(GeneratedField::Connection),
17566 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
17567 "recovery" => Ok(GeneratedField::Recovery),
17568 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
17569 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
17570 "secret" => Ok(GeneratedField::Secret),
17571 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
17572 "tableRefillRuntimeConfig" | "table_refill_runtime_config" => Ok(GeneratedField::TableRefillRuntimeConfig),
17573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17574 }
17575 }
17576 }
17577 deserializer.deserialize_identifier(GeneratedVisitor)
17578 }
17579 }
17580 struct GeneratedVisitor;
17581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17582 type Value = SubscribeResponse;
17583
17584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17585 formatter.write_str("struct meta.SubscribeResponse")
17586 }
17587
17588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
17589 where
17590 V: serde::de::MapAccess<'de>,
17591 {
17592 let mut status__ = None;
17593 let mut operation__ = None;
17594 let mut version__ = None;
17595 let mut info__ = None;
17596 while let Some(k) = map_.next_key()? {
17597 match k {
17598 GeneratedField::Status => {
17599 if status__.is_some() {
17600 return Err(serde::de::Error::duplicate_field("status"));
17601 }
17602 status__ = map_.next_value()?;
17603 }
17604 GeneratedField::Operation => {
17605 if operation__.is_some() {
17606 return Err(serde::de::Error::duplicate_field("operation"));
17607 }
17608 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
17609 }
17610 GeneratedField::Version => {
17611 if version__.is_some() {
17612 return Err(serde::de::Error::duplicate_field("version"));
17613 }
17614 version__ =
17615 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17616 ;
17617 }
17618 GeneratedField::Database => {
17619 if info__.is_some() {
17620 return Err(serde::de::Error::duplicate_field("database"));
17621 }
17622 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
17623;
17624 }
17625 GeneratedField::Schema => {
17626 if info__.is_some() {
17627 return Err(serde::de::Error::duplicate_field("schema"));
17628 }
17629 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
17630;
17631 }
17632 GeneratedField::Function => {
17633 if info__.is_some() {
17634 return Err(serde::de::Error::duplicate_field("function"));
17635 }
17636 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
17637;
17638 }
17639 GeneratedField::User => {
17640 if info__.is_some() {
17641 return Err(serde::de::Error::duplicate_field("user"));
17642 }
17643 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
17644;
17645 }
17646 GeneratedField::SessionParam => {
17647 if info__.is_some() {
17648 return Err(serde::de::Error::duplicate_field("sessionParam"));
17649 }
17650 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
17651;
17652 }
17653 GeneratedField::Node => {
17654 if info__.is_some() {
17655 return Err(serde::de::Error::duplicate_field("node"));
17656 }
17657 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
17658;
17659 }
17660 GeneratedField::HummockVersionDeltas => {
17661 if info__.is_some() {
17662 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
17663 }
17664 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
17665;
17666 }
17667 GeneratedField::Snapshot => {
17668 if info__.is_some() {
17669 return Err(serde::de::Error::duplicate_field("snapshot"));
17670 }
17671 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
17672;
17673 }
17674 GeneratedField::MetaBackupManifestId => {
17675 if info__.is_some() {
17676 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
17677 }
17678 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
17679;
17680 }
17681 GeneratedField::SystemParams => {
17682 if info__.is_some() {
17683 return Err(serde::de::Error::duplicate_field("systemParams"));
17684 }
17685 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
17686;
17687 }
17688 GeneratedField::HummockWriteLimits => {
17689 if info__.is_some() {
17690 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
17691 }
17692 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
17693;
17694 }
17695 GeneratedField::ObjectGroup => {
17696 if info__.is_some() {
17697 return Err(serde::de::Error::duplicate_field("objectGroup"));
17698 }
17699 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
17700;
17701 }
17702 GeneratedField::Connection => {
17703 if info__.is_some() {
17704 return Err(serde::de::Error::duplicate_field("connection"));
17705 }
17706 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
17707;
17708 }
17709 GeneratedField::HummockStats => {
17710 if info__.is_some() {
17711 return Err(serde::de::Error::duplicate_field("hummockStats"));
17712 }
17713 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
17714;
17715 }
17716 GeneratedField::Recovery => {
17717 if info__.is_some() {
17718 return Err(serde::de::Error::duplicate_field("recovery"));
17719 }
17720 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
17721;
17722 }
17723 GeneratedField::StreamingWorkerSlotMapping => {
17724 if info__.is_some() {
17725 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
17726 }
17727 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
17728;
17729 }
17730 GeneratedField::ServingWorkerSlotMappings => {
17731 if info__.is_some() {
17732 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
17733 }
17734 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
17735;
17736 }
17737 GeneratedField::Secret => {
17738 if info__.is_some() {
17739 return Err(serde::de::Error::duplicate_field("secret"));
17740 }
17741 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
17742;
17743 }
17744 GeneratedField::ClusterResource => {
17745 if info__.is_some() {
17746 return Err(serde::de::Error::duplicate_field("clusterResource"));
17747 }
17748 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
17749;
17750 }
17751 GeneratedField::TableRefillRuntimeConfig => {
17752 if info__.is_some() {
17753 return Err(serde::de::Error::duplicate_field("tableRefillRuntimeConfig"));
17754 }
17755 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::TableRefillRuntimeConfig)
17756;
17757 }
17758 }
17759 }
17760 Ok(SubscribeResponse {
17761 status: status__,
17762 operation: operation__.unwrap_or_default(),
17763 version: version__.unwrap_or_default(),
17764 info: info__,
17765 })
17766 }
17767 }
17768 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
17769 }
17770}
17771impl serde::Serialize for subscribe_response::Operation {
17772 #[allow(deprecated)]
17773 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17774 where
17775 S: serde::Serializer,
17776 {
17777 let variant = match self {
17778 Self::Unspecified => "UNSPECIFIED",
17779 Self::Add => "ADD",
17780 Self::Delete => "DELETE",
17781 Self::Update => "UPDATE",
17782 Self::Snapshot => "SNAPSHOT",
17783 };
17784 serializer.serialize_str(variant)
17785 }
17786}
17787impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
17788 #[allow(deprecated)]
17789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17790 where
17791 D: serde::Deserializer<'de>,
17792 {
17793 const FIELDS: &[&str] = &[
17794 "UNSPECIFIED",
17795 "ADD",
17796 "DELETE",
17797 "UPDATE",
17798 "SNAPSHOT",
17799 ];
17800
17801 struct GeneratedVisitor;
17802
17803 impl serde::de::Visitor<'_> for GeneratedVisitor {
17804 type Value = subscribe_response::Operation;
17805
17806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17807 write!(formatter, "expected one of: {:?}", &FIELDS)
17808 }
17809
17810 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17811 where
17812 E: serde::de::Error,
17813 {
17814 i32::try_from(v)
17815 .ok()
17816 .and_then(|x| x.try_into().ok())
17817 .ok_or_else(|| {
17818 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17819 })
17820 }
17821
17822 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17823 where
17824 E: serde::de::Error,
17825 {
17826 i32::try_from(v)
17827 .ok()
17828 .and_then(|x| x.try_into().ok())
17829 .ok_or_else(|| {
17830 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17831 })
17832 }
17833
17834 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17835 where
17836 E: serde::de::Error,
17837 {
17838 match value {
17839 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17840 "ADD" => Ok(subscribe_response::Operation::Add),
17841 "DELETE" => Ok(subscribe_response::Operation::Delete),
17842 "UPDATE" => Ok(subscribe_response::Operation::Update),
17843 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17844 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17845 }
17846 }
17847 }
17848 deserializer.deserialize_any(GeneratedVisitor)
17849 }
17850}
17851impl serde::Serialize for SubscribeType {
17852 #[allow(deprecated)]
17853 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17854 where
17855 S: serde::Serializer,
17856 {
17857 let variant = match self {
17858 Self::Unspecified => "UNSPECIFIED",
17859 Self::Frontend => "FRONTEND",
17860 Self::Hummock => "HUMMOCK",
17861 Self::Compactor => "COMPACTOR",
17862 Self::Compute => "COMPUTE",
17863 };
17864 serializer.serialize_str(variant)
17865 }
17866}
17867impl<'de> serde::Deserialize<'de> for SubscribeType {
17868 #[allow(deprecated)]
17869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17870 where
17871 D: serde::Deserializer<'de>,
17872 {
17873 const FIELDS: &[&str] = &[
17874 "UNSPECIFIED",
17875 "FRONTEND",
17876 "HUMMOCK",
17877 "COMPACTOR",
17878 "COMPUTE",
17879 ];
17880
17881 struct GeneratedVisitor;
17882
17883 impl serde::de::Visitor<'_> for GeneratedVisitor {
17884 type Value = SubscribeType;
17885
17886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17887 write!(formatter, "expected one of: {:?}", &FIELDS)
17888 }
17889
17890 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17891 where
17892 E: serde::de::Error,
17893 {
17894 i32::try_from(v)
17895 .ok()
17896 .and_then(|x| x.try_into().ok())
17897 .ok_or_else(|| {
17898 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17899 })
17900 }
17901
17902 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17903 where
17904 E: serde::de::Error,
17905 {
17906 i32::try_from(v)
17907 .ok()
17908 .and_then(|x| x.try_into().ok())
17909 .ok_or_else(|| {
17910 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17911 })
17912 }
17913
17914 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17915 where
17916 E: serde::de::Error,
17917 {
17918 match value {
17919 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17920 "FRONTEND" => Ok(SubscribeType::Frontend),
17921 "HUMMOCK" => Ok(SubscribeType::Hummock),
17922 "COMPACTOR" => Ok(SubscribeType::Compactor),
17923 "COMPUTE" => Ok(SubscribeType::Compute),
17924 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17925 }
17926 }
17927 }
17928 deserializer.deserialize_any(GeneratedVisitor)
17929 }
17930}
17931impl serde::Serialize for SystemParams {
17932 #[allow(deprecated)]
17933 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17934 where
17935 S: serde::Serializer,
17936 {
17937 use serde::ser::SerializeStruct;
17938 let mut len = 0;
17939 if self.barrier_interval_ms.is_some() {
17940 len += 1;
17941 }
17942 if self.checkpoint_frequency.is_some() {
17943 len += 1;
17944 }
17945 if self.sstable_size_mb.is_some() {
17946 len += 1;
17947 }
17948 if self.block_size_kb.is_some() {
17949 len += 1;
17950 }
17951 if self.bloom_false_positive.is_some() {
17952 len += 1;
17953 }
17954 if self.state_store.is_some() {
17955 len += 1;
17956 }
17957 if self.data_directory.is_some() {
17958 len += 1;
17959 }
17960 if self.backup_storage_url.is_some() {
17961 len += 1;
17962 }
17963 if self.backup_storage_directory.is_some() {
17964 len += 1;
17965 }
17966 if self.telemetry_enabled.is_some() {
17967 len += 1;
17968 }
17969 if self.parallel_compact_size_mb.is_some() {
17970 len += 1;
17971 }
17972 if self.max_concurrent_creating_streaming_jobs.is_some() {
17973 len += 1;
17974 }
17975 if self.pause_on_next_bootstrap.is_some() {
17976 len += 1;
17977 }
17978 if self.wasm_storage_url.is_some() {
17979 len += 1;
17980 }
17981 if self.enable_tracing.is_some() {
17982 len += 1;
17983 }
17984 if self.use_new_object_prefix_strategy.is_some() {
17985 len += 1;
17986 }
17987 if self.license_key.is_some() {
17988 len += 1;
17989 }
17990 if self.time_travel_retention_ms.is_some() {
17991 len += 1;
17992 }
17993 if self.adaptive_parallelism_strategy.is_some() {
17994 len += 1;
17995 }
17996 if self.per_database_isolation.is_some() {
17997 len += 1;
17998 }
17999 if self.enforce_secret.is_some() {
18000 len += 1;
18001 }
18002 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
18003 if let Some(v) = self.barrier_interval_ms.as_ref() {
18004 struct_ser.serialize_field("barrierIntervalMs", v)?;
18005 }
18006 if let Some(v) = self.checkpoint_frequency.as_ref() {
18007 #[allow(clippy::needless_borrow)]
18008 #[allow(clippy::needless_borrows_for_generic_args)]
18009 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
18010 }
18011 if let Some(v) = self.sstable_size_mb.as_ref() {
18012 struct_ser.serialize_field("sstableSizeMb", v)?;
18013 }
18014 if let Some(v) = self.block_size_kb.as_ref() {
18015 struct_ser.serialize_field("blockSizeKb", v)?;
18016 }
18017 if let Some(v) = self.bloom_false_positive.as_ref() {
18018 struct_ser.serialize_field("bloomFalsePositive", v)?;
18019 }
18020 if let Some(v) = self.state_store.as_ref() {
18021 struct_ser.serialize_field("stateStore", v)?;
18022 }
18023 if let Some(v) = self.data_directory.as_ref() {
18024 struct_ser.serialize_field("dataDirectory", v)?;
18025 }
18026 if let Some(v) = self.backup_storage_url.as_ref() {
18027 struct_ser.serialize_field("backupStorageUrl", v)?;
18028 }
18029 if let Some(v) = self.backup_storage_directory.as_ref() {
18030 struct_ser.serialize_field("backupStorageDirectory", v)?;
18031 }
18032 if let Some(v) = self.telemetry_enabled.as_ref() {
18033 struct_ser.serialize_field("telemetryEnabled", v)?;
18034 }
18035 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
18036 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
18037 }
18038 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
18039 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
18040 }
18041 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
18042 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
18043 }
18044 if let Some(v) = self.wasm_storage_url.as_ref() {
18045 struct_ser.serialize_field("wasmStorageUrl", v)?;
18046 }
18047 if let Some(v) = self.enable_tracing.as_ref() {
18048 struct_ser.serialize_field("enableTracing", v)?;
18049 }
18050 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
18051 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
18052 }
18053 if let Some(v) = self.license_key.as_ref() {
18054 struct_ser.serialize_field("licenseKey", v)?;
18055 }
18056 if let Some(v) = self.time_travel_retention_ms.as_ref() {
18057 #[allow(clippy::needless_borrow)]
18058 #[allow(clippy::needless_borrows_for_generic_args)]
18059 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
18060 }
18061 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
18062 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
18063 }
18064 if let Some(v) = self.per_database_isolation.as_ref() {
18065 struct_ser.serialize_field("perDatabaseIsolation", v)?;
18066 }
18067 if let Some(v) = self.enforce_secret.as_ref() {
18068 struct_ser.serialize_field("enforceSecret", v)?;
18069 }
18070 struct_ser.end()
18071 }
18072}
18073impl<'de> serde::Deserialize<'de> for SystemParams {
18074 #[allow(deprecated)]
18075 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18076 where
18077 D: serde::Deserializer<'de>,
18078 {
18079 const FIELDS: &[&str] = &[
18080 "barrier_interval_ms",
18081 "barrierIntervalMs",
18082 "checkpoint_frequency",
18083 "checkpointFrequency",
18084 "sstable_size_mb",
18085 "sstableSizeMb",
18086 "block_size_kb",
18087 "blockSizeKb",
18088 "bloom_false_positive",
18089 "bloomFalsePositive",
18090 "state_store",
18091 "stateStore",
18092 "data_directory",
18093 "dataDirectory",
18094 "backup_storage_url",
18095 "backupStorageUrl",
18096 "backup_storage_directory",
18097 "backupStorageDirectory",
18098 "telemetry_enabled",
18099 "telemetryEnabled",
18100 "parallel_compact_size_mb",
18101 "parallelCompactSizeMb",
18102 "max_concurrent_creating_streaming_jobs",
18103 "maxConcurrentCreatingStreamingJobs",
18104 "pause_on_next_bootstrap",
18105 "pauseOnNextBootstrap",
18106 "wasm_storage_url",
18107 "wasmStorageUrl",
18108 "enable_tracing",
18109 "enableTracing",
18110 "use_new_object_prefix_strategy",
18111 "useNewObjectPrefixStrategy",
18112 "license_key",
18113 "licenseKey",
18114 "time_travel_retention_ms",
18115 "timeTravelRetentionMs",
18116 "adaptive_parallelism_strategy",
18117 "adaptiveParallelismStrategy",
18118 "per_database_isolation",
18119 "perDatabaseIsolation",
18120 "enforce_secret",
18121 "enforceSecret",
18122 ];
18123
18124 #[allow(clippy::enum_variant_names)]
18125 enum GeneratedField {
18126 BarrierIntervalMs,
18127 CheckpointFrequency,
18128 SstableSizeMb,
18129 BlockSizeKb,
18130 BloomFalsePositive,
18131 StateStore,
18132 DataDirectory,
18133 BackupStorageUrl,
18134 BackupStorageDirectory,
18135 TelemetryEnabled,
18136 ParallelCompactSizeMb,
18137 MaxConcurrentCreatingStreamingJobs,
18138 PauseOnNextBootstrap,
18139 WasmStorageUrl,
18140 EnableTracing,
18141 UseNewObjectPrefixStrategy,
18142 LicenseKey,
18143 TimeTravelRetentionMs,
18144 AdaptiveParallelismStrategy,
18145 PerDatabaseIsolation,
18146 EnforceSecret,
18147 }
18148 impl<'de> serde::Deserialize<'de> for GeneratedField {
18149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18150 where
18151 D: serde::Deserializer<'de>,
18152 {
18153 struct GeneratedVisitor;
18154
18155 impl serde::de::Visitor<'_> for GeneratedVisitor {
18156 type Value = GeneratedField;
18157
18158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18159 write!(formatter, "expected one of: {:?}", &FIELDS)
18160 }
18161
18162 #[allow(unused_variables)]
18163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18164 where
18165 E: serde::de::Error,
18166 {
18167 match value {
18168 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
18169 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
18170 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
18171 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
18172 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
18173 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
18174 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
18175 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
18176 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
18177 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
18178 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
18179 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
18180 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
18181 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
18182 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
18183 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
18184 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
18185 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
18186 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
18187 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
18188 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
18189 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18190 }
18191 }
18192 }
18193 deserializer.deserialize_identifier(GeneratedVisitor)
18194 }
18195 }
18196 struct GeneratedVisitor;
18197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18198 type Value = SystemParams;
18199
18200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18201 formatter.write_str("struct meta.SystemParams")
18202 }
18203
18204 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
18205 where
18206 V: serde::de::MapAccess<'de>,
18207 {
18208 let mut barrier_interval_ms__ = None;
18209 let mut checkpoint_frequency__ = None;
18210 let mut sstable_size_mb__ = None;
18211 let mut block_size_kb__ = None;
18212 let mut bloom_false_positive__ = None;
18213 let mut state_store__ = None;
18214 let mut data_directory__ = None;
18215 let mut backup_storage_url__ = None;
18216 let mut backup_storage_directory__ = None;
18217 let mut telemetry_enabled__ = None;
18218 let mut parallel_compact_size_mb__ = None;
18219 let mut max_concurrent_creating_streaming_jobs__ = None;
18220 let mut pause_on_next_bootstrap__ = None;
18221 let mut wasm_storage_url__ = None;
18222 let mut enable_tracing__ = None;
18223 let mut use_new_object_prefix_strategy__ = None;
18224 let mut license_key__ = None;
18225 let mut time_travel_retention_ms__ = None;
18226 let mut adaptive_parallelism_strategy__ = None;
18227 let mut per_database_isolation__ = None;
18228 let mut enforce_secret__ = None;
18229 while let Some(k) = map_.next_key()? {
18230 match k {
18231 GeneratedField::BarrierIntervalMs => {
18232 if barrier_interval_ms__.is_some() {
18233 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
18234 }
18235 barrier_interval_ms__ =
18236 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18237 ;
18238 }
18239 GeneratedField::CheckpointFrequency => {
18240 if checkpoint_frequency__.is_some() {
18241 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
18242 }
18243 checkpoint_frequency__ =
18244 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18245 ;
18246 }
18247 GeneratedField::SstableSizeMb => {
18248 if sstable_size_mb__.is_some() {
18249 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
18250 }
18251 sstable_size_mb__ =
18252 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18253 ;
18254 }
18255 GeneratedField::BlockSizeKb => {
18256 if block_size_kb__.is_some() {
18257 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
18258 }
18259 block_size_kb__ =
18260 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18261 ;
18262 }
18263 GeneratedField::BloomFalsePositive => {
18264 if bloom_false_positive__.is_some() {
18265 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
18266 }
18267 bloom_false_positive__ =
18268 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18269 ;
18270 }
18271 GeneratedField::StateStore => {
18272 if state_store__.is_some() {
18273 return Err(serde::de::Error::duplicate_field("stateStore"));
18274 }
18275 state_store__ = map_.next_value()?;
18276 }
18277 GeneratedField::DataDirectory => {
18278 if data_directory__.is_some() {
18279 return Err(serde::de::Error::duplicate_field("dataDirectory"));
18280 }
18281 data_directory__ = map_.next_value()?;
18282 }
18283 GeneratedField::BackupStorageUrl => {
18284 if backup_storage_url__.is_some() {
18285 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
18286 }
18287 backup_storage_url__ = map_.next_value()?;
18288 }
18289 GeneratedField::BackupStorageDirectory => {
18290 if backup_storage_directory__.is_some() {
18291 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
18292 }
18293 backup_storage_directory__ = map_.next_value()?;
18294 }
18295 GeneratedField::TelemetryEnabled => {
18296 if telemetry_enabled__.is_some() {
18297 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
18298 }
18299 telemetry_enabled__ = map_.next_value()?;
18300 }
18301 GeneratedField::ParallelCompactSizeMb => {
18302 if parallel_compact_size_mb__.is_some() {
18303 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
18304 }
18305 parallel_compact_size_mb__ =
18306 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18307 ;
18308 }
18309 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
18310 if max_concurrent_creating_streaming_jobs__.is_some() {
18311 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
18312 }
18313 max_concurrent_creating_streaming_jobs__ =
18314 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18315 ;
18316 }
18317 GeneratedField::PauseOnNextBootstrap => {
18318 if pause_on_next_bootstrap__.is_some() {
18319 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
18320 }
18321 pause_on_next_bootstrap__ = map_.next_value()?;
18322 }
18323 GeneratedField::WasmStorageUrl => {
18324 if wasm_storage_url__.is_some() {
18325 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
18326 }
18327 wasm_storage_url__ = map_.next_value()?;
18328 }
18329 GeneratedField::EnableTracing => {
18330 if enable_tracing__.is_some() {
18331 return Err(serde::de::Error::duplicate_field("enableTracing"));
18332 }
18333 enable_tracing__ = map_.next_value()?;
18334 }
18335 GeneratedField::UseNewObjectPrefixStrategy => {
18336 if use_new_object_prefix_strategy__.is_some() {
18337 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
18338 }
18339 use_new_object_prefix_strategy__ = map_.next_value()?;
18340 }
18341 GeneratedField::LicenseKey => {
18342 if license_key__.is_some() {
18343 return Err(serde::de::Error::duplicate_field("licenseKey"));
18344 }
18345 license_key__ = map_.next_value()?;
18346 }
18347 GeneratedField::TimeTravelRetentionMs => {
18348 if time_travel_retention_ms__.is_some() {
18349 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
18350 }
18351 time_travel_retention_ms__ =
18352 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18353 ;
18354 }
18355 GeneratedField::AdaptiveParallelismStrategy => {
18356 if adaptive_parallelism_strategy__.is_some() {
18357 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
18358 }
18359 adaptive_parallelism_strategy__ = map_.next_value()?;
18360 }
18361 GeneratedField::PerDatabaseIsolation => {
18362 if per_database_isolation__.is_some() {
18363 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
18364 }
18365 per_database_isolation__ = map_.next_value()?;
18366 }
18367 GeneratedField::EnforceSecret => {
18368 if enforce_secret__.is_some() {
18369 return Err(serde::de::Error::duplicate_field("enforceSecret"));
18370 }
18371 enforce_secret__ = map_.next_value()?;
18372 }
18373 }
18374 }
18375 Ok(SystemParams {
18376 barrier_interval_ms: barrier_interval_ms__,
18377 checkpoint_frequency: checkpoint_frequency__,
18378 sstable_size_mb: sstable_size_mb__,
18379 block_size_kb: block_size_kb__,
18380 bloom_false_positive: bloom_false_positive__,
18381 state_store: state_store__,
18382 data_directory: data_directory__,
18383 backup_storage_url: backup_storage_url__,
18384 backup_storage_directory: backup_storage_directory__,
18385 telemetry_enabled: telemetry_enabled__,
18386 parallel_compact_size_mb: parallel_compact_size_mb__,
18387 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
18388 pause_on_next_bootstrap: pause_on_next_bootstrap__,
18389 wasm_storage_url: wasm_storage_url__,
18390 enable_tracing: enable_tracing__,
18391 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
18392 license_key: license_key__,
18393 time_travel_retention_ms: time_travel_retention_ms__,
18394 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
18395 per_database_isolation: per_database_isolation__,
18396 enforce_secret: enforce_secret__,
18397 })
18398 }
18399 }
18400 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
18401 }
18402}
18403impl serde::Serialize for TableCacheRefillPolicies {
18404 #[allow(deprecated)]
18405 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18406 where
18407 S: serde::Serializer,
18408 {
18409 use serde::ser::SerializeStruct;
18410 let mut len = 0;
18411 if !self.table_policies.is_empty() {
18412 len += 1;
18413 }
18414 if !self.internal_table_policies.is_empty() {
18415 len += 1;
18416 }
18417 let mut struct_ser = serializer.serialize_struct("meta.TableCacheRefillPolicies", len)?;
18418 if !self.table_policies.is_empty() {
18419 struct_ser.serialize_field("tablePolicies", &self.table_policies)?;
18420 }
18421 if !self.internal_table_policies.is_empty() {
18422 struct_ser.serialize_field("internalTablePolicies", &self.internal_table_policies)?;
18423 }
18424 struct_ser.end()
18425 }
18426}
18427impl<'de> serde::Deserialize<'de> for TableCacheRefillPolicies {
18428 #[allow(deprecated)]
18429 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18430 where
18431 D: serde::Deserializer<'de>,
18432 {
18433 const FIELDS: &[&str] = &[
18434 "table_policies",
18435 "tablePolicies",
18436 "internal_table_policies",
18437 "internalTablePolicies",
18438 ];
18439
18440 #[allow(clippy::enum_variant_names)]
18441 enum GeneratedField {
18442 TablePolicies,
18443 InternalTablePolicies,
18444 }
18445 impl<'de> serde::Deserialize<'de> for GeneratedField {
18446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18447 where
18448 D: serde::Deserializer<'de>,
18449 {
18450 struct GeneratedVisitor;
18451
18452 impl serde::de::Visitor<'_> for GeneratedVisitor {
18453 type Value = GeneratedField;
18454
18455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18456 write!(formatter, "expected one of: {:?}", &FIELDS)
18457 }
18458
18459 #[allow(unused_variables)]
18460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18461 where
18462 E: serde::de::Error,
18463 {
18464 match value {
18465 "tablePolicies" | "table_policies" => Ok(GeneratedField::TablePolicies),
18466 "internalTablePolicies" | "internal_table_policies" => Ok(GeneratedField::InternalTablePolicies),
18467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18468 }
18469 }
18470 }
18471 deserializer.deserialize_identifier(GeneratedVisitor)
18472 }
18473 }
18474 struct GeneratedVisitor;
18475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18476 type Value = TableCacheRefillPolicies;
18477
18478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18479 formatter.write_str("struct meta.TableCacheRefillPolicies")
18480 }
18481
18482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableCacheRefillPolicies, V::Error>
18483 where
18484 V: serde::de::MapAccess<'de>,
18485 {
18486 let mut table_policies__ = None;
18487 let mut internal_table_policies__ = None;
18488 while let Some(k) = map_.next_key()? {
18489 match k {
18490 GeneratedField::TablePolicies => {
18491 if table_policies__.is_some() {
18492 return Err(serde::de::Error::duplicate_field("tablePolicies"));
18493 }
18494 table_policies__ = Some(map_.next_value()?);
18495 }
18496 GeneratedField::InternalTablePolicies => {
18497 if internal_table_policies__.is_some() {
18498 return Err(serde::de::Error::duplicate_field("internalTablePolicies"));
18499 }
18500 internal_table_policies__ = Some(map_.next_value()?);
18501 }
18502 }
18503 }
18504 Ok(TableCacheRefillPolicies {
18505 table_policies: table_policies__.unwrap_or_default(),
18506 internal_table_policies: internal_table_policies__.unwrap_or_default(),
18507 })
18508 }
18509 }
18510 deserializer.deserialize_struct("meta.TableCacheRefillPolicies", FIELDS, GeneratedVisitor)
18511 }
18512}
18513impl serde::Serialize for table_cache_refill_policies::TableCacheRefillPolicy {
18514 #[allow(deprecated)]
18515 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18516 where
18517 S: serde::Serializer,
18518 {
18519 use serde::ser::SerializeStruct;
18520 let mut len = 0;
18521 if self.table_id != 0 {
18522 len += 1;
18523 }
18524 if self.policy != 0 {
18525 len += 1;
18526 }
18527 let mut struct_ser = serializer.serialize_struct("meta.TableCacheRefillPolicies.TableCacheRefillPolicy", len)?;
18528 if self.table_id != 0 {
18529 struct_ser.serialize_field("tableId", &self.table_id)?;
18530 }
18531 if self.policy != 0 {
18532 let v = table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::try_from(self.policy)
18533 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.policy)))?;
18534 struct_ser.serialize_field("policy", &v)?;
18535 }
18536 struct_ser.end()
18537 }
18538}
18539impl<'de> serde::Deserialize<'de> for table_cache_refill_policies::TableCacheRefillPolicy {
18540 #[allow(deprecated)]
18541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18542 where
18543 D: serde::Deserializer<'de>,
18544 {
18545 const FIELDS: &[&str] = &[
18546 "table_id",
18547 "tableId",
18548 "policy",
18549 ];
18550
18551 #[allow(clippy::enum_variant_names)]
18552 enum GeneratedField {
18553 TableId,
18554 Policy,
18555 }
18556 impl<'de> serde::Deserialize<'de> for GeneratedField {
18557 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18558 where
18559 D: serde::Deserializer<'de>,
18560 {
18561 struct GeneratedVisitor;
18562
18563 impl serde::de::Visitor<'_> for GeneratedVisitor {
18564 type Value = GeneratedField;
18565
18566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18567 write!(formatter, "expected one of: {:?}", &FIELDS)
18568 }
18569
18570 #[allow(unused_variables)]
18571 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18572 where
18573 E: serde::de::Error,
18574 {
18575 match value {
18576 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18577 "policy" => Ok(GeneratedField::Policy),
18578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18579 }
18580 }
18581 }
18582 deserializer.deserialize_identifier(GeneratedVisitor)
18583 }
18584 }
18585 struct GeneratedVisitor;
18586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18587 type Value = table_cache_refill_policies::TableCacheRefillPolicy;
18588
18589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18590 formatter.write_str("struct meta.TableCacheRefillPolicies.TableCacheRefillPolicy")
18591 }
18592
18593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_cache_refill_policies::TableCacheRefillPolicy, V::Error>
18594 where
18595 V: serde::de::MapAccess<'de>,
18596 {
18597 let mut table_id__ = None;
18598 let mut policy__ = None;
18599 while let Some(k) = map_.next_key()? {
18600 match k {
18601 GeneratedField::TableId => {
18602 if table_id__.is_some() {
18603 return Err(serde::de::Error::duplicate_field("tableId"));
18604 }
18605 table_id__ =
18606 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18607 ;
18608 }
18609 GeneratedField::Policy => {
18610 if policy__.is_some() {
18611 return Err(serde::de::Error::duplicate_field("policy"));
18612 }
18613 policy__ = Some(map_.next_value::<table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy>()? as i32);
18614 }
18615 }
18616 }
18617 Ok(table_cache_refill_policies::TableCacheRefillPolicy {
18618 table_id: table_id__.unwrap_or_default(),
18619 policy: policy__.unwrap_or_default(),
18620 })
18621 }
18622 }
18623 deserializer.deserialize_struct("meta.TableCacheRefillPolicies.TableCacheRefillPolicy", FIELDS, GeneratedVisitor)
18624 }
18625}
18626impl serde::Serialize for table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy {
18627 #[allow(deprecated)]
18628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18629 where
18630 S: serde::Serializer,
18631 {
18632 let variant = match self {
18633 Self::Unspecified => "UNSPECIFIED",
18634 Self::Enabled => "ENABLED",
18635 Self::Disabled => "DISABLED",
18636 Self::Streaming => "STREAMING",
18637 Self::Serving => "SERVING",
18638 Self::Both => "BOTH",
18639 };
18640 serializer.serialize_str(variant)
18641 }
18642}
18643impl<'de> serde::Deserialize<'de> for table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy {
18644 #[allow(deprecated)]
18645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18646 where
18647 D: serde::Deserializer<'de>,
18648 {
18649 const FIELDS: &[&str] = &[
18650 "UNSPECIFIED",
18651 "ENABLED",
18652 "DISABLED",
18653 "STREAMING",
18654 "SERVING",
18655 "BOTH",
18656 ];
18657
18658 struct GeneratedVisitor;
18659
18660 impl serde::de::Visitor<'_> for GeneratedVisitor {
18661 type Value = table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy;
18662
18663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18664 write!(formatter, "expected one of: {:?}", &FIELDS)
18665 }
18666
18667 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18668 where
18669 E: serde::de::Error,
18670 {
18671 i32::try_from(v)
18672 .ok()
18673 .and_then(|x| x.try_into().ok())
18674 .ok_or_else(|| {
18675 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18676 })
18677 }
18678
18679 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18680 where
18681 E: serde::de::Error,
18682 {
18683 i32::try_from(v)
18684 .ok()
18685 .and_then(|x| x.try_into().ok())
18686 .ok_or_else(|| {
18687 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18688 })
18689 }
18690
18691 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18692 where
18693 E: serde::de::Error,
18694 {
18695 match value {
18696 "UNSPECIFIED" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Unspecified),
18697 "ENABLED" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Enabled),
18698 "DISABLED" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Disabled),
18699 "STREAMING" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Streaming),
18700 "SERVING" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Serving),
18701 "BOTH" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Both),
18702 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18703 }
18704 }
18705 }
18706 deserializer.deserialize_any(GeneratedVisitor)
18707 }
18708}
18709impl serde::Serialize for TableFragments {
18710 #[allow(deprecated)]
18711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18712 where
18713 S: serde::Serializer,
18714 {
18715 use serde::ser::SerializeStruct;
18716 let mut len = 0;
18717 if self.table_id != 0 {
18718 len += 1;
18719 }
18720 if self.state != 0 {
18721 len += 1;
18722 }
18723 if !self.fragments.is_empty() {
18724 len += 1;
18725 }
18726 if !self.actor_status.is_empty() {
18727 len += 1;
18728 }
18729 if self.ctx.is_some() {
18730 len += 1;
18731 }
18732 if self.max_parallelism.is_some() {
18733 len += 1;
18734 }
18735 if !self.node_label.is_empty() {
18736 len += 1;
18737 }
18738 if self.backfill_done {
18739 len += 1;
18740 }
18741 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
18742 if self.table_id != 0 {
18743 struct_ser.serialize_field("tableId", &self.table_id)?;
18744 }
18745 if self.state != 0 {
18746 let v = table_fragments::State::try_from(self.state)
18747 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
18748 struct_ser.serialize_field("state", &v)?;
18749 }
18750 if !self.fragments.is_empty() {
18751 struct_ser.serialize_field("fragments", &self.fragments)?;
18752 }
18753 if !self.actor_status.is_empty() {
18754 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
18755 }
18756 if let Some(v) = self.ctx.as_ref() {
18757 struct_ser.serialize_field("ctx", v)?;
18758 }
18759 if let Some(v) = self.max_parallelism.as_ref() {
18760 struct_ser.serialize_field("maxParallelism", v)?;
18761 }
18762 if !self.node_label.is_empty() {
18763 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18764 }
18765 if self.backfill_done {
18766 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
18767 }
18768 struct_ser.end()
18769 }
18770}
18771impl<'de> serde::Deserialize<'de> for TableFragments {
18772 #[allow(deprecated)]
18773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18774 where
18775 D: serde::Deserializer<'de>,
18776 {
18777 const FIELDS: &[&str] = &[
18778 "table_id",
18779 "tableId",
18780 "state",
18781 "fragments",
18782 "actor_status",
18783 "actorStatus",
18784 "ctx",
18785 "max_parallelism",
18786 "maxParallelism",
18787 "node_label",
18788 "nodeLabel",
18789 "backfill_done",
18790 "backfillDone",
18791 ];
18792
18793 #[allow(clippy::enum_variant_names)]
18794 enum GeneratedField {
18795 TableId,
18796 State,
18797 Fragments,
18798 ActorStatus,
18799 Ctx,
18800 MaxParallelism,
18801 NodeLabel,
18802 BackfillDone,
18803 }
18804 impl<'de> serde::Deserialize<'de> for GeneratedField {
18805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18806 where
18807 D: serde::Deserializer<'de>,
18808 {
18809 struct GeneratedVisitor;
18810
18811 impl serde::de::Visitor<'_> for GeneratedVisitor {
18812 type Value = GeneratedField;
18813
18814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18815 write!(formatter, "expected one of: {:?}", &FIELDS)
18816 }
18817
18818 #[allow(unused_variables)]
18819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18820 where
18821 E: serde::de::Error,
18822 {
18823 match value {
18824 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18825 "state" => Ok(GeneratedField::State),
18826 "fragments" => Ok(GeneratedField::Fragments),
18827 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
18828 "ctx" => Ok(GeneratedField::Ctx),
18829 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
18830 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18831 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
18832 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18833 }
18834 }
18835 }
18836 deserializer.deserialize_identifier(GeneratedVisitor)
18837 }
18838 }
18839 struct GeneratedVisitor;
18840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18841 type Value = TableFragments;
18842
18843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18844 formatter.write_str("struct meta.TableFragments")
18845 }
18846
18847 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
18848 where
18849 V: serde::de::MapAccess<'de>,
18850 {
18851 let mut table_id__ = None;
18852 let mut state__ = None;
18853 let mut fragments__ = None;
18854 let mut actor_status__ = None;
18855 let mut ctx__ = None;
18856 let mut max_parallelism__ = None;
18857 let mut node_label__ = None;
18858 let mut backfill_done__ = None;
18859 while let Some(k) = map_.next_key()? {
18860 match k {
18861 GeneratedField::TableId => {
18862 if table_id__.is_some() {
18863 return Err(serde::de::Error::duplicate_field("tableId"));
18864 }
18865 table_id__ =
18866 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18867 ;
18868 }
18869 GeneratedField::State => {
18870 if state__.is_some() {
18871 return Err(serde::de::Error::duplicate_field("state"));
18872 }
18873 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
18874 }
18875 GeneratedField::Fragments => {
18876 if fragments__.is_some() {
18877 return Err(serde::de::Error::duplicate_field("fragments"));
18878 }
18879 fragments__ = Some(
18880 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18881 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18882 );
18883 }
18884 GeneratedField::ActorStatus => {
18885 if actor_status__.is_some() {
18886 return Err(serde::de::Error::duplicate_field("actorStatus"));
18887 }
18888 actor_status__ = Some(
18889 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18890 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18891 );
18892 }
18893 GeneratedField::Ctx => {
18894 if ctx__.is_some() {
18895 return Err(serde::de::Error::duplicate_field("ctx"));
18896 }
18897 ctx__ = map_.next_value()?;
18898 }
18899 GeneratedField::MaxParallelism => {
18900 if max_parallelism__.is_some() {
18901 return Err(serde::de::Error::duplicate_field("maxParallelism"));
18902 }
18903 max_parallelism__ =
18904 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18905 ;
18906 }
18907 GeneratedField::NodeLabel => {
18908 if node_label__.is_some() {
18909 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18910 }
18911 node_label__ = Some(map_.next_value()?);
18912 }
18913 GeneratedField::BackfillDone => {
18914 if backfill_done__.is_some() {
18915 return Err(serde::de::Error::duplicate_field("backfillDone"));
18916 }
18917 backfill_done__ = Some(map_.next_value()?);
18918 }
18919 }
18920 }
18921 Ok(TableFragments {
18922 table_id: table_id__.unwrap_or_default(),
18923 state: state__.unwrap_or_default(),
18924 fragments: fragments__.unwrap_or_default(),
18925 actor_status: actor_status__.unwrap_or_default(),
18926 ctx: ctx__,
18927 max_parallelism: max_parallelism__,
18928 node_label: node_label__.unwrap_or_default(),
18929 backfill_done: backfill_done__.unwrap_or_default(),
18930 })
18931 }
18932 }
18933 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
18934 }
18935}
18936impl serde::Serialize for table_fragments::ActorStatus {
18937 #[allow(deprecated)]
18938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18939 where
18940 S: serde::Serializer,
18941 {
18942 use serde::ser::SerializeStruct;
18943 let mut len = 0;
18944 if self.location.is_some() {
18945 len += 1;
18946 }
18947 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
18948 if let Some(v) = self.location.as_ref() {
18949 struct_ser.serialize_field("location", v)?;
18950 }
18951 struct_ser.end()
18952 }
18953}
18954impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
18955 #[allow(deprecated)]
18956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18957 where
18958 D: serde::Deserializer<'de>,
18959 {
18960 const FIELDS: &[&str] = &[
18961 "location",
18962 ];
18963
18964 #[allow(clippy::enum_variant_names)]
18965 enum GeneratedField {
18966 Location,
18967 }
18968 impl<'de> serde::Deserialize<'de> for GeneratedField {
18969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18970 where
18971 D: serde::Deserializer<'de>,
18972 {
18973 struct GeneratedVisitor;
18974
18975 impl serde::de::Visitor<'_> for GeneratedVisitor {
18976 type Value = GeneratedField;
18977
18978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18979 write!(formatter, "expected one of: {:?}", &FIELDS)
18980 }
18981
18982 #[allow(unused_variables)]
18983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18984 where
18985 E: serde::de::Error,
18986 {
18987 match value {
18988 "location" => Ok(GeneratedField::Location),
18989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18990 }
18991 }
18992 }
18993 deserializer.deserialize_identifier(GeneratedVisitor)
18994 }
18995 }
18996 struct GeneratedVisitor;
18997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18998 type Value = table_fragments::ActorStatus;
18999
19000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19001 formatter.write_str("struct meta.TableFragments.ActorStatus")
19002 }
19003
19004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
19005 where
19006 V: serde::de::MapAccess<'de>,
19007 {
19008 let mut location__ = None;
19009 while let Some(k) = map_.next_key()? {
19010 match k {
19011 GeneratedField::Location => {
19012 if location__.is_some() {
19013 return Err(serde::de::Error::duplicate_field("location"));
19014 }
19015 location__ = map_.next_value()?;
19016 }
19017 }
19018 }
19019 Ok(table_fragments::ActorStatus {
19020 location: location__,
19021 })
19022 }
19023 }
19024 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
19025 }
19026}
19027impl serde::Serialize for table_fragments::Fragment {
19028 #[allow(deprecated)]
19029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19030 where
19031 S: serde::Serializer,
19032 {
19033 use serde::ser::SerializeStruct;
19034 let mut len = 0;
19035 if self.fragment_id != 0 {
19036 len += 1;
19037 }
19038 if self.fragment_type_mask != 0 {
19039 len += 1;
19040 }
19041 if self.distribution_type != 0 {
19042 len += 1;
19043 }
19044 if !self.actors.is_empty() {
19045 len += 1;
19046 }
19047 if !self.state_table_ids.is_empty() {
19048 len += 1;
19049 }
19050 if !self.upstream_fragment_ids.is_empty() {
19051 len += 1;
19052 }
19053 if self.maybe_vnode_count.is_some() {
19054 len += 1;
19055 }
19056 if self.nodes.is_some() {
19057 len += 1;
19058 }
19059 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
19060 if self.fragment_id != 0 {
19061 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
19062 }
19063 if self.fragment_type_mask != 0 {
19064 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
19065 }
19066 if self.distribution_type != 0 {
19067 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
19068 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
19069 struct_ser.serialize_field("distributionType", &v)?;
19070 }
19071 if !self.actors.is_empty() {
19072 struct_ser.serialize_field("actors", &self.actors)?;
19073 }
19074 if !self.state_table_ids.is_empty() {
19075 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
19076 }
19077 if !self.upstream_fragment_ids.is_empty() {
19078 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
19079 }
19080 if let Some(v) = self.maybe_vnode_count.as_ref() {
19081 struct_ser.serialize_field("maybeVnodeCount", v)?;
19082 }
19083 if let Some(v) = self.nodes.as_ref() {
19084 struct_ser.serialize_field("nodes", v)?;
19085 }
19086 struct_ser.end()
19087 }
19088}
19089impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
19090 #[allow(deprecated)]
19091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19092 where
19093 D: serde::Deserializer<'de>,
19094 {
19095 const FIELDS: &[&str] = &[
19096 "fragment_id",
19097 "fragmentId",
19098 "fragment_type_mask",
19099 "fragmentTypeMask",
19100 "distribution_type",
19101 "distributionType",
19102 "actors",
19103 "state_table_ids",
19104 "stateTableIds",
19105 "upstream_fragment_ids",
19106 "upstreamFragmentIds",
19107 "maybe_vnode_count",
19108 "maybeVnodeCount",
19109 "nodes",
19110 ];
19111
19112 #[allow(clippy::enum_variant_names)]
19113 enum GeneratedField {
19114 FragmentId,
19115 FragmentTypeMask,
19116 DistributionType,
19117 Actors,
19118 StateTableIds,
19119 UpstreamFragmentIds,
19120 MaybeVnodeCount,
19121 Nodes,
19122 }
19123 impl<'de> serde::Deserialize<'de> for GeneratedField {
19124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19125 where
19126 D: serde::Deserializer<'de>,
19127 {
19128 struct GeneratedVisitor;
19129
19130 impl serde::de::Visitor<'_> for GeneratedVisitor {
19131 type Value = GeneratedField;
19132
19133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19134 write!(formatter, "expected one of: {:?}", &FIELDS)
19135 }
19136
19137 #[allow(unused_variables)]
19138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19139 where
19140 E: serde::de::Error,
19141 {
19142 match value {
19143 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
19144 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
19145 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
19146 "actors" => Ok(GeneratedField::Actors),
19147 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
19148 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
19149 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
19150 "nodes" => Ok(GeneratedField::Nodes),
19151 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19152 }
19153 }
19154 }
19155 deserializer.deserialize_identifier(GeneratedVisitor)
19156 }
19157 }
19158 struct GeneratedVisitor;
19159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19160 type Value = table_fragments::Fragment;
19161
19162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19163 formatter.write_str("struct meta.TableFragments.Fragment")
19164 }
19165
19166 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
19167 where
19168 V: serde::de::MapAccess<'de>,
19169 {
19170 let mut fragment_id__ = None;
19171 let mut fragment_type_mask__ = None;
19172 let mut distribution_type__ = None;
19173 let mut actors__ = None;
19174 let mut state_table_ids__ = None;
19175 let mut upstream_fragment_ids__ = None;
19176 let mut maybe_vnode_count__ = None;
19177 let mut nodes__ = None;
19178 while let Some(k) = map_.next_key()? {
19179 match k {
19180 GeneratedField::FragmentId => {
19181 if fragment_id__.is_some() {
19182 return Err(serde::de::Error::duplicate_field("fragmentId"));
19183 }
19184 fragment_id__ =
19185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19186 ;
19187 }
19188 GeneratedField::FragmentTypeMask => {
19189 if fragment_type_mask__.is_some() {
19190 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
19191 }
19192 fragment_type_mask__ =
19193 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19194 ;
19195 }
19196 GeneratedField::DistributionType => {
19197 if distribution_type__.is_some() {
19198 return Err(serde::de::Error::duplicate_field("distributionType"));
19199 }
19200 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
19201 }
19202 GeneratedField::Actors => {
19203 if actors__.is_some() {
19204 return Err(serde::de::Error::duplicate_field("actors"));
19205 }
19206 actors__ = Some(map_.next_value()?);
19207 }
19208 GeneratedField::StateTableIds => {
19209 if state_table_ids__.is_some() {
19210 return Err(serde::de::Error::duplicate_field("stateTableIds"));
19211 }
19212 state_table_ids__ =
19213 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19214 .into_iter().map(|x| x.0).collect())
19215 ;
19216 }
19217 GeneratedField::UpstreamFragmentIds => {
19218 if upstream_fragment_ids__.is_some() {
19219 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
19220 }
19221 upstream_fragment_ids__ =
19222 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19223 .into_iter().map(|x| x.0).collect())
19224 ;
19225 }
19226 GeneratedField::MaybeVnodeCount => {
19227 if maybe_vnode_count__.is_some() {
19228 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
19229 }
19230 maybe_vnode_count__ =
19231 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19232 ;
19233 }
19234 GeneratedField::Nodes => {
19235 if nodes__.is_some() {
19236 return Err(serde::de::Error::duplicate_field("nodes"));
19237 }
19238 nodes__ = map_.next_value()?;
19239 }
19240 }
19241 }
19242 Ok(table_fragments::Fragment {
19243 fragment_id: fragment_id__.unwrap_or_default(),
19244 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
19245 distribution_type: distribution_type__.unwrap_or_default(),
19246 actors: actors__.unwrap_or_default(),
19247 state_table_ids: state_table_ids__.unwrap_or_default(),
19248 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
19249 maybe_vnode_count: maybe_vnode_count__,
19250 nodes: nodes__,
19251 })
19252 }
19253 }
19254 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
19255 }
19256}
19257impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
19258 #[allow(deprecated)]
19259 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19260 where
19261 S: serde::Serializer,
19262 {
19263 let variant = match self {
19264 Self::Unspecified => "UNSPECIFIED",
19265 Self::Single => "SINGLE",
19266 Self::Hash => "HASH",
19267 };
19268 serializer.serialize_str(variant)
19269 }
19270}
19271impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
19272 #[allow(deprecated)]
19273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19274 where
19275 D: serde::Deserializer<'de>,
19276 {
19277 const FIELDS: &[&str] = &[
19278 "UNSPECIFIED",
19279 "SINGLE",
19280 "HASH",
19281 ];
19282
19283 struct GeneratedVisitor;
19284
19285 impl serde::de::Visitor<'_> for GeneratedVisitor {
19286 type Value = table_fragments::fragment::FragmentDistributionType;
19287
19288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19289 write!(formatter, "expected one of: {:?}", &FIELDS)
19290 }
19291
19292 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19293 where
19294 E: serde::de::Error,
19295 {
19296 i32::try_from(v)
19297 .ok()
19298 .and_then(|x| x.try_into().ok())
19299 .ok_or_else(|| {
19300 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19301 })
19302 }
19303
19304 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19305 where
19306 E: serde::de::Error,
19307 {
19308 i32::try_from(v)
19309 .ok()
19310 .and_then(|x| x.try_into().ok())
19311 .ok_or_else(|| {
19312 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19313 })
19314 }
19315
19316 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19317 where
19318 E: serde::de::Error,
19319 {
19320 match value {
19321 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
19322 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
19323 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
19324 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19325 }
19326 }
19327 }
19328 deserializer.deserialize_any(GeneratedVisitor)
19329 }
19330}
19331impl serde::Serialize for table_fragments::State {
19332 #[allow(deprecated)]
19333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19334 where
19335 S: serde::Serializer,
19336 {
19337 let variant = match self {
19338 Self::Unspecified => "UNSPECIFIED",
19339 Self::Initial => "INITIAL",
19340 Self::Creating => "CREATING",
19341 Self::Created => "CREATED",
19342 };
19343 serializer.serialize_str(variant)
19344 }
19345}
19346impl<'de> serde::Deserialize<'de> for table_fragments::State {
19347 #[allow(deprecated)]
19348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19349 where
19350 D: serde::Deserializer<'de>,
19351 {
19352 const FIELDS: &[&str] = &[
19353 "UNSPECIFIED",
19354 "INITIAL",
19355 "CREATING",
19356 "CREATED",
19357 ];
19358
19359 struct GeneratedVisitor;
19360
19361 impl serde::de::Visitor<'_> for GeneratedVisitor {
19362 type Value = table_fragments::State;
19363
19364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19365 write!(formatter, "expected one of: {:?}", &FIELDS)
19366 }
19367
19368 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19369 where
19370 E: serde::de::Error,
19371 {
19372 i32::try_from(v)
19373 .ok()
19374 .and_then(|x| x.try_into().ok())
19375 .ok_or_else(|| {
19376 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19377 })
19378 }
19379
19380 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19381 where
19382 E: serde::de::Error,
19383 {
19384 i32::try_from(v)
19385 .ok()
19386 .and_then(|x| x.try_into().ok())
19387 .ok_or_else(|| {
19388 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19389 })
19390 }
19391
19392 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19393 where
19394 E: serde::de::Error,
19395 {
19396 match value {
19397 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
19398 "INITIAL" => Ok(table_fragments::State::Initial),
19399 "CREATING" => Ok(table_fragments::State::Creating),
19400 "CREATED" => Ok(table_fragments::State::Created),
19401 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19402 }
19403 }
19404 }
19405 deserializer.deserialize_any(GeneratedVisitor)
19406 }
19407}
19408impl serde::Serialize for TableParallelism {
19409 #[allow(deprecated)]
19410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19411 where
19412 S: serde::Serializer,
19413 {
19414 use serde::ser::SerializeStruct;
19415 let mut len = 0;
19416 if self.parallelism.is_some() {
19417 len += 1;
19418 }
19419 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
19420 if let Some(v) = self.parallelism.as_ref() {
19421 match v {
19422 table_parallelism::Parallelism::Fixed(v) => {
19423 struct_ser.serialize_field("fixed", v)?;
19424 }
19425 table_parallelism::Parallelism::Auto(v) => {
19426 struct_ser.serialize_field("auto", v)?;
19427 }
19428 table_parallelism::Parallelism::Custom(v) => {
19429 struct_ser.serialize_field("custom", v)?;
19430 }
19431 table_parallelism::Parallelism::Adaptive(v) => {
19432 struct_ser.serialize_field("adaptive", v)?;
19433 }
19434 }
19435 }
19436 struct_ser.end()
19437 }
19438}
19439impl<'de> serde::Deserialize<'de> for TableParallelism {
19440 #[allow(deprecated)]
19441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19442 where
19443 D: serde::Deserializer<'de>,
19444 {
19445 const FIELDS: &[&str] = &[
19446 "fixed",
19447 "auto",
19448 "custom",
19449 "adaptive",
19450 ];
19451
19452 #[allow(clippy::enum_variant_names)]
19453 enum GeneratedField {
19454 Fixed,
19455 Auto,
19456 Custom,
19457 Adaptive,
19458 }
19459 impl<'de> serde::Deserialize<'de> for GeneratedField {
19460 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19461 where
19462 D: serde::Deserializer<'de>,
19463 {
19464 struct GeneratedVisitor;
19465
19466 impl serde::de::Visitor<'_> for GeneratedVisitor {
19467 type Value = GeneratedField;
19468
19469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19470 write!(formatter, "expected one of: {:?}", &FIELDS)
19471 }
19472
19473 #[allow(unused_variables)]
19474 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19475 where
19476 E: serde::de::Error,
19477 {
19478 match value {
19479 "fixed" => Ok(GeneratedField::Fixed),
19480 "auto" => Ok(GeneratedField::Auto),
19481 "custom" => Ok(GeneratedField::Custom),
19482 "adaptive" => Ok(GeneratedField::Adaptive),
19483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19484 }
19485 }
19486 }
19487 deserializer.deserialize_identifier(GeneratedVisitor)
19488 }
19489 }
19490 struct GeneratedVisitor;
19491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19492 type Value = TableParallelism;
19493
19494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19495 formatter.write_str("struct meta.TableParallelism")
19496 }
19497
19498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
19499 where
19500 V: serde::de::MapAccess<'de>,
19501 {
19502 let mut parallelism__ = None;
19503 while let Some(k) = map_.next_key()? {
19504 match k {
19505 GeneratedField::Fixed => {
19506 if parallelism__.is_some() {
19507 return Err(serde::de::Error::duplicate_field("fixed"));
19508 }
19509 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
19510;
19511 }
19512 GeneratedField::Auto => {
19513 if parallelism__.is_some() {
19514 return Err(serde::de::Error::duplicate_field("auto"));
19515 }
19516 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
19517;
19518 }
19519 GeneratedField::Custom => {
19520 if parallelism__.is_some() {
19521 return Err(serde::de::Error::duplicate_field("custom"));
19522 }
19523 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
19524;
19525 }
19526 GeneratedField::Adaptive => {
19527 if parallelism__.is_some() {
19528 return Err(serde::de::Error::duplicate_field("adaptive"));
19529 }
19530 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
19531;
19532 }
19533 }
19534 }
19535 Ok(TableParallelism {
19536 parallelism: parallelism__,
19537 })
19538 }
19539 }
19540 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
19541 }
19542}
19543impl serde::Serialize for table_parallelism::AdaptiveParallelism {
19544 #[allow(deprecated)]
19545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19546 where
19547 S: serde::Serializer,
19548 {
19549 use serde::ser::SerializeStruct;
19550 let len = 0;
19551 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
19552 struct_ser.end()
19553 }
19554}
19555impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
19556 #[allow(deprecated)]
19557 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19558 where
19559 D: serde::Deserializer<'de>,
19560 {
19561 const FIELDS: &[&str] = &[
19562 ];
19563
19564 #[allow(clippy::enum_variant_names)]
19565 enum GeneratedField {
19566 }
19567 impl<'de> serde::Deserialize<'de> for GeneratedField {
19568 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19569 where
19570 D: serde::Deserializer<'de>,
19571 {
19572 struct GeneratedVisitor;
19573
19574 impl serde::de::Visitor<'_> for GeneratedVisitor {
19575 type Value = GeneratedField;
19576
19577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19578 write!(formatter, "expected one of: {:?}", &FIELDS)
19579 }
19580
19581 #[allow(unused_variables)]
19582 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19583 where
19584 E: serde::de::Error,
19585 {
19586 Err(serde::de::Error::unknown_field(value, FIELDS))
19587 }
19588 }
19589 deserializer.deserialize_identifier(GeneratedVisitor)
19590 }
19591 }
19592 struct GeneratedVisitor;
19593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19594 type Value = table_parallelism::AdaptiveParallelism;
19595
19596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19597 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
19598 }
19599
19600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
19601 where
19602 V: serde::de::MapAccess<'de>,
19603 {
19604 while map_.next_key::<GeneratedField>()?.is_some() {
19605 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19606 }
19607 Ok(table_parallelism::AdaptiveParallelism {
19608 })
19609 }
19610 }
19611 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
19612 }
19613}
19614impl serde::Serialize for table_parallelism::AutoParallelism {
19615 #[allow(deprecated)]
19616 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19617 where
19618 S: serde::Serializer,
19619 {
19620 use serde::ser::SerializeStruct;
19621 let len = 0;
19622 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
19623 struct_ser.end()
19624 }
19625}
19626impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
19627 #[allow(deprecated)]
19628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19629 where
19630 D: serde::Deserializer<'de>,
19631 {
19632 const FIELDS: &[&str] = &[
19633 ];
19634
19635 #[allow(clippy::enum_variant_names)]
19636 enum GeneratedField {
19637 }
19638 impl<'de> serde::Deserialize<'de> for GeneratedField {
19639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19640 where
19641 D: serde::Deserializer<'de>,
19642 {
19643 struct GeneratedVisitor;
19644
19645 impl serde::de::Visitor<'_> for GeneratedVisitor {
19646 type Value = GeneratedField;
19647
19648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19649 write!(formatter, "expected one of: {:?}", &FIELDS)
19650 }
19651
19652 #[allow(unused_variables)]
19653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19654 where
19655 E: serde::de::Error,
19656 {
19657 Err(serde::de::Error::unknown_field(value, FIELDS))
19658 }
19659 }
19660 deserializer.deserialize_identifier(GeneratedVisitor)
19661 }
19662 }
19663 struct GeneratedVisitor;
19664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19665 type Value = table_parallelism::AutoParallelism;
19666
19667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19668 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
19669 }
19670
19671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
19672 where
19673 V: serde::de::MapAccess<'de>,
19674 {
19675 while map_.next_key::<GeneratedField>()?.is_some() {
19676 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19677 }
19678 Ok(table_parallelism::AutoParallelism {
19679 })
19680 }
19681 }
19682 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
19683 }
19684}
19685impl serde::Serialize for table_parallelism::CustomParallelism {
19686 #[allow(deprecated)]
19687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19688 where
19689 S: serde::Serializer,
19690 {
19691 use serde::ser::SerializeStruct;
19692 let len = 0;
19693 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
19694 struct_ser.end()
19695 }
19696}
19697impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
19698 #[allow(deprecated)]
19699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19700 where
19701 D: serde::Deserializer<'de>,
19702 {
19703 const FIELDS: &[&str] = &[
19704 ];
19705
19706 #[allow(clippy::enum_variant_names)]
19707 enum GeneratedField {
19708 }
19709 impl<'de> serde::Deserialize<'de> for GeneratedField {
19710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19711 where
19712 D: serde::Deserializer<'de>,
19713 {
19714 struct GeneratedVisitor;
19715
19716 impl serde::de::Visitor<'_> for GeneratedVisitor {
19717 type Value = GeneratedField;
19718
19719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19720 write!(formatter, "expected one of: {:?}", &FIELDS)
19721 }
19722
19723 #[allow(unused_variables)]
19724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19725 where
19726 E: serde::de::Error,
19727 {
19728 Err(serde::de::Error::unknown_field(value, FIELDS))
19729 }
19730 }
19731 deserializer.deserialize_identifier(GeneratedVisitor)
19732 }
19733 }
19734 struct GeneratedVisitor;
19735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19736 type Value = table_parallelism::CustomParallelism;
19737
19738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19739 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
19740 }
19741
19742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
19743 where
19744 V: serde::de::MapAccess<'de>,
19745 {
19746 while map_.next_key::<GeneratedField>()?.is_some() {
19747 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19748 }
19749 Ok(table_parallelism::CustomParallelism {
19750 })
19751 }
19752 }
19753 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
19754 }
19755}
19756impl serde::Serialize for table_parallelism::FixedParallelism {
19757 #[allow(deprecated)]
19758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19759 where
19760 S: serde::Serializer,
19761 {
19762 use serde::ser::SerializeStruct;
19763 let mut len = 0;
19764 if self.parallelism != 0 {
19765 len += 1;
19766 }
19767 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
19768 if self.parallelism != 0 {
19769 struct_ser.serialize_field("parallelism", &self.parallelism)?;
19770 }
19771 struct_ser.end()
19772 }
19773}
19774impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
19775 #[allow(deprecated)]
19776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19777 where
19778 D: serde::Deserializer<'de>,
19779 {
19780 const FIELDS: &[&str] = &[
19781 "parallelism",
19782 ];
19783
19784 #[allow(clippy::enum_variant_names)]
19785 enum GeneratedField {
19786 Parallelism,
19787 }
19788 impl<'de> serde::Deserialize<'de> for GeneratedField {
19789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19790 where
19791 D: serde::Deserializer<'de>,
19792 {
19793 struct GeneratedVisitor;
19794
19795 impl serde::de::Visitor<'_> for GeneratedVisitor {
19796 type Value = GeneratedField;
19797
19798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19799 write!(formatter, "expected one of: {:?}", &FIELDS)
19800 }
19801
19802 #[allow(unused_variables)]
19803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19804 where
19805 E: serde::de::Error,
19806 {
19807 match value {
19808 "parallelism" => Ok(GeneratedField::Parallelism),
19809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19810 }
19811 }
19812 }
19813 deserializer.deserialize_identifier(GeneratedVisitor)
19814 }
19815 }
19816 struct GeneratedVisitor;
19817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19818 type Value = table_parallelism::FixedParallelism;
19819
19820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19821 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
19822 }
19823
19824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
19825 where
19826 V: serde::de::MapAccess<'de>,
19827 {
19828 let mut parallelism__ = None;
19829 while let Some(k) = map_.next_key()? {
19830 match k {
19831 GeneratedField::Parallelism => {
19832 if parallelism__.is_some() {
19833 return Err(serde::de::Error::duplicate_field("parallelism"));
19834 }
19835 parallelism__ =
19836 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19837 ;
19838 }
19839 }
19840 }
19841 Ok(table_parallelism::FixedParallelism {
19842 parallelism: parallelism__.unwrap_or_default(),
19843 })
19844 }
19845 }
19846 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
19847 }
19848}
19849impl serde::Serialize for TableRefillRuntimeConfig {
19850 #[allow(deprecated)]
19851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19852 where
19853 S: serde::Serializer,
19854 {
19855 use serde::ser::SerializeStruct;
19856 let mut len = 0;
19857 if self.table_cache_refill_policies.is_some() {
19858 len += 1;
19859 }
19860 if self.serving_table_vnode_mappings.is_some() {
19861 len += 1;
19862 }
19863 if self.version != 0 {
19864 len += 1;
19865 }
19866 let mut struct_ser = serializer.serialize_struct("meta.TableRefillRuntimeConfig", len)?;
19867 if let Some(v) = self.table_cache_refill_policies.as_ref() {
19868 struct_ser.serialize_field("tableCacheRefillPolicies", v)?;
19869 }
19870 if let Some(v) = self.serving_table_vnode_mappings.as_ref() {
19871 struct_ser.serialize_field("servingTableVnodeMappings", v)?;
19872 }
19873 if self.version != 0 {
19874 #[allow(clippy::needless_borrow)]
19875 #[allow(clippy::needless_borrows_for_generic_args)]
19876 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
19877 }
19878 struct_ser.end()
19879 }
19880}
19881impl<'de> serde::Deserialize<'de> for TableRefillRuntimeConfig {
19882 #[allow(deprecated)]
19883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19884 where
19885 D: serde::Deserializer<'de>,
19886 {
19887 const FIELDS: &[&str] = &[
19888 "table_cache_refill_policies",
19889 "tableCacheRefillPolicies",
19890 "serving_table_vnode_mappings",
19891 "servingTableVnodeMappings",
19892 "version",
19893 ];
19894
19895 #[allow(clippy::enum_variant_names)]
19896 enum GeneratedField {
19897 TableCacheRefillPolicies,
19898 ServingTableVnodeMappings,
19899 Version,
19900 }
19901 impl<'de> serde::Deserialize<'de> for GeneratedField {
19902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19903 where
19904 D: serde::Deserializer<'de>,
19905 {
19906 struct GeneratedVisitor;
19907
19908 impl serde::de::Visitor<'_> for GeneratedVisitor {
19909 type Value = GeneratedField;
19910
19911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19912 write!(formatter, "expected one of: {:?}", &FIELDS)
19913 }
19914
19915 #[allow(unused_variables)]
19916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19917 where
19918 E: serde::de::Error,
19919 {
19920 match value {
19921 "tableCacheRefillPolicies" | "table_cache_refill_policies" => Ok(GeneratedField::TableCacheRefillPolicies),
19922 "servingTableVnodeMappings" | "serving_table_vnode_mappings" => Ok(GeneratedField::ServingTableVnodeMappings),
19923 "version" => Ok(GeneratedField::Version),
19924 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19925 }
19926 }
19927 }
19928 deserializer.deserialize_identifier(GeneratedVisitor)
19929 }
19930 }
19931 struct GeneratedVisitor;
19932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19933 type Value = TableRefillRuntimeConfig;
19934
19935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19936 formatter.write_str("struct meta.TableRefillRuntimeConfig")
19937 }
19938
19939 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableRefillRuntimeConfig, V::Error>
19940 where
19941 V: serde::de::MapAccess<'de>,
19942 {
19943 let mut table_cache_refill_policies__ = None;
19944 let mut serving_table_vnode_mappings__ = None;
19945 let mut version__ = None;
19946 while let Some(k) = map_.next_key()? {
19947 match k {
19948 GeneratedField::TableCacheRefillPolicies => {
19949 if table_cache_refill_policies__.is_some() {
19950 return Err(serde::de::Error::duplicate_field("tableCacheRefillPolicies"));
19951 }
19952 table_cache_refill_policies__ = map_.next_value()?;
19953 }
19954 GeneratedField::ServingTableVnodeMappings => {
19955 if serving_table_vnode_mappings__.is_some() {
19956 return Err(serde::de::Error::duplicate_field("servingTableVnodeMappings"));
19957 }
19958 serving_table_vnode_mappings__ = map_.next_value()?;
19959 }
19960 GeneratedField::Version => {
19961 if version__.is_some() {
19962 return Err(serde::de::Error::duplicate_field("version"));
19963 }
19964 version__ =
19965 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19966 ;
19967 }
19968 }
19969 }
19970 Ok(TableRefillRuntimeConfig {
19971 table_cache_refill_policies: table_cache_refill_policies__,
19972 serving_table_vnode_mappings: serving_table_vnode_mappings__,
19973 version: version__.unwrap_or_default(),
19974 })
19975 }
19976 }
19977 deserializer.deserialize_struct("meta.TableRefillRuntimeConfig", FIELDS, GeneratedVisitor)
19978 }
19979}
19980impl serde::Serialize for TelemetryInfoResponse {
19981 #[allow(deprecated)]
19982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19983 where
19984 S: serde::Serializer,
19985 {
19986 use serde::ser::SerializeStruct;
19987 let mut len = 0;
19988 if self.tracking_id.is_some() {
19989 len += 1;
19990 }
19991 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
19992 if let Some(v) = self.tracking_id.as_ref() {
19993 struct_ser.serialize_field("trackingId", v)?;
19994 }
19995 struct_ser.end()
19996 }
19997}
19998impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
19999 #[allow(deprecated)]
20000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20001 where
20002 D: serde::Deserializer<'de>,
20003 {
20004 const FIELDS: &[&str] = &[
20005 "tracking_id",
20006 "trackingId",
20007 ];
20008
20009 #[allow(clippy::enum_variant_names)]
20010 enum GeneratedField {
20011 TrackingId,
20012 }
20013 impl<'de> serde::Deserialize<'de> for GeneratedField {
20014 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20015 where
20016 D: serde::Deserializer<'de>,
20017 {
20018 struct GeneratedVisitor;
20019
20020 impl serde::de::Visitor<'_> for GeneratedVisitor {
20021 type Value = GeneratedField;
20022
20023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20024 write!(formatter, "expected one of: {:?}", &FIELDS)
20025 }
20026
20027 #[allow(unused_variables)]
20028 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20029 where
20030 E: serde::de::Error,
20031 {
20032 match value {
20033 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
20034 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20035 }
20036 }
20037 }
20038 deserializer.deserialize_identifier(GeneratedVisitor)
20039 }
20040 }
20041 struct GeneratedVisitor;
20042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20043 type Value = TelemetryInfoResponse;
20044
20045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20046 formatter.write_str("struct meta.TelemetryInfoResponse")
20047 }
20048
20049 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
20050 where
20051 V: serde::de::MapAccess<'de>,
20052 {
20053 let mut tracking_id__ = None;
20054 while let Some(k) = map_.next_key()? {
20055 match k {
20056 GeneratedField::TrackingId => {
20057 if tracking_id__.is_some() {
20058 return Err(serde::de::Error::duplicate_field("trackingId"));
20059 }
20060 tracking_id__ = map_.next_value()?;
20061 }
20062 }
20063 }
20064 Ok(TelemetryInfoResponse {
20065 tracking_id: tracking_id__,
20066 })
20067 }
20068 }
20069 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
20070 }
20071}
20072impl serde::Serialize for ThrottleTarget {
20073 #[allow(deprecated)]
20074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20075 where
20076 S: serde::Serializer,
20077 {
20078 let variant = match self {
20079 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
20080 Self::Source => "SOURCE",
20081 Self::Mv => "MV",
20082 Self::Table => "TABLE",
20083 Self::Sink => "SINK",
20084 Self::Fragment => "FRAGMENT",
20085 };
20086 serializer.serialize_str(variant)
20087 }
20088}
20089impl<'de> serde::Deserialize<'de> for ThrottleTarget {
20090 #[allow(deprecated)]
20091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20092 where
20093 D: serde::Deserializer<'de>,
20094 {
20095 const FIELDS: &[&str] = &[
20096 "THROTTLE_TARGET_UNSPECIFIED",
20097 "SOURCE",
20098 "MV",
20099 "TABLE",
20100 "SINK",
20101 "FRAGMENT",
20102 ];
20103
20104 struct GeneratedVisitor;
20105
20106 impl serde::de::Visitor<'_> for GeneratedVisitor {
20107 type Value = ThrottleTarget;
20108
20109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20110 write!(formatter, "expected one of: {:?}", &FIELDS)
20111 }
20112
20113 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
20114 where
20115 E: serde::de::Error,
20116 {
20117 i32::try_from(v)
20118 .ok()
20119 .and_then(|x| x.try_into().ok())
20120 .ok_or_else(|| {
20121 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
20122 })
20123 }
20124
20125 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
20126 where
20127 E: serde::de::Error,
20128 {
20129 i32::try_from(v)
20130 .ok()
20131 .and_then(|x| x.try_into().ok())
20132 .ok_or_else(|| {
20133 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
20134 })
20135 }
20136
20137 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
20138 where
20139 E: serde::de::Error,
20140 {
20141 match value {
20142 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
20143 "SOURCE" => Ok(ThrottleTarget::Source),
20144 "MV" => Ok(ThrottleTarget::Mv),
20145 "TABLE" => Ok(ThrottleTarget::Table),
20146 "SINK" => Ok(ThrottleTarget::Sink),
20147 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
20148 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
20149 }
20150 }
20151 }
20152 deserializer.deserialize_any(GeneratedVisitor)
20153 }
20154}
20155impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
20156 #[allow(deprecated)]
20157 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20158 where
20159 S: serde::Serializer,
20160 {
20161 use serde::ser::SerializeStruct;
20162 let mut len = 0;
20163 if self.id != 0 {
20164 len += 1;
20165 }
20166 if !self.node_label.is_empty() {
20167 len += 1;
20168 }
20169 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
20170 if self.id != 0 {
20171 struct_ser.serialize_field("id", &self.id)?;
20172 }
20173 if !self.node_label.is_empty() {
20174 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
20175 }
20176 struct_ser.end()
20177 }
20178}
20179impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
20180 #[allow(deprecated)]
20181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20182 where
20183 D: serde::Deserializer<'de>,
20184 {
20185 const FIELDS: &[&str] = &[
20186 "id",
20187 "node_label",
20188 "nodeLabel",
20189 ];
20190
20191 #[allow(clippy::enum_variant_names)]
20192 enum GeneratedField {
20193 Id,
20194 NodeLabel,
20195 }
20196 impl<'de> serde::Deserialize<'de> for GeneratedField {
20197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20198 where
20199 D: serde::Deserializer<'de>,
20200 {
20201 struct GeneratedVisitor;
20202
20203 impl serde::de::Visitor<'_> for GeneratedVisitor {
20204 type Value = GeneratedField;
20205
20206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20207 write!(formatter, "expected one of: {:?}", &FIELDS)
20208 }
20209
20210 #[allow(unused_variables)]
20211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20212 where
20213 E: serde::de::Error,
20214 {
20215 match value {
20216 "id" => Ok(GeneratedField::Id),
20217 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
20218 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20219 }
20220 }
20221 }
20222 deserializer.deserialize_identifier(GeneratedVisitor)
20223 }
20224 }
20225 struct GeneratedVisitor;
20226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20227 type Value = UpdateStreamingJobNodeLabelsRequest;
20228
20229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20230 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
20231 }
20232
20233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
20234 where
20235 V: serde::de::MapAccess<'de>,
20236 {
20237 let mut id__ = None;
20238 let mut node_label__ = None;
20239 while let Some(k) = map_.next_key()? {
20240 match k {
20241 GeneratedField::Id => {
20242 if id__.is_some() {
20243 return Err(serde::de::Error::duplicate_field("id"));
20244 }
20245 id__ =
20246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20247 ;
20248 }
20249 GeneratedField::NodeLabel => {
20250 if node_label__.is_some() {
20251 return Err(serde::de::Error::duplicate_field("nodeLabel"));
20252 }
20253 node_label__ = Some(map_.next_value()?);
20254 }
20255 }
20256 }
20257 Ok(UpdateStreamingJobNodeLabelsRequest {
20258 id: id__.unwrap_or_default(),
20259 node_label: node_label__.unwrap_or_default(),
20260 })
20261 }
20262 }
20263 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
20264 }
20265}
20266impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
20267 #[allow(deprecated)]
20268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20269 where
20270 S: serde::Serializer,
20271 {
20272 use serde::ser::SerializeStruct;
20273 let len = 0;
20274 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
20275 struct_ser.end()
20276 }
20277}
20278impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
20279 #[allow(deprecated)]
20280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20281 where
20282 D: serde::Deserializer<'de>,
20283 {
20284 const FIELDS: &[&str] = &[
20285 ];
20286
20287 #[allow(clippy::enum_variant_names)]
20288 enum GeneratedField {
20289 }
20290 impl<'de> serde::Deserialize<'de> for GeneratedField {
20291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20292 where
20293 D: serde::Deserializer<'de>,
20294 {
20295 struct GeneratedVisitor;
20296
20297 impl serde::de::Visitor<'_> for GeneratedVisitor {
20298 type Value = GeneratedField;
20299
20300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20301 write!(formatter, "expected one of: {:?}", &FIELDS)
20302 }
20303
20304 #[allow(unused_variables)]
20305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20306 where
20307 E: serde::de::Error,
20308 {
20309 Err(serde::de::Error::unknown_field(value, FIELDS))
20310 }
20311 }
20312 deserializer.deserialize_identifier(GeneratedVisitor)
20313 }
20314 }
20315 struct GeneratedVisitor;
20316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20317 type Value = UpdateStreamingJobNodeLabelsResponse;
20318
20319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20320 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
20321 }
20322
20323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
20324 where
20325 V: serde::de::MapAccess<'de>,
20326 {
20327 while map_.next_key::<GeneratedField>()?.is_some() {
20328 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
20329 }
20330 Ok(UpdateStreamingJobNodeLabelsResponse {
20331 })
20332 }
20333 }
20334 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
20335 }
20336}
20337impl serde::Serialize for WorkerReschedule {
20338 #[allow(deprecated)]
20339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20340 where
20341 S: serde::Serializer,
20342 {
20343 use serde::ser::SerializeStruct;
20344 let mut len = 0;
20345 if !self.worker_actor_diff.is_empty() {
20346 len += 1;
20347 }
20348 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
20349 if !self.worker_actor_diff.is_empty() {
20350 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
20351 }
20352 struct_ser.end()
20353 }
20354}
20355impl<'de> serde::Deserialize<'de> for WorkerReschedule {
20356 #[allow(deprecated)]
20357 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20358 where
20359 D: serde::Deserializer<'de>,
20360 {
20361 const FIELDS: &[&str] = &[
20362 "worker_actor_diff",
20363 "workerActorDiff",
20364 ];
20365
20366 #[allow(clippy::enum_variant_names)]
20367 enum GeneratedField {
20368 WorkerActorDiff,
20369 }
20370 impl<'de> serde::Deserialize<'de> for GeneratedField {
20371 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20372 where
20373 D: serde::Deserializer<'de>,
20374 {
20375 struct GeneratedVisitor;
20376
20377 impl serde::de::Visitor<'_> for GeneratedVisitor {
20378 type Value = GeneratedField;
20379
20380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20381 write!(formatter, "expected one of: {:?}", &FIELDS)
20382 }
20383
20384 #[allow(unused_variables)]
20385 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20386 where
20387 E: serde::de::Error,
20388 {
20389 match value {
20390 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
20391 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20392 }
20393 }
20394 }
20395 deserializer.deserialize_identifier(GeneratedVisitor)
20396 }
20397 }
20398 struct GeneratedVisitor;
20399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20400 type Value = WorkerReschedule;
20401
20402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20403 formatter.write_str("struct meta.WorkerReschedule")
20404 }
20405
20406 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
20407 where
20408 V: serde::de::MapAccess<'de>,
20409 {
20410 let mut worker_actor_diff__ = None;
20411 while let Some(k) = map_.next_key()? {
20412 match k {
20413 GeneratedField::WorkerActorDiff => {
20414 if worker_actor_diff__.is_some() {
20415 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
20416 }
20417 worker_actor_diff__ = Some(
20418 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
20419 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
20420 );
20421 }
20422 }
20423 }
20424 Ok(WorkerReschedule {
20425 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
20426 })
20427 }
20428 }
20429 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
20430 }
20431}