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