1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::meta::*;
4impl serde::Serialize for ActivateWorkerNodeRequest {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if self.host.is_some() {
13 len += 1;
14 }
15 if self.node_id != 0 {
16 len += 1;
17 }
18 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
19 if let Some(v) = self.host.as_ref() {
20 struct_ser.serialize_field("host", v)?;
21 }
22 if self.node_id != 0 {
23 struct_ser.serialize_field("nodeId", &self.node_id)?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "host",
36 "node_id",
37 "nodeId",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 Host,
43 NodeId,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl serde::de::Visitor<'_> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "host" => Ok(GeneratedField::Host),
66 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ActivateWorkerNodeRequest;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut host__ = None;
87 let mut node_id__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::Host => {
91 if host__.is_some() {
92 return Err(serde::de::Error::duplicate_field("host"));
93 }
94 host__ = map_.next_value()?;
95 }
96 GeneratedField::NodeId => {
97 if node_id__.is_some() {
98 return Err(serde::de::Error::duplicate_field("nodeId"));
99 }
100 node_id__ =
101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
102 ;
103 }
104 }
105 }
106 Ok(ActivateWorkerNodeRequest {
107 host: host__,
108 node_id: node_id__.unwrap_or_default(),
109 })
110 }
111 }
112 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
113 }
114}
115impl serde::Serialize for ActivateWorkerNodeResponse {
116 #[allow(deprecated)]
117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
118 where
119 S: serde::Serializer,
120 {
121 use serde::ser::SerializeStruct;
122 let mut len = 0;
123 if self.status.is_some() {
124 len += 1;
125 }
126 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
127 if let Some(v) = self.status.as_ref() {
128 struct_ser.serialize_field("status", v)?;
129 }
130 struct_ser.end()
131 }
132}
133impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
134 #[allow(deprecated)]
135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
136 where
137 D: serde::Deserializer<'de>,
138 {
139 const FIELDS: &[&str] = &[
140 "status",
141 ];
142
143 #[allow(clippy::enum_variant_names)]
144 enum GeneratedField {
145 Status,
146 }
147 impl<'de> serde::Deserialize<'de> for GeneratedField {
148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
149 where
150 D: serde::Deserializer<'de>,
151 {
152 struct GeneratedVisitor;
153
154 impl serde::de::Visitor<'_> for GeneratedVisitor {
155 type Value = GeneratedField;
156
157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158 write!(formatter, "expected one of: {:?}", &FIELDS)
159 }
160
161 #[allow(unused_variables)]
162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
163 where
164 E: serde::de::Error,
165 {
166 match value {
167 "status" => Ok(GeneratedField::Status),
168 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
169 }
170 }
171 }
172 deserializer.deserialize_identifier(GeneratedVisitor)
173 }
174 }
175 struct GeneratedVisitor;
176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
177 type Value = ActivateWorkerNodeResponse;
178
179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
180 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
181 }
182
183 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
184 where
185 V: serde::de::MapAccess<'de>,
186 {
187 let mut status__ = None;
188 while let Some(k) = map_.next_key()? {
189 match k {
190 GeneratedField::Status => {
191 if status__.is_some() {
192 return Err(serde::de::Error::duplicate_field("status"));
193 }
194 status__ = map_.next_value()?;
195 }
196 }
197 }
198 Ok(ActivateWorkerNodeResponse {
199 status: status__,
200 })
201 }
202 }
203 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
204 }
205}
206impl serde::Serialize for ActorCountPerParallelism {
207 #[allow(deprecated)]
208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
209 where
210 S: serde::Serializer,
211 {
212 use serde::ser::SerializeStruct;
213 let mut len = 0;
214 if !self.worker_id_to_actor_count.is_empty() {
215 len += 1;
216 }
217 if self.hard_limit != 0 {
218 len += 1;
219 }
220 if self.soft_limit != 0 {
221 len += 1;
222 }
223 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
224 if !self.worker_id_to_actor_count.is_empty() {
225 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
226 }
227 if self.hard_limit != 0 {
228 #[allow(clippy::needless_borrow)]
229 #[allow(clippy::needless_borrows_for_generic_args)]
230 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
231 }
232 if self.soft_limit != 0 {
233 #[allow(clippy::needless_borrow)]
234 #[allow(clippy::needless_borrows_for_generic_args)]
235 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
236 }
237 struct_ser.end()
238 }
239}
240impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
241 #[allow(deprecated)]
242 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
243 where
244 D: serde::Deserializer<'de>,
245 {
246 const FIELDS: &[&str] = &[
247 "worker_id_to_actor_count",
248 "workerIdToActorCount",
249 "hard_limit",
250 "hardLimit",
251 "soft_limit",
252 "softLimit",
253 ];
254
255 #[allow(clippy::enum_variant_names)]
256 enum GeneratedField {
257 WorkerIdToActorCount,
258 HardLimit,
259 SoftLimit,
260 }
261 impl<'de> serde::Deserialize<'de> for GeneratedField {
262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
263 where
264 D: serde::Deserializer<'de>,
265 {
266 struct GeneratedVisitor;
267
268 impl serde::de::Visitor<'_> for GeneratedVisitor {
269 type Value = GeneratedField;
270
271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 write!(formatter, "expected one of: {:?}", &FIELDS)
273 }
274
275 #[allow(unused_variables)]
276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
277 where
278 E: serde::de::Error,
279 {
280 match value {
281 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
282 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
283 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
285 }
286 }
287 }
288 deserializer.deserialize_identifier(GeneratedVisitor)
289 }
290 }
291 struct GeneratedVisitor;
292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
293 type Value = ActorCountPerParallelism;
294
295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
296 formatter.write_str("struct meta.ActorCountPerParallelism")
297 }
298
299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
300 where
301 V: serde::de::MapAccess<'de>,
302 {
303 let mut worker_id_to_actor_count__ = None;
304 let mut hard_limit__ = None;
305 let mut soft_limit__ = None;
306 while let Some(k) = map_.next_key()? {
307 match k {
308 GeneratedField::WorkerIdToActorCount => {
309 if worker_id_to_actor_count__.is_some() {
310 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
311 }
312 worker_id_to_actor_count__ = Some(
313 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
314 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
315 );
316 }
317 GeneratedField::HardLimit => {
318 if hard_limit__.is_some() {
319 return Err(serde::de::Error::duplicate_field("hardLimit"));
320 }
321 hard_limit__ =
322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
323 ;
324 }
325 GeneratedField::SoftLimit => {
326 if soft_limit__.is_some() {
327 return Err(serde::de::Error::duplicate_field("softLimit"));
328 }
329 soft_limit__ =
330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
331 ;
332 }
333 }
334 }
335 Ok(ActorCountPerParallelism {
336 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
337 hard_limit: hard_limit__.unwrap_or_default(),
338 soft_limit: soft_limit__.unwrap_or_default(),
339 })
340 }
341 }
342 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
343 }
344}
345impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
346 #[allow(deprecated)]
347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
348 where
349 S: serde::Serializer,
350 {
351 use serde::ser::SerializeStruct;
352 let mut len = 0;
353 if self.actor_count != 0 {
354 len += 1;
355 }
356 if self.parallelism != 0 {
357 len += 1;
358 }
359 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
360 if self.actor_count != 0 {
361 #[allow(clippy::needless_borrow)]
362 #[allow(clippy::needless_borrows_for_generic_args)]
363 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
364 }
365 if self.parallelism != 0 {
366 #[allow(clippy::needless_borrow)]
367 #[allow(clippy::needless_borrows_for_generic_args)]
368 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
369 }
370 struct_ser.end()
371 }
372}
373impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
374 #[allow(deprecated)]
375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
376 where
377 D: serde::Deserializer<'de>,
378 {
379 const FIELDS: &[&str] = &[
380 "actor_count",
381 "actorCount",
382 "parallelism",
383 ];
384
385 #[allow(clippy::enum_variant_names)]
386 enum GeneratedField {
387 ActorCount,
388 Parallelism,
389 }
390 impl<'de> serde::Deserialize<'de> for GeneratedField {
391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
392 where
393 D: serde::Deserializer<'de>,
394 {
395 struct GeneratedVisitor;
396
397 impl serde::de::Visitor<'_> for GeneratedVisitor {
398 type Value = GeneratedField;
399
400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401 write!(formatter, "expected one of: {:?}", &FIELDS)
402 }
403
404 #[allow(unused_variables)]
405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
406 where
407 E: serde::de::Error,
408 {
409 match value {
410 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
411 "parallelism" => Ok(GeneratedField::Parallelism),
412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
413 }
414 }
415 }
416 deserializer.deserialize_identifier(GeneratedVisitor)
417 }
418 }
419 struct GeneratedVisitor;
420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
421 type Value = actor_count_per_parallelism::WorkerActorCount;
422
423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
424 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
425 }
426
427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
428 where
429 V: serde::de::MapAccess<'de>,
430 {
431 let mut actor_count__ = None;
432 let mut parallelism__ = None;
433 while let Some(k) = map_.next_key()? {
434 match k {
435 GeneratedField::ActorCount => {
436 if actor_count__.is_some() {
437 return Err(serde::de::Error::duplicate_field("actorCount"));
438 }
439 actor_count__ =
440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
441 ;
442 }
443 GeneratedField::Parallelism => {
444 if parallelism__.is_some() {
445 return Err(serde::de::Error::duplicate_field("parallelism"));
446 }
447 parallelism__ =
448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
449 ;
450 }
451 }
452 }
453 Ok(actor_count_per_parallelism::WorkerActorCount {
454 actor_count: actor_count__.unwrap_or_default(),
455 parallelism: parallelism__.unwrap_or_default(),
456 })
457 }
458 }
459 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
460 }
461}
462impl serde::Serialize for ActorIds {
463 #[allow(deprecated)]
464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
465 where
466 S: serde::Serializer,
467 {
468 use serde::ser::SerializeStruct;
469 let mut len = 0;
470 if !self.ids.is_empty() {
471 len += 1;
472 }
473 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
474 if !self.ids.is_empty() {
475 struct_ser.serialize_field("ids", &self.ids)?;
476 }
477 struct_ser.end()
478 }
479}
480impl<'de> serde::Deserialize<'de> for ActorIds {
481 #[allow(deprecated)]
482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
483 where
484 D: serde::Deserializer<'de>,
485 {
486 const FIELDS: &[&str] = &[
487 "ids",
488 ];
489
490 #[allow(clippy::enum_variant_names)]
491 enum GeneratedField {
492 Ids,
493 }
494 impl<'de> serde::Deserialize<'de> for GeneratedField {
495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
496 where
497 D: serde::Deserializer<'de>,
498 {
499 struct GeneratedVisitor;
500
501 impl serde::de::Visitor<'_> for GeneratedVisitor {
502 type Value = GeneratedField;
503
504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
505 write!(formatter, "expected one of: {:?}", &FIELDS)
506 }
507
508 #[allow(unused_variables)]
509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
510 where
511 E: serde::de::Error,
512 {
513 match value {
514 "ids" => Ok(GeneratedField::Ids),
515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
516 }
517 }
518 }
519 deserializer.deserialize_identifier(GeneratedVisitor)
520 }
521 }
522 struct GeneratedVisitor;
523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
524 type Value = ActorIds;
525
526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
527 formatter.write_str("struct meta.ActorIds")
528 }
529
530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
531 where
532 V: serde::de::MapAccess<'de>,
533 {
534 let mut ids__ = None;
535 while let Some(k) = map_.next_key()? {
536 match k {
537 GeneratedField::Ids => {
538 if ids__.is_some() {
539 return Err(serde::de::Error::duplicate_field("ids"));
540 }
541 ids__ =
542 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
543 .into_iter().map(|x| x.0).collect())
544 ;
545 }
546 }
547 }
548 Ok(ActorIds {
549 ids: ids__.unwrap_or_default(),
550 })
551 }
552 }
553 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
554 }
555}
556impl serde::Serialize for ActorLocation {
557 #[allow(deprecated)]
558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
559 where
560 S: serde::Serializer,
561 {
562 use serde::ser::SerializeStruct;
563 let mut len = 0;
564 if self.node.is_some() {
565 len += 1;
566 }
567 if !self.actors.is_empty() {
568 len += 1;
569 }
570 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
571 if let Some(v) = self.node.as_ref() {
572 struct_ser.serialize_field("node", v)?;
573 }
574 if !self.actors.is_empty() {
575 struct_ser.serialize_field("actors", &self.actors)?;
576 }
577 struct_ser.end()
578 }
579}
580impl<'de> serde::Deserialize<'de> for ActorLocation {
581 #[allow(deprecated)]
582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
583 where
584 D: serde::Deserializer<'de>,
585 {
586 const FIELDS: &[&str] = &[
587 "node",
588 "actors",
589 ];
590
591 #[allow(clippy::enum_variant_names)]
592 enum GeneratedField {
593 Node,
594 Actors,
595 }
596 impl<'de> serde::Deserialize<'de> for GeneratedField {
597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
598 where
599 D: serde::Deserializer<'de>,
600 {
601 struct GeneratedVisitor;
602
603 impl serde::de::Visitor<'_> for GeneratedVisitor {
604 type Value = GeneratedField;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 write!(formatter, "expected one of: {:?}", &FIELDS)
608 }
609
610 #[allow(unused_variables)]
611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
612 where
613 E: serde::de::Error,
614 {
615 match value {
616 "node" => Ok(GeneratedField::Node),
617 "actors" => Ok(GeneratedField::Actors),
618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
619 }
620 }
621 }
622 deserializer.deserialize_identifier(GeneratedVisitor)
623 }
624 }
625 struct GeneratedVisitor;
626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
627 type Value = ActorLocation;
628
629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
630 formatter.write_str("struct meta.ActorLocation")
631 }
632
633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
634 where
635 V: serde::de::MapAccess<'de>,
636 {
637 let mut node__ = None;
638 let mut actors__ = None;
639 while let Some(k) = map_.next_key()? {
640 match k {
641 GeneratedField::Node => {
642 if node__.is_some() {
643 return Err(serde::de::Error::duplicate_field("node"));
644 }
645 node__ = map_.next_value()?;
646 }
647 GeneratedField::Actors => {
648 if actors__.is_some() {
649 return Err(serde::de::Error::duplicate_field("actors"));
650 }
651 actors__ = Some(map_.next_value()?);
652 }
653 }
654 }
655 Ok(ActorLocation {
656 node: node__,
657 actors: actors__.unwrap_or_default(),
658 })
659 }
660 }
661 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
662 }
663}
664impl serde::Serialize for AddEventLogRequest {
665 #[allow(deprecated)]
666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
667 where
668 S: serde::Serializer,
669 {
670 use serde::ser::SerializeStruct;
671 let mut len = 0;
672 if self.event.is_some() {
673 len += 1;
674 }
675 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
676 if let Some(v) = self.event.as_ref() {
677 match v {
678 add_event_log_request::Event::WorkerNodePanic(v) => {
679 struct_ser.serialize_field("workerNodePanic", v)?;
680 }
681 add_event_log_request::Event::SinkFail(v) => {
682 struct_ser.serialize_field("sinkFail", v)?;
683 }
684 add_event_log_request::Event::AutoSchemaChangeFail(v) => {
685 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
686 }
687 }
688 }
689 struct_ser.end()
690 }
691}
692impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
693 #[allow(deprecated)]
694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
695 where
696 D: serde::Deserializer<'de>,
697 {
698 const FIELDS: &[&str] = &[
699 "worker_node_panic",
700 "workerNodePanic",
701 "sink_fail",
702 "sinkFail",
703 "auto_schema_change_fail",
704 "autoSchemaChangeFail",
705 ];
706
707 #[allow(clippy::enum_variant_names)]
708 enum GeneratedField {
709 WorkerNodePanic,
710 SinkFail,
711 AutoSchemaChangeFail,
712 }
713 impl<'de> serde::Deserialize<'de> for GeneratedField {
714 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
715 where
716 D: serde::Deserializer<'de>,
717 {
718 struct GeneratedVisitor;
719
720 impl serde::de::Visitor<'_> for GeneratedVisitor {
721 type Value = GeneratedField;
722
723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
724 write!(formatter, "expected one of: {:?}", &FIELDS)
725 }
726
727 #[allow(unused_variables)]
728 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
729 where
730 E: serde::de::Error,
731 {
732 match value {
733 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
734 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
735 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
737 }
738 }
739 }
740 deserializer.deserialize_identifier(GeneratedVisitor)
741 }
742 }
743 struct GeneratedVisitor;
744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
745 type Value = AddEventLogRequest;
746
747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
748 formatter.write_str("struct meta.AddEventLogRequest")
749 }
750
751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
752 where
753 V: serde::de::MapAccess<'de>,
754 {
755 let mut event__ = None;
756 while let Some(k) = map_.next_key()? {
757 match k {
758 GeneratedField::WorkerNodePanic => {
759 if event__.is_some() {
760 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
761 }
762 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
763;
764 }
765 GeneratedField::SinkFail => {
766 if event__.is_some() {
767 return Err(serde::de::Error::duplicate_field("sinkFail"));
768 }
769 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
770;
771 }
772 GeneratedField::AutoSchemaChangeFail => {
773 if event__.is_some() {
774 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
775 }
776 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
777;
778 }
779 }
780 }
781 Ok(AddEventLogRequest {
782 event: event__,
783 })
784 }
785 }
786 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
787 }
788}
789impl serde::Serialize for AddEventLogResponse {
790 #[allow(deprecated)]
791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
792 where
793 S: serde::Serializer,
794 {
795 use serde::ser::SerializeStruct;
796 let len = 0;
797 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
798 struct_ser.end()
799 }
800}
801impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
802 #[allow(deprecated)]
803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
804 where
805 D: serde::Deserializer<'de>,
806 {
807 const FIELDS: &[&str] = &[
808 ];
809
810 #[allow(clippy::enum_variant_names)]
811 enum GeneratedField {
812 }
813 impl<'de> serde::Deserialize<'de> for GeneratedField {
814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
815 where
816 D: serde::Deserializer<'de>,
817 {
818 struct GeneratedVisitor;
819
820 impl serde::de::Visitor<'_> for GeneratedVisitor {
821 type Value = GeneratedField;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 #[allow(unused_variables)]
828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
829 where
830 E: serde::de::Error,
831 {
832 Err(serde::de::Error::unknown_field(value, FIELDS))
833 }
834 }
835 deserializer.deserialize_identifier(GeneratedVisitor)
836 }
837 }
838 struct GeneratedVisitor;
839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
840 type Value = AddEventLogResponse;
841
842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
843 formatter.write_str("struct meta.AddEventLogResponse")
844 }
845
846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
847 where
848 V: serde::de::MapAccess<'de>,
849 {
850 while map_.next_key::<GeneratedField>()?.is_some() {
851 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
852 }
853 Ok(AddEventLogResponse {
854 })
855 }
856 }
857 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
858 }
859}
860impl serde::Serialize for AddWorkerNodeRequest {
861 #[allow(deprecated)]
862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
863 where
864 S: serde::Serializer,
865 {
866 use serde::ser::SerializeStruct;
867 let mut len = 0;
868 if self.worker_type != 0 {
869 len += 1;
870 }
871 if self.host.is_some() {
872 len += 1;
873 }
874 if self.resource.is_some() {
875 len += 1;
876 }
877 if self.property.is_some() {
878 len += 1;
879 }
880 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
881 if self.worker_type != 0 {
882 let v = super::common::WorkerType::try_from(self.worker_type)
883 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
884 struct_ser.serialize_field("workerType", &v)?;
885 }
886 if let Some(v) = self.host.as_ref() {
887 struct_ser.serialize_field("host", v)?;
888 }
889 if let Some(v) = self.resource.as_ref() {
890 struct_ser.serialize_field("resource", v)?;
891 }
892 if let Some(v) = self.property.as_ref() {
893 struct_ser.serialize_field("property", v)?;
894 }
895 struct_ser.end()
896 }
897}
898impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
899 #[allow(deprecated)]
900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
901 where
902 D: serde::Deserializer<'de>,
903 {
904 const FIELDS: &[&str] = &[
905 "worker_type",
906 "workerType",
907 "host",
908 "resource",
909 "property",
910 ];
911
912 #[allow(clippy::enum_variant_names)]
913 enum GeneratedField {
914 WorkerType,
915 Host,
916 Resource,
917 Property,
918 }
919 impl<'de> serde::Deserialize<'de> for GeneratedField {
920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
921 where
922 D: serde::Deserializer<'de>,
923 {
924 struct GeneratedVisitor;
925
926 impl serde::de::Visitor<'_> for GeneratedVisitor {
927 type Value = GeneratedField;
928
929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
930 write!(formatter, "expected one of: {:?}", &FIELDS)
931 }
932
933 #[allow(unused_variables)]
934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
935 where
936 E: serde::de::Error,
937 {
938 match value {
939 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
940 "host" => Ok(GeneratedField::Host),
941 "resource" => Ok(GeneratedField::Resource),
942 "property" => Ok(GeneratedField::Property),
943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
944 }
945 }
946 }
947 deserializer.deserialize_identifier(GeneratedVisitor)
948 }
949 }
950 struct GeneratedVisitor;
951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
952 type Value = AddWorkerNodeRequest;
953
954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
955 formatter.write_str("struct meta.AddWorkerNodeRequest")
956 }
957
958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
959 where
960 V: serde::de::MapAccess<'de>,
961 {
962 let mut worker_type__ = None;
963 let mut host__ = None;
964 let mut resource__ = None;
965 let mut property__ = None;
966 while let Some(k) = map_.next_key()? {
967 match k {
968 GeneratedField::WorkerType => {
969 if worker_type__.is_some() {
970 return Err(serde::de::Error::duplicate_field("workerType"));
971 }
972 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
973 }
974 GeneratedField::Host => {
975 if host__.is_some() {
976 return Err(serde::de::Error::duplicate_field("host"));
977 }
978 host__ = map_.next_value()?;
979 }
980 GeneratedField::Resource => {
981 if resource__.is_some() {
982 return Err(serde::de::Error::duplicate_field("resource"));
983 }
984 resource__ = map_.next_value()?;
985 }
986 GeneratedField::Property => {
987 if property__.is_some() {
988 return Err(serde::de::Error::duplicate_field("property"));
989 }
990 property__ = map_.next_value()?;
991 }
992 }
993 }
994 Ok(AddWorkerNodeRequest {
995 worker_type: worker_type__.unwrap_or_default(),
996 host: host__,
997 resource: resource__,
998 property: property__,
999 })
1000 }
1001 }
1002 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1003 }
1004}
1005impl serde::Serialize for AddWorkerNodeResponse {
1006 #[allow(deprecated)]
1007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1008 where
1009 S: serde::Serializer,
1010 {
1011 use serde::ser::SerializeStruct;
1012 let mut len = 0;
1013 if self.node_id.is_some() {
1014 len += 1;
1015 }
1016 if !self.cluster_id.is_empty() {
1017 len += 1;
1018 }
1019 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1020 if let Some(v) = self.node_id.as_ref() {
1021 struct_ser.serialize_field("nodeId", v)?;
1022 }
1023 if !self.cluster_id.is_empty() {
1024 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1025 }
1026 struct_ser.end()
1027 }
1028}
1029impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1030 #[allow(deprecated)]
1031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1032 where
1033 D: serde::Deserializer<'de>,
1034 {
1035 const FIELDS: &[&str] = &[
1036 "node_id",
1037 "nodeId",
1038 "cluster_id",
1039 "clusterId",
1040 ];
1041
1042 #[allow(clippy::enum_variant_names)]
1043 enum GeneratedField {
1044 NodeId,
1045 ClusterId,
1046 }
1047 impl<'de> serde::Deserialize<'de> for GeneratedField {
1048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1049 where
1050 D: serde::Deserializer<'de>,
1051 {
1052 struct GeneratedVisitor;
1053
1054 impl serde::de::Visitor<'_> for GeneratedVisitor {
1055 type Value = GeneratedField;
1056
1057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1058 write!(formatter, "expected one of: {:?}", &FIELDS)
1059 }
1060
1061 #[allow(unused_variables)]
1062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1063 where
1064 E: serde::de::Error,
1065 {
1066 match value {
1067 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1068 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1069 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1070 }
1071 }
1072 }
1073 deserializer.deserialize_identifier(GeneratedVisitor)
1074 }
1075 }
1076 struct GeneratedVisitor;
1077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1078 type Value = AddWorkerNodeResponse;
1079
1080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1081 formatter.write_str("struct meta.AddWorkerNodeResponse")
1082 }
1083
1084 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1085 where
1086 V: serde::de::MapAccess<'de>,
1087 {
1088 let mut node_id__ = None;
1089 let mut cluster_id__ = None;
1090 while let Some(k) = map_.next_key()? {
1091 match k {
1092 GeneratedField::NodeId => {
1093 if node_id__.is_some() {
1094 return Err(serde::de::Error::duplicate_field("nodeId"));
1095 }
1096 node_id__ =
1097 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1098 ;
1099 }
1100 GeneratedField::ClusterId => {
1101 if cluster_id__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("clusterId"));
1103 }
1104 cluster_id__ = Some(map_.next_value()?);
1105 }
1106 }
1107 }
1108 Ok(AddWorkerNodeResponse {
1109 node_id: node_id__,
1110 cluster_id: cluster_id__.unwrap_or_default(),
1111 })
1112 }
1113 }
1114 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1115 }
1116}
1117impl serde::Serialize for AlterConnectorPropsRequest {
1118 #[allow(deprecated)]
1119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1120 where
1121 S: serde::Serializer,
1122 {
1123 use serde::ser::SerializeStruct;
1124 let mut len = 0;
1125 if self.object_id != 0 {
1126 len += 1;
1127 }
1128 if !self.changed_props.is_empty() {
1129 len += 1;
1130 }
1131 if !self.changed_secret_refs.is_empty() {
1132 len += 1;
1133 }
1134 if self.connector_conn_ref.is_some() {
1135 len += 1;
1136 }
1137 if self.object_type != 0 {
1138 len += 1;
1139 }
1140 if self.extra_options.is_some() {
1141 len += 1;
1142 }
1143 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1144 if self.object_id != 0 {
1145 struct_ser.serialize_field("objectId", &self.object_id)?;
1146 }
1147 if !self.changed_props.is_empty() {
1148 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1149 }
1150 if !self.changed_secret_refs.is_empty() {
1151 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1152 }
1153 if let Some(v) = self.connector_conn_ref.as_ref() {
1154 struct_ser.serialize_field("connectorConnRef", v)?;
1155 }
1156 if self.object_type != 0 {
1157 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1158 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1159 struct_ser.serialize_field("objectType", &v)?;
1160 }
1161 if let Some(v) = self.extra_options.as_ref() {
1162 match v {
1163 alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1164 struct_ser.serialize_field("alterIcebergTableIds", v)?;
1165 }
1166 }
1167 }
1168 struct_ser.end()
1169 }
1170}
1171impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1172 #[allow(deprecated)]
1173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1174 where
1175 D: serde::Deserializer<'de>,
1176 {
1177 const FIELDS: &[&str] = &[
1178 "object_id",
1179 "objectId",
1180 "changed_props",
1181 "changedProps",
1182 "changed_secret_refs",
1183 "changedSecretRefs",
1184 "connector_conn_ref",
1185 "connectorConnRef",
1186 "object_type",
1187 "objectType",
1188 "alter_iceberg_table_ids",
1189 "alterIcebergTableIds",
1190 ];
1191
1192 #[allow(clippy::enum_variant_names)]
1193 enum GeneratedField {
1194 ObjectId,
1195 ChangedProps,
1196 ChangedSecretRefs,
1197 ConnectorConnRef,
1198 ObjectType,
1199 AlterIcebergTableIds,
1200 }
1201 impl<'de> serde::Deserialize<'de> for GeneratedField {
1202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1203 where
1204 D: serde::Deserializer<'de>,
1205 {
1206 struct GeneratedVisitor;
1207
1208 impl serde::de::Visitor<'_> for GeneratedVisitor {
1209 type Value = GeneratedField;
1210
1211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1212 write!(formatter, "expected one of: {:?}", &FIELDS)
1213 }
1214
1215 #[allow(unused_variables)]
1216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1217 where
1218 E: serde::de::Error,
1219 {
1220 match value {
1221 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1222 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1223 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1224 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1225 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1226 "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1228 }
1229 }
1230 }
1231 deserializer.deserialize_identifier(GeneratedVisitor)
1232 }
1233 }
1234 struct GeneratedVisitor;
1235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1236 type Value = AlterConnectorPropsRequest;
1237
1238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1239 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1240 }
1241
1242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1243 where
1244 V: serde::de::MapAccess<'de>,
1245 {
1246 let mut object_id__ = None;
1247 let mut changed_props__ = None;
1248 let mut changed_secret_refs__ = None;
1249 let mut connector_conn_ref__ = None;
1250 let mut object_type__ = None;
1251 let mut extra_options__ = None;
1252 while let Some(k) = map_.next_key()? {
1253 match k {
1254 GeneratedField::ObjectId => {
1255 if object_id__.is_some() {
1256 return Err(serde::de::Error::duplicate_field("objectId"));
1257 }
1258 object_id__ =
1259 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1260 ;
1261 }
1262 GeneratedField::ChangedProps => {
1263 if changed_props__.is_some() {
1264 return Err(serde::de::Error::duplicate_field("changedProps"));
1265 }
1266 changed_props__ = Some(
1267 map_.next_value::<std::collections::HashMap<_, _>>()?
1268 );
1269 }
1270 GeneratedField::ChangedSecretRefs => {
1271 if changed_secret_refs__.is_some() {
1272 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1273 }
1274 changed_secret_refs__ = Some(
1275 map_.next_value::<std::collections::HashMap<_, _>>()?
1276 );
1277 }
1278 GeneratedField::ConnectorConnRef => {
1279 if connector_conn_ref__.is_some() {
1280 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1281 }
1282 connector_conn_ref__ =
1283 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1284 ;
1285 }
1286 GeneratedField::ObjectType => {
1287 if object_type__.is_some() {
1288 return Err(serde::de::Error::duplicate_field("objectType"));
1289 }
1290 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1291 }
1292 GeneratedField::AlterIcebergTableIds => {
1293 if extra_options__.is_some() {
1294 return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1295 }
1296 extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1297;
1298 }
1299 }
1300 }
1301 Ok(AlterConnectorPropsRequest {
1302 object_id: object_id__.unwrap_or_default(),
1303 changed_props: changed_props__.unwrap_or_default(),
1304 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1305 connector_conn_ref: connector_conn_ref__,
1306 object_type: object_type__.unwrap_or_default(),
1307 extra_options: extra_options__,
1308 })
1309 }
1310 }
1311 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1312 }
1313}
1314impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1315 #[allow(deprecated)]
1316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1317 where
1318 S: serde::Serializer,
1319 {
1320 let variant = match self {
1321 Self::Unspecified => "UNSPECIFIED",
1322 Self::Source => "SOURCE",
1323 Self::Sink => "SINK",
1324 Self::Connection => "CONNECTION",
1325 Self::IcebergTable => "ICEBERG_TABLE",
1326 };
1327 serializer.serialize_str(variant)
1328 }
1329}
1330impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1331 #[allow(deprecated)]
1332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1333 where
1334 D: serde::Deserializer<'de>,
1335 {
1336 const FIELDS: &[&str] = &[
1337 "UNSPECIFIED",
1338 "SOURCE",
1339 "SINK",
1340 "CONNECTION",
1341 "ICEBERG_TABLE",
1342 ];
1343
1344 struct GeneratedVisitor;
1345
1346 impl serde::de::Visitor<'_> for GeneratedVisitor {
1347 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1348
1349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1350 write!(formatter, "expected one of: {:?}", &FIELDS)
1351 }
1352
1353 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1354 where
1355 E: serde::de::Error,
1356 {
1357 i32::try_from(v)
1358 .ok()
1359 .and_then(|x| x.try_into().ok())
1360 .ok_or_else(|| {
1361 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1362 })
1363 }
1364
1365 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1366 where
1367 E: serde::de::Error,
1368 {
1369 i32::try_from(v)
1370 .ok()
1371 .and_then(|x| x.try_into().ok())
1372 .ok_or_else(|| {
1373 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1374 })
1375 }
1376
1377 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1378 where
1379 E: serde::de::Error,
1380 {
1381 match value {
1382 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1383 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1384 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1385 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1386 "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1387 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1388 }
1389 }
1390 }
1391 deserializer.deserialize_any(GeneratedVisitor)
1392 }
1393}
1394impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1395 #[allow(deprecated)]
1396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1397 where
1398 S: serde::Serializer,
1399 {
1400 use serde::ser::SerializeStruct;
1401 let mut len = 0;
1402 if self.source_id != 0 {
1403 len += 1;
1404 }
1405 if self.sink_id != 0 {
1406 len += 1;
1407 }
1408 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1409 if self.source_id != 0 {
1410 struct_ser.serialize_field("sourceId", &self.source_id)?;
1411 }
1412 if self.sink_id != 0 {
1413 struct_ser.serialize_field("sinkId", &self.sink_id)?;
1414 }
1415 struct_ser.end()
1416 }
1417}
1418impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1419 #[allow(deprecated)]
1420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1421 where
1422 D: serde::Deserializer<'de>,
1423 {
1424 const FIELDS: &[&str] = &[
1425 "source_id",
1426 "sourceId",
1427 "sink_id",
1428 "sinkId",
1429 ];
1430
1431 #[allow(clippy::enum_variant_names)]
1432 enum GeneratedField {
1433 SourceId,
1434 SinkId,
1435 }
1436 impl<'de> serde::Deserialize<'de> for GeneratedField {
1437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1438 where
1439 D: serde::Deserializer<'de>,
1440 {
1441 struct GeneratedVisitor;
1442
1443 impl serde::de::Visitor<'_> for GeneratedVisitor {
1444 type Value = GeneratedField;
1445
1446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1447 write!(formatter, "expected one of: {:?}", &FIELDS)
1448 }
1449
1450 #[allow(unused_variables)]
1451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1452 where
1453 E: serde::de::Error,
1454 {
1455 match value {
1456 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1457 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1459 }
1460 }
1461 }
1462 deserializer.deserialize_identifier(GeneratedVisitor)
1463 }
1464 }
1465 struct GeneratedVisitor;
1466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1467 type Value = alter_connector_props_request::AlterIcebergTableIds;
1468
1469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1470 formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1471 }
1472
1473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1474 where
1475 V: serde::de::MapAccess<'de>,
1476 {
1477 let mut source_id__ = None;
1478 let mut sink_id__ = None;
1479 while let Some(k) = map_.next_key()? {
1480 match k {
1481 GeneratedField::SourceId => {
1482 if source_id__.is_some() {
1483 return Err(serde::de::Error::duplicate_field("sourceId"));
1484 }
1485 source_id__ =
1486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1487 ;
1488 }
1489 GeneratedField::SinkId => {
1490 if sink_id__.is_some() {
1491 return Err(serde::de::Error::duplicate_field("sinkId"));
1492 }
1493 sink_id__ =
1494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1495 ;
1496 }
1497 }
1498 }
1499 Ok(alter_connector_props_request::AlterIcebergTableIds {
1500 source_id: source_id__.unwrap_or_default(),
1501 sink_id: sink_id__.unwrap_or_default(),
1502 })
1503 }
1504 }
1505 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1506 }
1507}
1508impl serde::Serialize for AlterConnectorPropsResponse {
1509 #[allow(deprecated)]
1510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1511 where
1512 S: serde::Serializer,
1513 {
1514 use serde::ser::SerializeStruct;
1515 let len = 0;
1516 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1517 struct_ser.end()
1518 }
1519}
1520impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1521 #[allow(deprecated)]
1522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1523 where
1524 D: serde::Deserializer<'de>,
1525 {
1526 const FIELDS: &[&str] = &[
1527 ];
1528
1529 #[allow(clippy::enum_variant_names)]
1530 enum GeneratedField {
1531 }
1532 impl<'de> serde::Deserialize<'de> for GeneratedField {
1533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1534 where
1535 D: serde::Deserializer<'de>,
1536 {
1537 struct GeneratedVisitor;
1538
1539 impl serde::de::Visitor<'_> for GeneratedVisitor {
1540 type Value = GeneratedField;
1541
1542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1543 write!(formatter, "expected one of: {:?}", &FIELDS)
1544 }
1545
1546 #[allow(unused_variables)]
1547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1548 where
1549 E: serde::de::Error,
1550 {
1551 Err(serde::de::Error::unknown_field(value, FIELDS))
1552 }
1553 }
1554 deserializer.deserialize_identifier(GeneratedVisitor)
1555 }
1556 }
1557 struct GeneratedVisitor;
1558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1559 type Value = AlterConnectorPropsResponse;
1560
1561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1562 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1563 }
1564
1565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1566 where
1567 V: serde::de::MapAccess<'de>,
1568 {
1569 while map_.next_key::<GeneratedField>()?.is_some() {
1570 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1571 }
1572 Ok(AlterConnectorPropsResponse {
1573 })
1574 }
1575 }
1576 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1577 }
1578}
1579impl serde::Serialize for AlterSourcePropertiesSafeRequest {
1580 #[allow(deprecated)]
1581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1582 where
1583 S: serde::Serializer,
1584 {
1585 use serde::ser::SerializeStruct;
1586 let mut len = 0;
1587 if self.source_id != 0 {
1588 len += 1;
1589 }
1590 if !self.changed_props.is_empty() {
1591 len += 1;
1592 }
1593 if !self.changed_secret_refs.is_empty() {
1594 len += 1;
1595 }
1596 if self.options.is_some() {
1597 len += 1;
1598 }
1599 let mut struct_ser = serializer.serialize_struct("meta.AlterSourcePropertiesSafeRequest", len)?;
1600 if self.source_id != 0 {
1601 struct_ser.serialize_field("sourceId", &self.source_id)?;
1602 }
1603 if !self.changed_props.is_empty() {
1604 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1605 }
1606 if !self.changed_secret_refs.is_empty() {
1607 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1608 }
1609 if let Some(v) = self.options.as_ref() {
1610 struct_ser.serialize_field("options", v)?;
1611 }
1612 struct_ser.end()
1613 }
1614}
1615impl<'de> serde::Deserialize<'de> for AlterSourcePropertiesSafeRequest {
1616 #[allow(deprecated)]
1617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1618 where
1619 D: serde::Deserializer<'de>,
1620 {
1621 const FIELDS: &[&str] = &[
1622 "source_id",
1623 "sourceId",
1624 "changed_props",
1625 "changedProps",
1626 "changed_secret_refs",
1627 "changedSecretRefs",
1628 "options",
1629 ];
1630
1631 #[allow(clippy::enum_variant_names)]
1632 enum GeneratedField {
1633 SourceId,
1634 ChangedProps,
1635 ChangedSecretRefs,
1636 Options,
1637 }
1638 impl<'de> serde::Deserialize<'de> for GeneratedField {
1639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1640 where
1641 D: serde::Deserializer<'de>,
1642 {
1643 struct GeneratedVisitor;
1644
1645 impl serde::de::Visitor<'_> for GeneratedVisitor {
1646 type Value = GeneratedField;
1647
1648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1649 write!(formatter, "expected one of: {:?}", &FIELDS)
1650 }
1651
1652 #[allow(unused_variables)]
1653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1654 where
1655 E: serde::de::Error,
1656 {
1657 match value {
1658 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1659 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1660 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1661 "options" => Ok(GeneratedField::Options),
1662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1663 }
1664 }
1665 }
1666 deserializer.deserialize_identifier(GeneratedVisitor)
1667 }
1668 }
1669 struct GeneratedVisitor;
1670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1671 type Value = AlterSourcePropertiesSafeRequest;
1672
1673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1674 formatter.write_str("struct meta.AlterSourcePropertiesSafeRequest")
1675 }
1676
1677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourcePropertiesSafeRequest, V::Error>
1678 where
1679 V: serde::de::MapAccess<'de>,
1680 {
1681 let mut source_id__ = None;
1682 let mut changed_props__ = None;
1683 let mut changed_secret_refs__ = None;
1684 let mut options__ = None;
1685 while let Some(k) = map_.next_key()? {
1686 match k {
1687 GeneratedField::SourceId => {
1688 if source_id__.is_some() {
1689 return Err(serde::de::Error::duplicate_field("sourceId"));
1690 }
1691 source_id__ =
1692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1693 ;
1694 }
1695 GeneratedField::ChangedProps => {
1696 if changed_props__.is_some() {
1697 return Err(serde::de::Error::duplicate_field("changedProps"));
1698 }
1699 changed_props__ = Some(
1700 map_.next_value::<std::collections::HashMap<_, _>>()?
1701 );
1702 }
1703 GeneratedField::ChangedSecretRefs => {
1704 if changed_secret_refs__.is_some() {
1705 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1706 }
1707 changed_secret_refs__ = Some(
1708 map_.next_value::<std::collections::HashMap<_, _>>()?
1709 );
1710 }
1711 GeneratedField::Options => {
1712 if options__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("options"));
1714 }
1715 options__ = map_.next_value()?;
1716 }
1717 }
1718 }
1719 Ok(AlterSourcePropertiesSafeRequest {
1720 source_id: source_id__.unwrap_or_default(),
1721 changed_props: changed_props__.unwrap_or_default(),
1722 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1723 options: options__,
1724 })
1725 }
1726 }
1727 deserializer.deserialize_struct("meta.AlterSourcePropertiesSafeRequest", FIELDS, GeneratedVisitor)
1728 }
1729}
1730impl serde::Serialize for AlterSourcePropertiesSafeResponse {
1731 #[allow(deprecated)]
1732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1733 where
1734 S: serde::Serializer,
1735 {
1736 use serde::ser::SerializeStruct;
1737 let len = 0;
1738 let struct_ser = serializer.serialize_struct("meta.AlterSourcePropertiesSafeResponse", len)?;
1739 struct_ser.end()
1740 }
1741}
1742impl<'de> serde::Deserialize<'de> for AlterSourcePropertiesSafeResponse {
1743 #[allow(deprecated)]
1744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1745 where
1746 D: serde::Deserializer<'de>,
1747 {
1748 const FIELDS: &[&str] = &[
1749 ];
1750
1751 #[allow(clippy::enum_variant_names)]
1752 enum GeneratedField {
1753 }
1754 impl<'de> serde::Deserialize<'de> for GeneratedField {
1755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1756 where
1757 D: serde::Deserializer<'de>,
1758 {
1759 struct GeneratedVisitor;
1760
1761 impl serde::de::Visitor<'_> for GeneratedVisitor {
1762 type Value = GeneratedField;
1763
1764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1765 write!(formatter, "expected one of: {:?}", &FIELDS)
1766 }
1767
1768 #[allow(unused_variables)]
1769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1770 where
1771 E: serde::de::Error,
1772 {
1773 Err(serde::de::Error::unknown_field(value, FIELDS))
1774 }
1775 }
1776 deserializer.deserialize_identifier(GeneratedVisitor)
1777 }
1778 }
1779 struct GeneratedVisitor;
1780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1781 type Value = AlterSourcePropertiesSafeResponse;
1782
1783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1784 formatter.write_str("struct meta.AlterSourcePropertiesSafeResponse")
1785 }
1786
1787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourcePropertiesSafeResponse, V::Error>
1788 where
1789 V: serde::de::MapAccess<'de>,
1790 {
1791 while map_.next_key::<GeneratedField>()?.is_some() {
1792 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1793 }
1794 Ok(AlterSourcePropertiesSafeResponse {
1795 })
1796 }
1797 }
1798 deserializer.deserialize_struct("meta.AlterSourcePropertiesSafeResponse", FIELDS, GeneratedVisitor)
1799 }
1800}
1801impl serde::Serialize for ApplyThrottleRequest {
1802 #[allow(deprecated)]
1803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1804 where
1805 S: serde::Serializer,
1806 {
1807 use serde::ser::SerializeStruct;
1808 let mut len = 0;
1809 if self.throttle_target != 0 {
1810 len += 1;
1811 }
1812 if self.throttle_type != 0 {
1813 len += 1;
1814 }
1815 if self.id != 0 {
1816 len += 1;
1817 }
1818 if self.rate.is_some() {
1819 len += 1;
1820 }
1821 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1822 if self.throttle_target != 0 {
1823 let v = ThrottleTarget::try_from(self.throttle_target)
1824 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_target)))?;
1825 struct_ser.serialize_field("throttleTarget", &v)?;
1826 }
1827 if self.throttle_type != 0 {
1828 let v = super::common::ThrottleType::try_from(self.throttle_type)
1829 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
1830 struct_ser.serialize_field("throttleType", &v)?;
1831 }
1832 if self.id != 0 {
1833 struct_ser.serialize_field("id", &self.id)?;
1834 }
1835 if let Some(v) = self.rate.as_ref() {
1836 struct_ser.serialize_field("rate", v)?;
1837 }
1838 struct_ser.end()
1839 }
1840}
1841impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1842 #[allow(deprecated)]
1843 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1844 where
1845 D: serde::Deserializer<'de>,
1846 {
1847 const FIELDS: &[&str] = &[
1848 "throttle_target",
1849 "throttleTarget",
1850 "throttle_type",
1851 "throttleType",
1852 "id",
1853 "rate",
1854 ];
1855
1856 #[allow(clippy::enum_variant_names)]
1857 enum GeneratedField {
1858 ThrottleTarget,
1859 ThrottleType,
1860 Id,
1861 Rate,
1862 }
1863 impl<'de> serde::Deserialize<'de> for GeneratedField {
1864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1865 where
1866 D: serde::Deserializer<'de>,
1867 {
1868 struct GeneratedVisitor;
1869
1870 impl serde::de::Visitor<'_> for GeneratedVisitor {
1871 type Value = GeneratedField;
1872
1873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1874 write!(formatter, "expected one of: {:?}", &FIELDS)
1875 }
1876
1877 #[allow(unused_variables)]
1878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1879 where
1880 E: serde::de::Error,
1881 {
1882 match value {
1883 "throttleTarget" | "throttle_target" => Ok(GeneratedField::ThrottleTarget),
1884 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
1885 "id" => Ok(GeneratedField::Id),
1886 "rate" => Ok(GeneratedField::Rate),
1887 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1888 }
1889 }
1890 }
1891 deserializer.deserialize_identifier(GeneratedVisitor)
1892 }
1893 }
1894 struct GeneratedVisitor;
1895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1896 type Value = ApplyThrottleRequest;
1897
1898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1899 formatter.write_str("struct meta.ApplyThrottleRequest")
1900 }
1901
1902 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1903 where
1904 V: serde::de::MapAccess<'de>,
1905 {
1906 let mut throttle_target__ = None;
1907 let mut throttle_type__ = None;
1908 let mut id__ = None;
1909 let mut rate__ = None;
1910 while let Some(k) = map_.next_key()? {
1911 match k {
1912 GeneratedField::ThrottleTarget => {
1913 if throttle_target__.is_some() {
1914 return Err(serde::de::Error::duplicate_field("throttleTarget"));
1915 }
1916 throttle_target__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1917 }
1918 GeneratedField::ThrottleType => {
1919 if throttle_type__.is_some() {
1920 return Err(serde::de::Error::duplicate_field("throttleType"));
1921 }
1922 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
1923 }
1924 GeneratedField::Id => {
1925 if id__.is_some() {
1926 return Err(serde::de::Error::duplicate_field("id"));
1927 }
1928 id__ =
1929 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1930 ;
1931 }
1932 GeneratedField::Rate => {
1933 if rate__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("rate"));
1935 }
1936 rate__ =
1937 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1938 ;
1939 }
1940 }
1941 }
1942 Ok(ApplyThrottleRequest {
1943 throttle_target: throttle_target__.unwrap_or_default(),
1944 throttle_type: throttle_type__.unwrap_or_default(),
1945 id: id__.unwrap_or_default(),
1946 rate: rate__,
1947 })
1948 }
1949 }
1950 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1951 }
1952}
1953impl serde::Serialize for ApplyThrottleResponse {
1954 #[allow(deprecated)]
1955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1956 where
1957 S: serde::Serializer,
1958 {
1959 use serde::ser::SerializeStruct;
1960 let mut len = 0;
1961 if self.status.is_some() {
1962 len += 1;
1963 }
1964 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1965 if let Some(v) = self.status.as_ref() {
1966 struct_ser.serialize_field("status", v)?;
1967 }
1968 struct_ser.end()
1969 }
1970}
1971impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1972 #[allow(deprecated)]
1973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1974 where
1975 D: serde::Deserializer<'de>,
1976 {
1977 const FIELDS: &[&str] = &[
1978 "status",
1979 ];
1980
1981 #[allow(clippy::enum_variant_names)]
1982 enum GeneratedField {
1983 Status,
1984 }
1985 impl<'de> serde::Deserialize<'de> for GeneratedField {
1986 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1987 where
1988 D: serde::Deserializer<'de>,
1989 {
1990 struct GeneratedVisitor;
1991
1992 impl serde::de::Visitor<'_> for GeneratedVisitor {
1993 type Value = GeneratedField;
1994
1995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1996 write!(formatter, "expected one of: {:?}", &FIELDS)
1997 }
1998
1999 #[allow(unused_variables)]
2000 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2001 where
2002 E: serde::de::Error,
2003 {
2004 match value {
2005 "status" => Ok(GeneratedField::Status),
2006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2007 }
2008 }
2009 }
2010 deserializer.deserialize_identifier(GeneratedVisitor)
2011 }
2012 }
2013 struct GeneratedVisitor;
2014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2015 type Value = ApplyThrottleResponse;
2016
2017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2018 formatter.write_str("struct meta.ApplyThrottleResponse")
2019 }
2020
2021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
2022 where
2023 V: serde::de::MapAccess<'de>,
2024 {
2025 let mut status__ = None;
2026 while let Some(k) = map_.next_key()? {
2027 match k {
2028 GeneratedField::Status => {
2029 if status__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("status"));
2031 }
2032 status__ = map_.next_value()?;
2033 }
2034 }
2035 }
2036 Ok(ApplyThrottleResponse {
2037 status: status__,
2038 })
2039 }
2040 }
2041 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
2042 }
2043}
2044impl serde::Serialize for CancelCreatingJobsRequest {
2045 #[allow(deprecated)]
2046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2047 where
2048 S: serde::Serializer,
2049 {
2050 use serde::ser::SerializeStruct;
2051 let mut len = 0;
2052 if self.jobs.is_some() {
2053 len += 1;
2054 }
2055 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
2056 if let Some(v) = self.jobs.as_ref() {
2057 match v {
2058 cancel_creating_jobs_request::Jobs::Infos(v) => {
2059 struct_ser.serialize_field("infos", v)?;
2060 }
2061 cancel_creating_jobs_request::Jobs::Ids(v) => {
2062 struct_ser.serialize_field("ids", v)?;
2063 }
2064 }
2065 }
2066 struct_ser.end()
2067 }
2068}
2069impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
2070 #[allow(deprecated)]
2071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2072 where
2073 D: serde::Deserializer<'de>,
2074 {
2075 const FIELDS: &[&str] = &[
2076 "infos",
2077 "ids",
2078 ];
2079
2080 #[allow(clippy::enum_variant_names)]
2081 enum GeneratedField {
2082 Infos,
2083 Ids,
2084 }
2085 impl<'de> serde::Deserialize<'de> for GeneratedField {
2086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2087 where
2088 D: serde::Deserializer<'de>,
2089 {
2090 struct GeneratedVisitor;
2091
2092 impl serde::de::Visitor<'_> for GeneratedVisitor {
2093 type Value = GeneratedField;
2094
2095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2096 write!(formatter, "expected one of: {:?}", &FIELDS)
2097 }
2098
2099 #[allow(unused_variables)]
2100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2101 where
2102 E: serde::de::Error,
2103 {
2104 match value {
2105 "infos" => Ok(GeneratedField::Infos),
2106 "ids" => Ok(GeneratedField::Ids),
2107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2108 }
2109 }
2110 }
2111 deserializer.deserialize_identifier(GeneratedVisitor)
2112 }
2113 }
2114 struct GeneratedVisitor;
2115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2116 type Value = CancelCreatingJobsRequest;
2117
2118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2119 formatter.write_str("struct meta.CancelCreatingJobsRequest")
2120 }
2121
2122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
2123 where
2124 V: serde::de::MapAccess<'de>,
2125 {
2126 let mut jobs__ = None;
2127 while let Some(k) = map_.next_key()? {
2128 match k {
2129 GeneratedField::Infos => {
2130 if jobs__.is_some() {
2131 return Err(serde::de::Error::duplicate_field("infos"));
2132 }
2133 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
2134;
2135 }
2136 GeneratedField::Ids => {
2137 if jobs__.is_some() {
2138 return Err(serde::de::Error::duplicate_field("ids"));
2139 }
2140 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
2141;
2142 }
2143 }
2144 }
2145 Ok(CancelCreatingJobsRequest {
2146 jobs: jobs__,
2147 })
2148 }
2149 }
2150 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
2151 }
2152}
2153impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
2154 #[allow(deprecated)]
2155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2156 where
2157 S: serde::Serializer,
2158 {
2159 use serde::ser::SerializeStruct;
2160 let mut len = 0;
2161 if !self.job_ids.is_empty() {
2162 len += 1;
2163 }
2164 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
2165 if !self.job_ids.is_empty() {
2166 struct_ser.serialize_field("jobIds", &self.job_ids)?;
2167 }
2168 struct_ser.end()
2169 }
2170}
2171impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
2172 #[allow(deprecated)]
2173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2174 where
2175 D: serde::Deserializer<'de>,
2176 {
2177 const FIELDS: &[&str] = &[
2178 "job_ids",
2179 "jobIds",
2180 ];
2181
2182 #[allow(clippy::enum_variant_names)]
2183 enum GeneratedField {
2184 JobIds,
2185 }
2186 impl<'de> serde::Deserialize<'de> for GeneratedField {
2187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2188 where
2189 D: serde::Deserializer<'de>,
2190 {
2191 struct GeneratedVisitor;
2192
2193 impl serde::de::Visitor<'_> for GeneratedVisitor {
2194 type Value = GeneratedField;
2195
2196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2197 write!(formatter, "expected one of: {:?}", &FIELDS)
2198 }
2199
2200 #[allow(unused_variables)]
2201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2202 where
2203 E: serde::de::Error,
2204 {
2205 match value {
2206 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
2207 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2208 }
2209 }
2210 }
2211 deserializer.deserialize_identifier(GeneratedVisitor)
2212 }
2213 }
2214 struct GeneratedVisitor;
2215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2216 type Value = cancel_creating_jobs_request::CreatingJobIds;
2217
2218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2219 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
2220 }
2221
2222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
2223 where
2224 V: serde::de::MapAccess<'de>,
2225 {
2226 let mut job_ids__ = None;
2227 while let Some(k) = map_.next_key()? {
2228 match k {
2229 GeneratedField::JobIds => {
2230 if job_ids__.is_some() {
2231 return Err(serde::de::Error::duplicate_field("jobIds"));
2232 }
2233 job_ids__ =
2234 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2235 .into_iter().map(|x| x.0).collect())
2236 ;
2237 }
2238 }
2239 }
2240 Ok(cancel_creating_jobs_request::CreatingJobIds {
2241 job_ids: job_ids__.unwrap_or_default(),
2242 })
2243 }
2244 }
2245 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2246 }
2247}
2248impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2249 #[allow(deprecated)]
2250 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2251 where
2252 S: serde::Serializer,
2253 {
2254 use serde::ser::SerializeStruct;
2255 let mut len = 0;
2256 if self.database_id != 0 {
2257 len += 1;
2258 }
2259 if self.schema_id != 0 {
2260 len += 1;
2261 }
2262 if !self.name.is_empty() {
2263 len += 1;
2264 }
2265 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2266 if self.database_id != 0 {
2267 struct_ser.serialize_field("databaseId", &self.database_id)?;
2268 }
2269 if self.schema_id != 0 {
2270 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2271 }
2272 if !self.name.is_empty() {
2273 struct_ser.serialize_field("name", &self.name)?;
2274 }
2275 struct_ser.end()
2276 }
2277}
2278impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2279 #[allow(deprecated)]
2280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2281 where
2282 D: serde::Deserializer<'de>,
2283 {
2284 const FIELDS: &[&str] = &[
2285 "database_id",
2286 "databaseId",
2287 "schema_id",
2288 "schemaId",
2289 "name",
2290 ];
2291
2292 #[allow(clippy::enum_variant_names)]
2293 enum GeneratedField {
2294 DatabaseId,
2295 SchemaId,
2296 Name,
2297 }
2298 impl<'de> serde::Deserialize<'de> for GeneratedField {
2299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2300 where
2301 D: serde::Deserializer<'de>,
2302 {
2303 struct GeneratedVisitor;
2304
2305 impl serde::de::Visitor<'_> for GeneratedVisitor {
2306 type Value = GeneratedField;
2307
2308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2309 write!(formatter, "expected one of: {:?}", &FIELDS)
2310 }
2311
2312 #[allow(unused_variables)]
2313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2314 where
2315 E: serde::de::Error,
2316 {
2317 match value {
2318 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2319 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2320 "name" => Ok(GeneratedField::Name),
2321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2322 }
2323 }
2324 }
2325 deserializer.deserialize_identifier(GeneratedVisitor)
2326 }
2327 }
2328 struct GeneratedVisitor;
2329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2330 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2331
2332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2333 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2334 }
2335
2336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2337 where
2338 V: serde::de::MapAccess<'de>,
2339 {
2340 let mut database_id__ = None;
2341 let mut schema_id__ = None;
2342 let mut name__ = None;
2343 while let Some(k) = map_.next_key()? {
2344 match k {
2345 GeneratedField::DatabaseId => {
2346 if database_id__.is_some() {
2347 return Err(serde::de::Error::duplicate_field("databaseId"));
2348 }
2349 database_id__ =
2350 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2351 ;
2352 }
2353 GeneratedField::SchemaId => {
2354 if schema_id__.is_some() {
2355 return Err(serde::de::Error::duplicate_field("schemaId"));
2356 }
2357 schema_id__ =
2358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2359 ;
2360 }
2361 GeneratedField::Name => {
2362 if name__.is_some() {
2363 return Err(serde::de::Error::duplicate_field("name"));
2364 }
2365 name__ = Some(map_.next_value()?);
2366 }
2367 }
2368 }
2369 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2370 database_id: database_id__.unwrap_or_default(),
2371 schema_id: schema_id__.unwrap_or_default(),
2372 name: name__.unwrap_or_default(),
2373 })
2374 }
2375 }
2376 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2377 }
2378}
2379impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2380 #[allow(deprecated)]
2381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2382 where
2383 S: serde::Serializer,
2384 {
2385 use serde::ser::SerializeStruct;
2386 let mut len = 0;
2387 if !self.infos.is_empty() {
2388 len += 1;
2389 }
2390 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2391 if !self.infos.is_empty() {
2392 struct_ser.serialize_field("infos", &self.infos)?;
2393 }
2394 struct_ser.end()
2395 }
2396}
2397impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2398 #[allow(deprecated)]
2399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2400 where
2401 D: serde::Deserializer<'de>,
2402 {
2403 const FIELDS: &[&str] = &[
2404 "infos",
2405 ];
2406
2407 #[allow(clippy::enum_variant_names)]
2408 enum GeneratedField {
2409 Infos,
2410 }
2411 impl<'de> serde::Deserialize<'de> for GeneratedField {
2412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2413 where
2414 D: serde::Deserializer<'de>,
2415 {
2416 struct GeneratedVisitor;
2417
2418 impl serde::de::Visitor<'_> for GeneratedVisitor {
2419 type Value = GeneratedField;
2420
2421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2422 write!(formatter, "expected one of: {:?}", &FIELDS)
2423 }
2424
2425 #[allow(unused_variables)]
2426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2427 where
2428 E: serde::de::Error,
2429 {
2430 match value {
2431 "infos" => Ok(GeneratedField::Infos),
2432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2433 }
2434 }
2435 }
2436 deserializer.deserialize_identifier(GeneratedVisitor)
2437 }
2438 }
2439 struct GeneratedVisitor;
2440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2441 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2442
2443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2444 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2445 }
2446
2447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2448 where
2449 V: serde::de::MapAccess<'de>,
2450 {
2451 let mut infos__ = None;
2452 while let Some(k) = map_.next_key()? {
2453 match k {
2454 GeneratedField::Infos => {
2455 if infos__.is_some() {
2456 return Err(serde::de::Error::duplicate_field("infos"));
2457 }
2458 infos__ = Some(map_.next_value()?);
2459 }
2460 }
2461 }
2462 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2463 infos: infos__.unwrap_or_default(),
2464 })
2465 }
2466 }
2467 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2468 }
2469}
2470impl serde::Serialize for CancelCreatingJobsResponse {
2471 #[allow(deprecated)]
2472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2473 where
2474 S: serde::Serializer,
2475 {
2476 use serde::ser::SerializeStruct;
2477 let mut len = 0;
2478 if self.status.is_some() {
2479 len += 1;
2480 }
2481 if !self.canceled_jobs.is_empty() {
2482 len += 1;
2483 }
2484 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2485 if let Some(v) = self.status.as_ref() {
2486 struct_ser.serialize_field("status", v)?;
2487 }
2488 if !self.canceled_jobs.is_empty() {
2489 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2490 }
2491 struct_ser.end()
2492 }
2493}
2494impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2495 #[allow(deprecated)]
2496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2497 where
2498 D: serde::Deserializer<'de>,
2499 {
2500 const FIELDS: &[&str] = &[
2501 "status",
2502 "canceled_jobs",
2503 "canceledJobs",
2504 ];
2505
2506 #[allow(clippy::enum_variant_names)]
2507 enum GeneratedField {
2508 Status,
2509 CanceledJobs,
2510 }
2511 impl<'de> serde::Deserialize<'de> for GeneratedField {
2512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2513 where
2514 D: serde::Deserializer<'de>,
2515 {
2516 struct GeneratedVisitor;
2517
2518 impl serde::de::Visitor<'_> for GeneratedVisitor {
2519 type Value = GeneratedField;
2520
2521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2522 write!(formatter, "expected one of: {:?}", &FIELDS)
2523 }
2524
2525 #[allow(unused_variables)]
2526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2527 where
2528 E: serde::de::Error,
2529 {
2530 match value {
2531 "status" => Ok(GeneratedField::Status),
2532 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2534 }
2535 }
2536 }
2537 deserializer.deserialize_identifier(GeneratedVisitor)
2538 }
2539 }
2540 struct GeneratedVisitor;
2541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2542 type Value = CancelCreatingJobsResponse;
2543
2544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2545 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2546 }
2547
2548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2549 where
2550 V: serde::de::MapAccess<'de>,
2551 {
2552 let mut status__ = None;
2553 let mut canceled_jobs__ = None;
2554 while let Some(k) = map_.next_key()? {
2555 match k {
2556 GeneratedField::Status => {
2557 if status__.is_some() {
2558 return Err(serde::de::Error::duplicate_field("status"));
2559 }
2560 status__ = map_.next_value()?;
2561 }
2562 GeneratedField::CanceledJobs => {
2563 if canceled_jobs__.is_some() {
2564 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2565 }
2566 canceled_jobs__ =
2567 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2568 .into_iter().map(|x| x.0).collect())
2569 ;
2570 }
2571 }
2572 }
2573 Ok(CancelCreatingJobsResponse {
2574 status: status__,
2575 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2576 })
2577 }
2578 }
2579 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2580 }
2581}
2582impl serde::Serialize for ClusterLimit {
2583 #[allow(deprecated)]
2584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2585 where
2586 S: serde::Serializer,
2587 {
2588 use serde::ser::SerializeStruct;
2589 let mut len = 0;
2590 if self.limit.is_some() {
2591 len += 1;
2592 }
2593 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2594 if let Some(v) = self.limit.as_ref() {
2595 match v {
2596 cluster_limit::Limit::ActorCount(v) => {
2597 struct_ser.serialize_field("actorCount", v)?;
2598 }
2599 }
2600 }
2601 struct_ser.end()
2602 }
2603}
2604impl<'de> serde::Deserialize<'de> for ClusterLimit {
2605 #[allow(deprecated)]
2606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2607 where
2608 D: serde::Deserializer<'de>,
2609 {
2610 const FIELDS: &[&str] = &[
2611 "actor_count",
2612 "actorCount",
2613 ];
2614
2615 #[allow(clippy::enum_variant_names)]
2616 enum GeneratedField {
2617 ActorCount,
2618 }
2619 impl<'de> serde::Deserialize<'de> for GeneratedField {
2620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2621 where
2622 D: serde::Deserializer<'de>,
2623 {
2624 struct GeneratedVisitor;
2625
2626 impl serde::de::Visitor<'_> for GeneratedVisitor {
2627 type Value = GeneratedField;
2628
2629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2630 write!(formatter, "expected one of: {:?}", &FIELDS)
2631 }
2632
2633 #[allow(unused_variables)]
2634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2635 where
2636 E: serde::de::Error,
2637 {
2638 match value {
2639 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2640 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2641 }
2642 }
2643 }
2644 deserializer.deserialize_identifier(GeneratedVisitor)
2645 }
2646 }
2647 struct GeneratedVisitor;
2648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2649 type Value = ClusterLimit;
2650
2651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2652 formatter.write_str("struct meta.ClusterLimit")
2653 }
2654
2655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2656 where
2657 V: serde::de::MapAccess<'de>,
2658 {
2659 let mut limit__ = None;
2660 while let Some(k) = map_.next_key()? {
2661 match k {
2662 GeneratedField::ActorCount => {
2663 if limit__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("actorCount"));
2665 }
2666 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2667;
2668 }
2669 }
2670 }
2671 Ok(ClusterLimit {
2672 limit: limit__,
2673 })
2674 }
2675 }
2676 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2677 }
2678}
2679impl serde::Serialize for DeleteWorkerNodeRequest {
2680 #[allow(deprecated)]
2681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2682 where
2683 S: serde::Serializer,
2684 {
2685 use serde::ser::SerializeStruct;
2686 let mut len = 0;
2687 if self.host.is_some() {
2688 len += 1;
2689 }
2690 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2691 if let Some(v) = self.host.as_ref() {
2692 struct_ser.serialize_field("host", v)?;
2693 }
2694 struct_ser.end()
2695 }
2696}
2697impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2698 #[allow(deprecated)]
2699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2700 where
2701 D: serde::Deserializer<'de>,
2702 {
2703 const FIELDS: &[&str] = &[
2704 "host",
2705 ];
2706
2707 #[allow(clippy::enum_variant_names)]
2708 enum GeneratedField {
2709 Host,
2710 }
2711 impl<'de> serde::Deserialize<'de> for GeneratedField {
2712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2713 where
2714 D: serde::Deserializer<'de>,
2715 {
2716 struct GeneratedVisitor;
2717
2718 impl serde::de::Visitor<'_> for GeneratedVisitor {
2719 type Value = GeneratedField;
2720
2721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2722 write!(formatter, "expected one of: {:?}", &FIELDS)
2723 }
2724
2725 #[allow(unused_variables)]
2726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2727 where
2728 E: serde::de::Error,
2729 {
2730 match value {
2731 "host" => Ok(GeneratedField::Host),
2732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2733 }
2734 }
2735 }
2736 deserializer.deserialize_identifier(GeneratedVisitor)
2737 }
2738 }
2739 struct GeneratedVisitor;
2740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2741 type Value = DeleteWorkerNodeRequest;
2742
2743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2744 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2745 }
2746
2747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2748 where
2749 V: serde::de::MapAccess<'de>,
2750 {
2751 let mut host__ = None;
2752 while let Some(k) = map_.next_key()? {
2753 match k {
2754 GeneratedField::Host => {
2755 if host__.is_some() {
2756 return Err(serde::de::Error::duplicate_field("host"));
2757 }
2758 host__ = map_.next_value()?;
2759 }
2760 }
2761 }
2762 Ok(DeleteWorkerNodeRequest {
2763 host: host__,
2764 })
2765 }
2766 }
2767 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2768 }
2769}
2770impl serde::Serialize for DeleteWorkerNodeResponse {
2771 #[allow(deprecated)]
2772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2773 where
2774 S: serde::Serializer,
2775 {
2776 use serde::ser::SerializeStruct;
2777 let mut len = 0;
2778 if self.status.is_some() {
2779 len += 1;
2780 }
2781 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2782 if let Some(v) = self.status.as_ref() {
2783 struct_ser.serialize_field("status", v)?;
2784 }
2785 struct_ser.end()
2786 }
2787}
2788impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2789 #[allow(deprecated)]
2790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2791 where
2792 D: serde::Deserializer<'de>,
2793 {
2794 const FIELDS: &[&str] = &[
2795 "status",
2796 ];
2797
2798 #[allow(clippy::enum_variant_names)]
2799 enum GeneratedField {
2800 Status,
2801 }
2802 impl<'de> serde::Deserialize<'de> for GeneratedField {
2803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2804 where
2805 D: serde::Deserializer<'de>,
2806 {
2807 struct GeneratedVisitor;
2808
2809 impl serde::de::Visitor<'_> for GeneratedVisitor {
2810 type Value = GeneratedField;
2811
2812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2813 write!(formatter, "expected one of: {:?}", &FIELDS)
2814 }
2815
2816 #[allow(unused_variables)]
2817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2818 where
2819 E: serde::de::Error,
2820 {
2821 match value {
2822 "status" => Ok(GeneratedField::Status),
2823 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2824 }
2825 }
2826 }
2827 deserializer.deserialize_identifier(GeneratedVisitor)
2828 }
2829 }
2830 struct GeneratedVisitor;
2831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2832 type Value = DeleteWorkerNodeResponse;
2833
2834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2835 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2836 }
2837
2838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2839 where
2840 V: serde::de::MapAccess<'de>,
2841 {
2842 let mut status__ = None;
2843 while let Some(k) = map_.next_key()? {
2844 match k {
2845 GeneratedField::Status => {
2846 if status__.is_some() {
2847 return Err(serde::de::Error::duplicate_field("status"));
2848 }
2849 status__ = map_.next_value()?;
2850 }
2851 }
2852 }
2853 Ok(DeleteWorkerNodeResponse {
2854 status: status__,
2855 })
2856 }
2857 }
2858 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2859 }
2860}
2861impl serde::Serialize for EventLog {
2862 #[allow(deprecated)]
2863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2864 where
2865 S: serde::Serializer,
2866 {
2867 use serde::ser::SerializeStruct;
2868 let mut len = 0;
2869 if self.unique_id.is_some() {
2870 len += 1;
2871 }
2872 if self.timestamp.is_some() {
2873 len += 1;
2874 }
2875 if self.event.is_some() {
2876 len += 1;
2877 }
2878 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2879 if let Some(v) = self.unique_id.as_ref() {
2880 struct_ser.serialize_field("uniqueId", v)?;
2881 }
2882 if let Some(v) = self.timestamp.as_ref() {
2883 #[allow(clippy::needless_borrow)]
2884 #[allow(clippy::needless_borrows_for_generic_args)]
2885 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2886 }
2887 if let Some(v) = self.event.as_ref() {
2888 match v {
2889 event_log::Event::CreateStreamJobFail(v) => {
2890 struct_ser.serialize_field("createStreamJobFail", v)?;
2891 }
2892 event_log::Event::DirtyStreamJobClear(v) => {
2893 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2894 }
2895 event_log::Event::MetaNodeStart(v) => {
2896 struct_ser.serialize_field("metaNodeStart", v)?;
2897 }
2898 event_log::Event::BarrierComplete(v) => {
2899 struct_ser.serialize_field("barrierComplete", v)?;
2900 }
2901 event_log::Event::InjectBarrierFail(v) => {
2902 struct_ser.serialize_field("injectBarrierFail", v)?;
2903 }
2904 event_log::Event::CollectBarrierFail(v) => {
2905 struct_ser.serialize_field("collectBarrierFail", v)?;
2906 }
2907 event_log::Event::WorkerNodePanic(v) => {
2908 struct_ser.serialize_field("workerNodePanic", v)?;
2909 }
2910 event_log::Event::AutoSchemaChangeFail(v) => {
2911 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2912 }
2913 event_log::Event::SinkFail(v) => {
2914 struct_ser.serialize_field("sinkFail", v)?;
2915 }
2916 event_log::Event::Recovery(v) => {
2917 struct_ser.serialize_field("recovery", v)?;
2918 }
2919 }
2920 }
2921 struct_ser.end()
2922 }
2923}
2924impl<'de> serde::Deserialize<'de> for EventLog {
2925 #[allow(deprecated)]
2926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2927 where
2928 D: serde::Deserializer<'de>,
2929 {
2930 const FIELDS: &[&str] = &[
2931 "unique_id",
2932 "uniqueId",
2933 "timestamp",
2934 "create_stream_job_fail",
2935 "createStreamJobFail",
2936 "dirty_stream_job_clear",
2937 "dirtyStreamJobClear",
2938 "meta_node_start",
2939 "metaNodeStart",
2940 "barrier_complete",
2941 "barrierComplete",
2942 "inject_barrier_fail",
2943 "injectBarrierFail",
2944 "collect_barrier_fail",
2945 "collectBarrierFail",
2946 "worker_node_panic",
2947 "workerNodePanic",
2948 "auto_schema_change_fail",
2949 "autoSchemaChangeFail",
2950 "sink_fail",
2951 "sinkFail",
2952 "recovery",
2953 ];
2954
2955 #[allow(clippy::enum_variant_names)]
2956 enum GeneratedField {
2957 UniqueId,
2958 Timestamp,
2959 CreateStreamJobFail,
2960 DirtyStreamJobClear,
2961 MetaNodeStart,
2962 BarrierComplete,
2963 InjectBarrierFail,
2964 CollectBarrierFail,
2965 WorkerNodePanic,
2966 AutoSchemaChangeFail,
2967 SinkFail,
2968 Recovery,
2969 }
2970 impl<'de> serde::Deserialize<'de> for GeneratedField {
2971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2972 where
2973 D: serde::Deserializer<'de>,
2974 {
2975 struct GeneratedVisitor;
2976
2977 impl serde::de::Visitor<'_> for GeneratedVisitor {
2978 type Value = GeneratedField;
2979
2980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2981 write!(formatter, "expected one of: {:?}", &FIELDS)
2982 }
2983
2984 #[allow(unused_variables)]
2985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2986 where
2987 E: serde::de::Error,
2988 {
2989 match value {
2990 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2991 "timestamp" => Ok(GeneratedField::Timestamp),
2992 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2993 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2994 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2995 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2996 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2997 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2998 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2999 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
3000 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
3001 "recovery" => Ok(GeneratedField::Recovery),
3002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3003 }
3004 }
3005 }
3006 deserializer.deserialize_identifier(GeneratedVisitor)
3007 }
3008 }
3009 struct GeneratedVisitor;
3010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3011 type Value = EventLog;
3012
3013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3014 formatter.write_str("struct meta.EventLog")
3015 }
3016
3017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
3018 where
3019 V: serde::de::MapAccess<'de>,
3020 {
3021 let mut unique_id__ = None;
3022 let mut timestamp__ = None;
3023 let mut event__ = None;
3024 while let Some(k) = map_.next_key()? {
3025 match k {
3026 GeneratedField::UniqueId => {
3027 if unique_id__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("uniqueId"));
3029 }
3030 unique_id__ = map_.next_value()?;
3031 }
3032 GeneratedField::Timestamp => {
3033 if timestamp__.is_some() {
3034 return Err(serde::de::Error::duplicate_field("timestamp"));
3035 }
3036 timestamp__ =
3037 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3038 ;
3039 }
3040 GeneratedField::CreateStreamJobFail => {
3041 if event__.is_some() {
3042 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
3043 }
3044 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
3045;
3046 }
3047 GeneratedField::DirtyStreamJobClear => {
3048 if event__.is_some() {
3049 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
3050 }
3051 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
3052;
3053 }
3054 GeneratedField::MetaNodeStart => {
3055 if event__.is_some() {
3056 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
3057 }
3058 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
3059;
3060 }
3061 GeneratedField::BarrierComplete => {
3062 if event__.is_some() {
3063 return Err(serde::de::Error::duplicate_field("barrierComplete"));
3064 }
3065 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
3066;
3067 }
3068 GeneratedField::InjectBarrierFail => {
3069 if event__.is_some() {
3070 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
3071 }
3072 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
3073;
3074 }
3075 GeneratedField::CollectBarrierFail => {
3076 if event__.is_some() {
3077 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
3078 }
3079 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
3080;
3081 }
3082 GeneratedField::WorkerNodePanic => {
3083 if event__.is_some() {
3084 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
3085 }
3086 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
3087;
3088 }
3089 GeneratedField::AutoSchemaChangeFail => {
3090 if event__.is_some() {
3091 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
3092 }
3093 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
3094;
3095 }
3096 GeneratedField::SinkFail => {
3097 if event__.is_some() {
3098 return Err(serde::de::Error::duplicate_field("sinkFail"));
3099 }
3100 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
3101;
3102 }
3103 GeneratedField::Recovery => {
3104 if event__.is_some() {
3105 return Err(serde::de::Error::duplicate_field("recovery"));
3106 }
3107 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
3108;
3109 }
3110 }
3111 }
3112 Ok(EventLog {
3113 unique_id: unique_id__,
3114 timestamp: timestamp__,
3115 event: event__,
3116 })
3117 }
3118 }
3119 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
3120 }
3121}
3122impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
3123 #[allow(deprecated)]
3124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3125 where
3126 S: serde::Serializer,
3127 {
3128 use serde::ser::SerializeStruct;
3129 let mut len = 0;
3130 if self.table_id != 0 {
3131 len += 1;
3132 }
3133 if !self.table_name.is_empty() {
3134 len += 1;
3135 }
3136 if !self.cdc_table_id.is_empty() {
3137 len += 1;
3138 }
3139 if !self.upstream_ddl.is_empty() {
3140 len += 1;
3141 }
3142 if !self.fail_info.is_empty() {
3143 len += 1;
3144 }
3145 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
3146 if self.table_id != 0 {
3147 struct_ser.serialize_field("tableId", &self.table_id)?;
3148 }
3149 if !self.table_name.is_empty() {
3150 struct_ser.serialize_field("tableName", &self.table_name)?;
3151 }
3152 if !self.cdc_table_id.is_empty() {
3153 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
3154 }
3155 if !self.upstream_ddl.is_empty() {
3156 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
3157 }
3158 if !self.fail_info.is_empty() {
3159 struct_ser.serialize_field("failInfo", &self.fail_info)?;
3160 }
3161 struct_ser.end()
3162 }
3163}
3164impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
3165 #[allow(deprecated)]
3166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3167 where
3168 D: serde::Deserializer<'de>,
3169 {
3170 const FIELDS: &[&str] = &[
3171 "table_id",
3172 "tableId",
3173 "table_name",
3174 "tableName",
3175 "cdc_table_id",
3176 "cdcTableId",
3177 "upstream_ddl",
3178 "upstreamDdl",
3179 "fail_info",
3180 "failInfo",
3181 ];
3182
3183 #[allow(clippy::enum_variant_names)]
3184 enum GeneratedField {
3185 TableId,
3186 TableName,
3187 CdcTableId,
3188 UpstreamDdl,
3189 FailInfo,
3190 }
3191 impl<'de> serde::Deserialize<'de> for GeneratedField {
3192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3193 where
3194 D: serde::Deserializer<'de>,
3195 {
3196 struct GeneratedVisitor;
3197
3198 impl serde::de::Visitor<'_> for GeneratedVisitor {
3199 type Value = GeneratedField;
3200
3201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3202 write!(formatter, "expected one of: {:?}", &FIELDS)
3203 }
3204
3205 #[allow(unused_variables)]
3206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3207 where
3208 E: serde::de::Error,
3209 {
3210 match value {
3211 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3212 "tableName" | "table_name" => Ok(GeneratedField::TableName),
3213 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
3214 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
3215 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
3216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3217 }
3218 }
3219 }
3220 deserializer.deserialize_identifier(GeneratedVisitor)
3221 }
3222 }
3223 struct GeneratedVisitor;
3224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3225 type Value = event_log::EventAutoSchemaChangeFail;
3226
3227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3228 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
3229 }
3230
3231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
3232 where
3233 V: serde::de::MapAccess<'de>,
3234 {
3235 let mut table_id__ = None;
3236 let mut table_name__ = None;
3237 let mut cdc_table_id__ = None;
3238 let mut upstream_ddl__ = None;
3239 let mut fail_info__ = None;
3240 while let Some(k) = map_.next_key()? {
3241 match k {
3242 GeneratedField::TableId => {
3243 if table_id__.is_some() {
3244 return Err(serde::de::Error::duplicate_field("tableId"));
3245 }
3246 table_id__ =
3247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3248 ;
3249 }
3250 GeneratedField::TableName => {
3251 if table_name__.is_some() {
3252 return Err(serde::de::Error::duplicate_field("tableName"));
3253 }
3254 table_name__ = Some(map_.next_value()?);
3255 }
3256 GeneratedField::CdcTableId => {
3257 if cdc_table_id__.is_some() {
3258 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3259 }
3260 cdc_table_id__ = Some(map_.next_value()?);
3261 }
3262 GeneratedField::UpstreamDdl => {
3263 if upstream_ddl__.is_some() {
3264 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3265 }
3266 upstream_ddl__ = Some(map_.next_value()?);
3267 }
3268 GeneratedField::FailInfo => {
3269 if fail_info__.is_some() {
3270 return Err(serde::de::Error::duplicate_field("failInfo"));
3271 }
3272 fail_info__ = Some(map_.next_value()?);
3273 }
3274 }
3275 }
3276 Ok(event_log::EventAutoSchemaChangeFail {
3277 table_id: table_id__.unwrap_or_default(),
3278 table_name: table_name__.unwrap_or_default(),
3279 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3280 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3281 fail_info: fail_info__.unwrap_or_default(),
3282 })
3283 }
3284 }
3285 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3286 }
3287}
3288impl serde::Serialize for event_log::EventBarrierComplete {
3289 #[allow(deprecated)]
3290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3291 where
3292 S: serde::Serializer,
3293 {
3294 use serde::ser::SerializeStruct;
3295 let mut len = 0;
3296 if self.prev_epoch != 0 {
3297 len += 1;
3298 }
3299 if self.cur_epoch != 0 {
3300 len += 1;
3301 }
3302 if self.duration_sec != 0. {
3303 len += 1;
3304 }
3305 if !self.command.is_empty() {
3306 len += 1;
3307 }
3308 if !self.barrier_kind.is_empty() {
3309 len += 1;
3310 }
3311 if self.database_id != 0 {
3312 len += 1;
3313 }
3314 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3315 if self.prev_epoch != 0 {
3316 #[allow(clippy::needless_borrow)]
3317 #[allow(clippy::needless_borrows_for_generic_args)]
3318 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3319 }
3320 if self.cur_epoch != 0 {
3321 #[allow(clippy::needless_borrow)]
3322 #[allow(clippy::needless_borrows_for_generic_args)]
3323 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3324 }
3325 if self.duration_sec != 0. {
3326 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3327 }
3328 if !self.command.is_empty() {
3329 struct_ser.serialize_field("command", &self.command)?;
3330 }
3331 if !self.barrier_kind.is_empty() {
3332 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3333 }
3334 if self.database_id != 0 {
3335 struct_ser.serialize_field("databaseId", &self.database_id)?;
3336 }
3337 struct_ser.end()
3338 }
3339}
3340impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3341 #[allow(deprecated)]
3342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3343 where
3344 D: serde::Deserializer<'de>,
3345 {
3346 const FIELDS: &[&str] = &[
3347 "prev_epoch",
3348 "prevEpoch",
3349 "cur_epoch",
3350 "curEpoch",
3351 "duration_sec",
3352 "durationSec",
3353 "command",
3354 "barrier_kind",
3355 "barrierKind",
3356 "database_id",
3357 "databaseId",
3358 ];
3359
3360 #[allow(clippy::enum_variant_names)]
3361 enum GeneratedField {
3362 PrevEpoch,
3363 CurEpoch,
3364 DurationSec,
3365 Command,
3366 BarrierKind,
3367 DatabaseId,
3368 }
3369 impl<'de> serde::Deserialize<'de> for GeneratedField {
3370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3371 where
3372 D: serde::Deserializer<'de>,
3373 {
3374 struct GeneratedVisitor;
3375
3376 impl serde::de::Visitor<'_> for GeneratedVisitor {
3377 type Value = GeneratedField;
3378
3379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3380 write!(formatter, "expected one of: {:?}", &FIELDS)
3381 }
3382
3383 #[allow(unused_variables)]
3384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3385 where
3386 E: serde::de::Error,
3387 {
3388 match value {
3389 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3390 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3391 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3392 "command" => Ok(GeneratedField::Command),
3393 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3394 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3396 }
3397 }
3398 }
3399 deserializer.deserialize_identifier(GeneratedVisitor)
3400 }
3401 }
3402 struct GeneratedVisitor;
3403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3404 type Value = event_log::EventBarrierComplete;
3405
3406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3407 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3408 }
3409
3410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3411 where
3412 V: serde::de::MapAccess<'de>,
3413 {
3414 let mut prev_epoch__ = None;
3415 let mut cur_epoch__ = None;
3416 let mut duration_sec__ = None;
3417 let mut command__ = None;
3418 let mut barrier_kind__ = None;
3419 let mut database_id__ = None;
3420 while let Some(k) = map_.next_key()? {
3421 match k {
3422 GeneratedField::PrevEpoch => {
3423 if prev_epoch__.is_some() {
3424 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3425 }
3426 prev_epoch__ =
3427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3428 ;
3429 }
3430 GeneratedField::CurEpoch => {
3431 if cur_epoch__.is_some() {
3432 return Err(serde::de::Error::duplicate_field("curEpoch"));
3433 }
3434 cur_epoch__ =
3435 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3436 ;
3437 }
3438 GeneratedField::DurationSec => {
3439 if duration_sec__.is_some() {
3440 return Err(serde::de::Error::duplicate_field("durationSec"));
3441 }
3442 duration_sec__ =
3443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3444 ;
3445 }
3446 GeneratedField::Command => {
3447 if command__.is_some() {
3448 return Err(serde::de::Error::duplicate_field("command"));
3449 }
3450 command__ = Some(map_.next_value()?);
3451 }
3452 GeneratedField::BarrierKind => {
3453 if barrier_kind__.is_some() {
3454 return Err(serde::de::Error::duplicate_field("barrierKind"));
3455 }
3456 barrier_kind__ = Some(map_.next_value()?);
3457 }
3458 GeneratedField::DatabaseId => {
3459 if database_id__.is_some() {
3460 return Err(serde::de::Error::duplicate_field("databaseId"));
3461 }
3462 database_id__ =
3463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3464 ;
3465 }
3466 }
3467 }
3468 Ok(event_log::EventBarrierComplete {
3469 prev_epoch: prev_epoch__.unwrap_or_default(),
3470 cur_epoch: cur_epoch__.unwrap_or_default(),
3471 duration_sec: duration_sec__.unwrap_or_default(),
3472 command: command__.unwrap_or_default(),
3473 barrier_kind: barrier_kind__.unwrap_or_default(),
3474 database_id: database_id__.unwrap_or_default(),
3475 })
3476 }
3477 }
3478 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3479 }
3480}
3481impl serde::Serialize for event_log::EventCollectBarrierFail {
3482 #[allow(deprecated)]
3483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3484 where
3485 S: serde::Serializer,
3486 {
3487 use serde::ser::SerializeStruct;
3488 let mut len = 0;
3489 if !self.error.is_empty() {
3490 len += 1;
3491 }
3492 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3493 if !self.error.is_empty() {
3494 struct_ser.serialize_field("error", &self.error)?;
3495 }
3496 struct_ser.end()
3497 }
3498}
3499impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3500 #[allow(deprecated)]
3501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3502 where
3503 D: serde::Deserializer<'de>,
3504 {
3505 const FIELDS: &[&str] = &[
3506 "error",
3507 ];
3508
3509 #[allow(clippy::enum_variant_names)]
3510 enum GeneratedField {
3511 Error,
3512 }
3513 impl<'de> serde::Deserialize<'de> for GeneratedField {
3514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3515 where
3516 D: serde::Deserializer<'de>,
3517 {
3518 struct GeneratedVisitor;
3519
3520 impl serde::de::Visitor<'_> for GeneratedVisitor {
3521 type Value = GeneratedField;
3522
3523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3524 write!(formatter, "expected one of: {:?}", &FIELDS)
3525 }
3526
3527 #[allow(unused_variables)]
3528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3529 where
3530 E: serde::de::Error,
3531 {
3532 match value {
3533 "error" => Ok(GeneratedField::Error),
3534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3535 }
3536 }
3537 }
3538 deserializer.deserialize_identifier(GeneratedVisitor)
3539 }
3540 }
3541 struct GeneratedVisitor;
3542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3543 type Value = event_log::EventCollectBarrierFail;
3544
3545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3546 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3547 }
3548
3549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3550 where
3551 V: serde::de::MapAccess<'de>,
3552 {
3553 let mut error__ = None;
3554 while let Some(k) = map_.next_key()? {
3555 match k {
3556 GeneratedField::Error => {
3557 if error__.is_some() {
3558 return Err(serde::de::Error::duplicate_field("error"));
3559 }
3560 error__ = Some(map_.next_value()?);
3561 }
3562 }
3563 }
3564 Ok(event_log::EventCollectBarrierFail {
3565 error: error__.unwrap_or_default(),
3566 })
3567 }
3568 }
3569 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3570 }
3571}
3572impl serde::Serialize for event_log::EventCreateStreamJobFail {
3573 #[allow(deprecated)]
3574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3575 where
3576 S: serde::Serializer,
3577 {
3578 use serde::ser::SerializeStruct;
3579 let mut len = 0;
3580 if self.id != 0 {
3581 len += 1;
3582 }
3583 if !self.name.is_empty() {
3584 len += 1;
3585 }
3586 if !self.definition.is_empty() {
3587 len += 1;
3588 }
3589 if !self.error.is_empty() {
3590 len += 1;
3591 }
3592 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3593 if self.id != 0 {
3594 struct_ser.serialize_field("id", &self.id)?;
3595 }
3596 if !self.name.is_empty() {
3597 struct_ser.serialize_field("name", &self.name)?;
3598 }
3599 if !self.definition.is_empty() {
3600 struct_ser.serialize_field("definition", &self.definition)?;
3601 }
3602 if !self.error.is_empty() {
3603 struct_ser.serialize_field("error", &self.error)?;
3604 }
3605 struct_ser.end()
3606 }
3607}
3608impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3609 #[allow(deprecated)]
3610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3611 where
3612 D: serde::Deserializer<'de>,
3613 {
3614 const FIELDS: &[&str] = &[
3615 "id",
3616 "name",
3617 "definition",
3618 "error",
3619 ];
3620
3621 #[allow(clippy::enum_variant_names)]
3622 enum GeneratedField {
3623 Id,
3624 Name,
3625 Definition,
3626 Error,
3627 }
3628 impl<'de> serde::Deserialize<'de> for GeneratedField {
3629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3630 where
3631 D: serde::Deserializer<'de>,
3632 {
3633 struct GeneratedVisitor;
3634
3635 impl serde::de::Visitor<'_> for GeneratedVisitor {
3636 type Value = GeneratedField;
3637
3638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3639 write!(formatter, "expected one of: {:?}", &FIELDS)
3640 }
3641
3642 #[allow(unused_variables)]
3643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3644 where
3645 E: serde::de::Error,
3646 {
3647 match value {
3648 "id" => Ok(GeneratedField::Id),
3649 "name" => Ok(GeneratedField::Name),
3650 "definition" => Ok(GeneratedField::Definition),
3651 "error" => Ok(GeneratedField::Error),
3652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3653 }
3654 }
3655 }
3656 deserializer.deserialize_identifier(GeneratedVisitor)
3657 }
3658 }
3659 struct GeneratedVisitor;
3660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3661 type Value = event_log::EventCreateStreamJobFail;
3662
3663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3664 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3665 }
3666
3667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3668 where
3669 V: serde::de::MapAccess<'de>,
3670 {
3671 let mut id__ = None;
3672 let mut name__ = None;
3673 let mut definition__ = None;
3674 let mut error__ = None;
3675 while let Some(k) = map_.next_key()? {
3676 match k {
3677 GeneratedField::Id => {
3678 if id__.is_some() {
3679 return Err(serde::de::Error::duplicate_field("id"));
3680 }
3681 id__ =
3682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3683 ;
3684 }
3685 GeneratedField::Name => {
3686 if name__.is_some() {
3687 return Err(serde::de::Error::duplicate_field("name"));
3688 }
3689 name__ = Some(map_.next_value()?);
3690 }
3691 GeneratedField::Definition => {
3692 if definition__.is_some() {
3693 return Err(serde::de::Error::duplicate_field("definition"));
3694 }
3695 definition__ = Some(map_.next_value()?);
3696 }
3697 GeneratedField::Error => {
3698 if error__.is_some() {
3699 return Err(serde::de::Error::duplicate_field("error"));
3700 }
3701 error__ = Some(map_.next_value()?);
3702 }
3703 }
3704 }
3705 Ok(event_log::EventCreateStreamJobFail {
3706 id: id__.unwrap_or_default(),
3707 name: name__.unwrap_or_default(),
3708 definition: definition__.unwrap_or_default(),
3709 error: error__.unwrap_or_default(),
3710 })
3711 }
3712 }
3713 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3714 }
3715}
3716impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3717 #[allow(deprecated)]
3718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3719 where
3720 S: serde::Serializer,
3721 {
3722 use serde::ser::SerializeStruct;
3723 let mut len = 0;
3724 if self.id != 0 {
3725 len += 1;
3726 }
3727 if !self.name.is_empty() {
3728 len += 1;
3729 }
3730 if !self.definition.is_empty() {
3731 len += 1;
3732 }
3733 if !self.error.is_empty() {
3734 len += 1;
3735 }
3736 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3737 if self.id != 0 {
3738 struct_ser.serialize_field("id", &self.id)?;
3739 }
3740 if !self.name.is_empty() {
3741 struct_ser.serialize_field("name", &self.name)?;
3742 }
3743 if !self.definition.is_empty() {
3744 struct_ser.serialize_field("definition", &self.definition)?;
3745 }
3746 if !self.error.is_empty() {
3747 struct_ser.serialize_field("error", &self.error)?;
3748 }
3749 struct_ser.end()
3750 }
3751}
3752impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3753 #[allow(deprecated)]
3754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3755 where
3756 D: serde::Deserializer<'de>,
3757 {
3758 const FIELDS: &[&str] = &[
3759 "id",
3760 "name",
3761 "definition",
3762 "error",
3763 ];
3764
3765 #[allow(clippy::enum_variant_names)]
3766 enum GeneratedField {
3767 Id,
3768 Name,
3769 Definition,
3770 Error,
3771 }
3772 impl<'de> serde::Deserialize<'de> for GeneratedField {
3773 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3774 where
3775 D: serde::Deserializer<'de>,
3776 {
3777 struct GeneratedVisitor;
3778
3779 impl serde::de::Visitor<'_> for GeneratedVisitor {
3780 type Value = GeneratedField;
3781
3782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3783 write!(formatter, "expected one of: {:?}", &FIELDS)
3784 }
3785
3786 #[allow(unused_variables)]
3787 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3788 where
3789 E: serde::de::Error,
3790 {
3791 match value {
3792 "id" => Ok(GeneratedField::Id),
3793 "name" => Ok(GeneratedField::Name),
3794 "definition" => Ok(GeneratedField::Definition),
3795 "error" => Ok(GeneratedField::Error),
3796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3797 }
3798 }
3799 }
3800 deserializer.deserialize_identifier(GeneratedVisitor)
3801 }
3802 }
3803 struct GeneratedVisitor;
3804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3805 type Value = event_log::EventDirtyStreamJobClear;
3806
3807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3808 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3809 }
3810
3811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3812 where
3813 V: serde::de::MapAccess<'de>,
3814 {
3815 let mut id__ = None;
3816 let mut name__ = None;
3817 let mut definition__ = None;
3818 let mut error__ = None;
3819 while let Some(k) = map_.next_key()? {
3820 match k {
3821 GeneratedField::Id => {
3822 if id__.is_some() {
3823 return Err(serde::de::Error::duplicate_field("id"));
3824 }
3825 id__ =
3826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3827 ;
3828 }
3829 GeneratedField::Name => {
3830 if name__.is_some() {
3831 return Err(serde::de::Error::duplicate_field("name"));
3832 }
3833 name__ = Some(map_.next_value()?);
3834 }
3835 GeneratedField::Definition => {
3836 if definition__.is_some() {
3837 return Err(serde::de::Error::duplicate_field("definition"));
3838 }
3839 definition__ = Some(map_.next_value()?);
3840 }
3841 GeneratedField::Error => {
3842 if error__.is_some() {
3843 return Err(serde::de::Error::duplicate_field("error"));
3844 }
3845 error__ = Some(map_.next_value()?);
3846 }
3847 }
3848 }
3849 Ok(event_log::EventDirtyStreamJobClear {
3850 id: id__.unwrap_or_default(),
3851 name: name__.unwrap_or_default(),
3852 definition: definition__.unwrap_or_default(),
3853 error: error__.unwrap_or_default(),
3854 })
3855 }
3856 }
3857 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3858 }
3859}
3860impl serde::Serialize for event_log::EventInjectBarrierFail {
3861 #[allow(deprecated)]
3862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3863 where
3864 S: serde::Serializer,
3865 {
3866 use serde::ser::SerializeStruct;
3867 let mut len = 0;
3868 if self.prev_epoch != 0 {
3869 len += 1;
3870 }
3871 if self.cur_epoch != 0 {
3872 len += 1;
3873 }
3874 if !self.error.is_empty() {
3875 len += 1;
3876 }
3877 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3878 if self.prev_epoch != 0 {
3879 #[allow(clippy::needless_borrow)]
3880 #[allow(clippy::needless_borrows_for_generic_args)]
3881 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3882 }
3883 if self.cur_epoch != 0 {
3884 #[allow(clippy::needless_borrow)]
3885 #[allow(clippy::needless_borrows_for_generic_args)]
3886 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3887 }
3888 if !self.error.is_empty() {
3889 struct_ser.serialize_field("error", &self.error)?;
3890 }
3891 struct_ser.end()
3892 }
3893}
3894impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3895 #[allow(deprecated)]
3896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3897 where
3898 D: serde::Deserializer<'de>,
3899 {
3900 const FIELDS: &[&str] = &[
3901 "prev_epoch",
3902 "prevEpoch",
3903 "cur_epoch",
3904 "curEpoch",
3905 "error",
3906 ];
3907
3908 #[allow(clippy::enum_variant_names)]
3909 enum GeneratedField {
3910 PrevEpoch,
3911 CurEpoch,
3912 Error,
3913 }
3914 impl<'de> serde::Deserialize<'de> for GeneratedField {
3915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3916 where
3917 D: serde::Deserializer<'de>,
3918 {
3919 struct GeneratedVisitor;
3920
3921 impl serde::de::Visitor<'_> for GeneratedVisitor {
3922 type Value = GeneratedField;
3923
3924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3925 write!(formatter, "expected one of: {:?}", &FIELDS)
3926 }
3927
3928 #[allow(unused_variables)]
3929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3930 where
3931 E: serde::de::Error,
3932 {
3933 match value {
3934 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3935 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3936 "error" => Ok(GeneratedField::Error),
3937 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3938 }
3939 }
3940 }
3941 deserializer.deserialize_identifier(GeneratedVisitor)
3942 }
3943 }
3944 struct GeneratedVisitor;
3945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3946 type Value = event_log::EventInjectBarrierFail;
3947
3948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3949 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3950 }
3951
3952 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3953 where
3954 V: serde::de::MapAccess<'de>,
3955 {
3956 let mut prev_epoch__ = None;
3957 let mut cur_epoch__ = None;
3958 let mut error__ = None;
3959 while let Some(k) = map_.next_key()? {
3960 match k {
3961 GeneratedField::PrevEpoch => {
3962 if prev_epoch__.is_some() {
3963 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3964 }
3965 prev_epoch__ =
3966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3967 ;
3968 }
3969 GeneratedField::CurEpoch => {
3970 if cur_epoch__.is_some() {
3971 return Err(serde::de::Error::duplicate_field("curEpoch"));
3972 }
3973 cur_epoch__ =
3974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3975 ;
3976 }
3977 GeneratedField::Error => {
3978 if error__.is_some() {
3979 return Err(serde::de::Error::duplicate_field("error"));
3980 }
3981 error__ = Some(map_.next_value()?);
3982 }
3983 }
3984 }
3985 Ok(event_log::EventInjectBarrierFail {
3986 prev_epoch: prev_epoch__.unwrap_or_default(),
3987 cur_epoch: cur_epoch__.unwrap_or_default(),
3988 error: error__.unwrap_or_default(),
3989 })
3990 }
3991 }
3992 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3993 }
3994}
3995impl serde::Serialize for event_log::EventMetaNodeStart {
3996 #[allow(deprecated)]
3997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3998 where
3999 S: serde::Serializer,
4000 {
4001 use serde::ser::SerializeStruct;
4002 let mut len = 0;
4003 if !self.advertise_addr.is_empty() {
4004 len += 1;
4005 }
4006 if !self.listen_addr.is_empty() {
4007 len += 1;
4008 }
4009 if !self.opts.is_empty() {
4010 len += 1;
4011 }
4012 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
4013 if !self.advertise_addr.is_empty() {
4014 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
4015 }
4016 if !self.listen_addr.is_empty() {
4017 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
4018 }
4019 if !self.opts.is_empty() {
4020 struct_ser.serialize_field("opts", &self.opts)?;
4021 }
4022 struct_ser.end()
4023 }
4024}
4025impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
4026 #[allow(deprecated)]
4027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4028 where
4029 D: serde::Deserializer<'de>,
4030 {
4031 const FIELDS: &[&str] = &[
4032 "advertise_addr",
4033 "advertiseAddr",
4034 "listen_addr",
4035 "listenAddr",
4036 "opts",
4037 ];
4038
4039 #[allow(clippy::enum_variant_names)]
4040 enum GeneratedField {
4041 AdvertiseAddr,
4042 ListenAddr,
4043 Opts,
4044 }
4045 impl<'de> serde::Deserialize<'de> for GeneratedField {
4046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4047 where
4048 D: serde::Deserializer<'de>,
4049 {
4050 struct GeneratedVisitor;
4051
4052 impl serde::de::Visitor<'_> for GeneratedVisitor {
4053 type Value = GeneratedField;
4054
4055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4056 write!(formatter, "expected one of: {:?}", &FIELDS)
4057 }
4058
4059 #[allow(unused_variables)]
4060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4061 where
4062 E: serde::de::Error,
4063 {
4064 match value {
4065 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
4066 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
4067 "opts" => Ok(GeneratedField::Opts),
4068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4069 }
4070 }
4071 }
4072 deserializer.deserialize_identifier(GeneratedVisitor)
4073 }
4074 }
4075 struct GeneratedVisitor;
4076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4077 type Value = event_log::EventMetaNodeStart;
4078
4079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4080 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
4081 }
4082
4083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
4084 where
4085 V: serde::de::MapAccess<'de>,
4086 {
4087 let mut advertise_addr__ = None;
4088 let mut listen_addr__ = None;
4089 let mut opts__ = None;
4090 while let Some(k) = map_.next_key()? {
4091 match k {
4092 GeneratedField::AdvertiseAddr => {
4093 if advertise_addr__.is_some() {
4094 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
4095 }
4096 advertise_addr__ = Some(map_.next_value()?);
4097 }
4098 GeneratedField::ListenAddr => {
4099 if listen_addr__.is_some() {
4100 return Err(serde::de::Error::duplicate_field("listenAddr"));
4101 }
4102 listen_addr__ = Some(map_.next_value()?);
4103 }
4104 GeneratedField::Opts => {
4105 if opts__.is_some() {
4106 return Err(serde::de::Error::duplicate_field("opts"));
4107 }
4108 opts__ = Some(map_.next_value()?);
4109 }
4110 }
4111 }
4112 Ok(event_log::EventMetaNodeStart {
4113 advertise_addr: advertise_addr__.unwrap_or_default(),
4114 listen_addr: listen_addr__.unwrap_or_default(),
4115 opts: opts__.unwrap_or_default(),
4116 })
4117 }
4118 }
4119 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
4120 }
4121}
4122impl serde::Serialize for event_log::EventRecovery {
4123 #[allow(deprecated)]
4124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4125 where
4126 S: serde::Serializer,
4127 {
4128 use serde::ser::SerializeStruct;
4129 let mut len = 0;
4130 if self.recovery_event.is_some() {
4131 len += 1;
4132 }
4133 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
4134 if let Some(v) = self.recovery_event.as_ref() {
4135 match v {
4136 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
4137 struct_ser.serialize_field("globalStart", v)?;
4138 }
4139 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
4140 struct_ser.serialize_field("globalSuccess", v)?;
4141 }
4142 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
4143 struct_ser.serialize_field("globalFailure", v)?;
4144 }
4145 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
4146 struct_ser.serialize_field("databaseStart", v)?;
4147 }
4148 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
4149 struct_ser.serialize_field("databaseFailure", v)?;
4150 }
4151 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
4152 struct_ser.serialize_field("databaseSuccess", v)?;
4153 }
4154 }
4155 }
4156 struct_ser.end()
4157 }
4158}
4159impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
4160 #[allow(deprecated)]
4161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4162 where
4163 D: serde::Deserializer<'de>,
4164 {
4165 const FIELDS: &[&str] = &[
4166 "global_start",
4167 "globalStart",
4168 "global_success",
4169 "globalSuccess",
4170 "global_failure",
4171 "globalFailure",
4172 "database_start",
4173 "databaseStart",
4174 "database_failure",
4175 "databaseFailure",
4176 "database_success",
4177 "databaseSuccess",
4178 ];
4179
4180 #[allow(clippy::enum_variant_names)]
4181 enum GeneratedField {
4182 GlobalStart,
4183 GlobalSuccess,
4184 GlobalFailure,
4185 DatabaseStart,
4186 DatabaseFailure,
4187 DatabaseSuccess,
4188 }
4189 impl<'de> serde::Deserialize<'de> for GeneratedField {
4190 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4191 where
4192 D: serde::Deserializer<'de>,
4193 {
4194 struct GeneratedVisitor;
4195
4196 impl serde::de::Visitor<'_> for GeneratedVisitor {
4197 type Value = GeneratedField;
4198
4199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4200 write!(formatter, "expected one of: {:?}", &FIELDS)
4201 }
4202
4203 #[allow(unused_variables)]
4204 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4205 where
4206 E: serde::de::Error,
4207 {
4208 match value {
4209 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
4210 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
4211 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
4212 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
4213 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
4214 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
4215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4216 }
4217 }
4218 }
4219 deserializer.deserialize_identifier(GeneratedVisitor)
4220 }
4221 }
4222 struct GeneratedVisitor;
4223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4224 type Value = event_log::EventRecovery;
4225
4226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4227 formatter.write_str("struct meta.EventLog.EventRecovery")
4228 }
4229
4230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
4231 where
4232 V: serde::de::MapAccess<'de>,
4233 {
4234 let mut recovery_event__ = None;
4235 while let Some(k) = map_.next_key()? {
4236 match k {
4237 GeneratedField::GlobalStart => {
4238 if recovery_event__.is_some() {
4239 return Err(serde::de::Error::duplicate_field("globalStart"));
4240 }
4241 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
4242;
4243 }
4244 GeneratedField::GlobalSuccess => {
4245 if recovery_event__.is_some() {
4246 return Err(serde::de::Error::duplicate_field("globalSuccess"));
4247 }
4248 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
4249;
4250 }
4251 GeneratedField::GlobalFailure => {
4252 if recovery_event__.is_some() {
4253 return Err(serde::de::Error::duplicate_field("globalFailure"));
4254 }
4255 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
4256;
4257 }
4258 GeneratedField::DatabaseStart => {
4259 if recovery_event__.is_some() {
4260 return Err(serde::de::Error::duplicate_field("databaseStart"));
4261 }
4262 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
4263;
4264 }
4265 GeneratedField::DatabaseFailure => {
4266 if recovery_event__.is_some() {
4267 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4268 }
4269 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4270;
4271 }
4272 GeneratedField::DatabaseSuccess => {
4273 if recovery_event__.is_some() {
4274 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4275 }
4276 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4277;
4278 }
4279 }
4280 }
4281 Ok(event_log::EventRecovery {
4282 recovery_event: recovery_event__,
4283 })
4284 }
4285 }
4286 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4287 }
4288}
4289impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4290 #[allow(deprecated)]
4291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4292 where
4293 S: serde::Serializer,
4294 {
4295 use serde::ser::SerializeStruct;
4296 let mut len = 0;
4297 if self.database_id != 0 {
4298 len += 1;
4299 }
4300 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4301 if self.database_id != 0 {
4302 struct_ser.serialize_field("databaseId", &self.database_id)?;
4303 }
4304 struct_ser.end()
4305 }
4306}
4307impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4308 #[allow(deprecated)]
4309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4310 where
4311 D: serde::Deserializer<'de>,
4312 {
4313 const FIELDS: &[&str] = &[
4314 "database_id",
4315 "databaseId",
4316 ];
4317
4318 #[allow(clippy::enum_variant_names)]
4319 enum GeneratedField {
4320 DatabaseId,
4321 }
4322 impl<'de> serde::Deserialize<'de> for GeneratedField {
4323 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4324 where
4325 D: serde::Deserializer<'de>,
4326 {
4327 struct GeneratedVisitor;
4328
4329 impl serde::de::Visitor<'_> for GeneratedVisitor {
4330 type Value = GeneratedField;
4331
4332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4333 write!(formatter, "expected one of: {:?}", &FIELDS)
4334 }
4335
4336 #[allow(unused_variables)]
4337 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4338 where
4339 E: serde::de::Error,
4340 {
4341 match value {
4342 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4344 }
4345 }
4346 }
4347 deserializer.deserialize_identifier(GeneratedVisitor)
4348 }
4349 }
4350 struct GeneratedVisitor;
4351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4352 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4353
4354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4355 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4356 }
4357
4358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4359 where
4360 V: serde::de::MapAccess<'de>,
4361 {
4362 let mut database_id__ = None;
4363 while let Some(k) = map_.next_key()? {
4364 match k {
4365 GeneratedField::DatabaseId => {
4366 if database_id__.is_some() {
4367 return Err(serde::de::Error::duplicate_field("databaseId"));
4368 }
4369 database_id__ =
4370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4371 ;
4372 }
4373 }
4374 }
4375 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4376 database_id: database_id__.unwrap_or_default(),
4377 })
4378 }
4379 }
4380 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4381 }
4382}
4383impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4384 #[allow(deprecated)]
4385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4386 where
4387 S: serde::Serializer,
4388 {
4389 use serde::ser::SerializeStruct;
4390 let mut len = 0;
4391 if self.database_id != 0 {
4392 len += 1;
4393 }
4394 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4395 if self.database_id != 0 {
4396 struct_ser.serialize_field("databaseId", &self.database_id)?;
4397 }
4398 struct_ser.end()
4399 }
4400}
4401impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4402 #[allow(deprecated)]
4403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4404 where
4405 D: serde::Deserializer<'de>,
4406 {
4407 const FIELDS: &[&str] = &[
4408 "database_id",
4409 "databaseId",
4410 ];
4411
4412 #[allow(clippy::enum_variant_names)]
4413 enum GeneratedField {
4414 DatabaseId,
4415 }
4416 impl<'de> serde::Deserialize<'de> for GeneratedField {
4417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4418 where
4419 D: serde::Deserializer<'de>,
4420 {
4421 struct GeneratedVisitor;
4422
4423 impl serde::de::Visitor<'_> for GeneratedVisitor {
4424 type Value = GeneratedField;
4425
4426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4427 write!(formatter, "expected one of: {:?}", &FIELDS)
4428 }
4429
4430 #[allow(unused_variables)]
4431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4432 where
4433 E: serde::de::Error,
4434 {
4435 match value {
4436 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4438 }
4439 }
4440 }
4441 deserializer.deserialize_identifier(GeneratedVisitor)
4442 }
4443 }
4444 struct GeneratedVisitor;
4445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4446 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4447
4448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4449 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4450 }
4451
4452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4453 where
4454 V: serde::de::MapAccess<'de>,
4455 {
4456 let mut database_id__ = None;
4457 while let Some(k) = map_.next_key()? {
4458 match k {
4459 GeneratedField::DatabaseId => {
4460 if database_id__.is_some() {
4461 return Err(serde::de::Error::duplicate_field("databaseId"));
4462 }
4463 database_id__ =
4464 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4465 ;
4466 }
4467 }
4468 }
4469 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4470 database_id: database_id__.unwrap_or_default(),
4471 })
4472 }
4473 }
4474 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4475 }
4476}
4477impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4478 #[allow(deprecated)]
4479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4480 where
4481 S: serde::Serializer,
4482 {
4483 use serde::ser::SerializeStruct;
4484 let mut len = 0;
4485 if self.database_id != 0 {
4486 len += 1;
4487 }
4488 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4489 if self.database_id != 0 {
4490 struct_ser.serialize_field("databaseId", &self.database_id)?;
4491 }
4492 struct_ser.end()
4493 }
4494}
4495impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4496 #[allow(deprecated)]
4497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4498 where
4499 D: serde::Deserializer<'de>,
4500 {
4501 const FIELDS: &[&str] = &[
4502 "database_id",
4503 "databaseId",
4504 ];
4505
4506 #[allow(clippy::enum_variant_names)]
4507 enum GeneratedField {
4508 DatabaseId,
4509 }
4510 impl<'de> serde::Deserialize<'de> for GeneratedField {
4511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4512 where
4513 D: serde::Deserializer<'de>,
4514 {
4515 struct GeneratedVisitor;
4516
4517 impl serde::de::Visitor<'_> for GeneratedVisitor {
4518 type Value = GeneratedField;
4519
4520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4521 write!(formatter, "expected one of: {:?}", &FIELDS)
4522 }
4523
4524 #[allow(unused_variables)]
4525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4526 where
4527 E: serde::de::Error,
4528 {
4529 match value {
4530 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4532 }
4533 }
4534 }
4535 deserializer.deserialize_identifier(GeneratedVisitor)
4536 }
4537 }
4538 struct GeneratedVisitor;
4539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4540 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4541
4542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4543 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4544 }
4545
4546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4547 where
4548 V: serde::de::MapAccess<'de>,
4549 {
4550 let mut database_id__ = None;
4551 while let Some(k) = map_.next_key()? {
4552 match k {
4553 GeneratedField::DatabaseId => {
4554 if database_id__.is_some() {
4555 return Err(serde::de::Error::duplicate_field("databaseId"));
4556 }
4557 database_id__ =
4558 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4559 ;
4560 }
4561 }
4562 }
4563 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4564 database_id: database_id__.unwrap_or_default(),
4565 })
4566 }
4567 }
4568 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4569 }
4570}
4571impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4572 #[allow(deprecated)]
4573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4574 where
4575 S: serde::Serializer,
4576 {
4577 use serde::ser::SerializeStruct;
4578 let mut len = 0;
4579 if !self.reason.is_empty() {
4580 len += 1;
4581 }
4582 if !self.error.is_empty() {
4583 len += 1;
4584 }
4585 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4586 if !self.reason.is_empty() {
4587 struct_ser.serialize_field("reason", &self.reason)?;
4588 }
4589 if !self.error.is_empty() {
4590 struct_ser.serialize_field("error", &self.error)?;
4591 }
4592 struct_ser.end()
4593 }
4594}
4595impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4596 #[allow(deprecated)]
4597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4598 where
4599 D: serde::Deserializer<'de>,
4600 {
4601 const FIELDS: &[&str] = &[
4602 "reason",
4603 "error",
4604 ];
4605
4606 #[allow(clippy::enum_variant_names)]
4607 enum GeneratedField {
4608 Reason,
4609 Error,
4610 }
4611 impl<'de> serde::Deserialize<'de> for GeneratedField {
4612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4613 where
4614 D: serde::Deserializer<'de>,
4615 {
4616 struct GeneratedVisitor;
4617
4618 impl serde::de::Visitor<'_> for GeneratedVisitor {
4619 type Value = GeneratedField;
4620
4621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4622 write!(formatter, "expected one of: {:?}", &FIELDS)
4623 }
4624
4625 #[allow(unused_variables)]
4626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4627 where
4628 E: serde::de::Error,
4629 {
4630 match value {
4631 "reason" => Ok(GeneratedField::Reason),
4632 "error" => Ok(GeneratedField::Error),
4633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4634 }
4635 }
4636 }
4637 deserializer.deserialize_identifier(GeneratedVisitor)
4638 }
4639 }
4640 struct GeneratedVisitor;
4641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4642 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4643
4644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4645 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4646 }
4647
4648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4649 where
4650 V: serde::de::MapAccess<'de>,
4651 {
4652 let mut reason__ = None;
4653 let mut error__ = None;
4654 while let Some(k) = map_.next_key()? {
4655 match k {
4656 GeneratedField::Reason => {
4657 if reason__.is_some() {
4658 return Err(serde::de::Error::duplicate_field("reason"));
4659 }
4660 reason__ = Some(map_.next_value()?);
4661 }
4662 GeneratedField::Error => {
4663 if error__.is_some() {
4664 return Err(serde::de::Error::duplicate_field("error"));
4665 }
4666 error__ = Some(map_.next_value()?);
4667 }
4668 }
4669 }
4670 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4671 reason: reason__.unwrap_or_default(),
4672 error: error__.unwrap_or_default(),
4673 })
4674 }
4675 }
4676 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4677 }
4678}
4679impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4680 #[allow(deprecated)]
4681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4682 where
4683 S: serde::Serializer,
4684 {
4685 use serde::ser::SerializeStruct;
4686 let mut len = 0;
4687 if !self.reason.is_empty() {
4688 len += 1;
4689 }
4690 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4691 if !self.reason.is_empty() {
4692 struct_ser.serialize_field("reason", &self.reason)?;
4693 }
4694 struct_ser.end()
4695 }
4696}
4697impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4698 #[allow(deprecated)]
4699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4700 where
4701 D: serde::Deserializer<'de>,
4702 {
4703 const FIELDS: &[&str] = &[
4704 "reason",
4705 ];
4706
4707 #[allow(clippy::enum_variant_names)]
4708 enum GeneratedField {
4709 Reason,
4710 }
4711 impl<'de> serde::Deserialize<'de> for GeneratedField {
4712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4713 where
4714 D: serde::Deserializer<'de>,
4715 {
4716 struct GeneratedVisitor;
4717
4718 impl serde::de::Visitor<'_> for GeneratedVisitor {
4719 type Value = GeneratedField;
4720
4721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4722 write!(formatter, "expected one of: {:?}", &FIELDS)
4723 }
4724
4725 #[allow(unused_variables)]
4726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4727 where
4728 E: serde::de::Error,
4729 {
4730 match value {
4731 "reason" => Ok(GeneratedField::Reason),
4732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4733 }
4734 }
4735 }
4736 deserializer.deserialize_identifier(GeneratedVisitor)
4737 }
4738 }
4739 struct GeneratedVisitor;
4740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4741 type Value = event_log::event_recovery::GlobalRecoveryStart;
4742
4743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4744 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4745 }
4746
4747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4748 where
4749 V: serde::de::MapAccess<'de>,
4750 {
4751 let mut reason__ = None;
4752 while let Some(k) = map_.next_key()? {
4753 match k {
4754 GeneratedField::Reason => {
4755 if reason__.is_some() {
4756 return Err(serde::de::Error::duplicate_field("reason"));
4757 }
4758 reason__ = Some(map_.next_value()?);
4759 }
4760 }
4761 }
4762 Ok(event_log::event_recovery::GlobalRecoveryStart {
4763 reason: reason__.unwrap_or_default(),
4764 })
4765 }
4766 }
4767 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4768 }
4769}
4770impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4771 #[allow(deprecated)]
4772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4773 where
4774 S: serde::Serializer,
4775 {
4776 use serde::ser::SerializeStruct;
4777 let mut len = 0;
4778 if !self.reason.is_empty() {
4779 len += 1;
4780 }
4781 if self.duration_secs != 0. {
4782 len += 1;
4783 }
4784 if !self.running_database_ids.is_empty() {
4785 len += 1;
4786 }
4787 if !self.recovering_database_ids.is_empty() {
4788 len += 1;
4789 }
4790 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4791 if !self.reason.is_empty() {
4792 struct_ser.serialize_field("reason", &self.reason)?;
4793 }
4794 if self.duration_secs != 0. {
4795 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4796 }
4797 if !self.running_database_ids.is_empty() {
4798 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4799 }
4800 if !self.recovering_database_ids.is_empty() {
4801 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4802 }
4803 struct_ser.end()
4804 }
4805}
4806impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4807 #[allow(deprecated)]
4808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4809 where
4810 D: serde::Deserializer<'de>,
4811 {
4812 const FIELDS: &[&str] = &[
4813 "reason",
4814 "duration_secs",
4815 "durationSecs",
4816 "running_database_ids",
4817 "runningDatabaseIds",
4818 "recovering_database_ids",
4819 "recoveringDatabaseIds",
4820 ];
4821
4822 #[allow(clippy::enum_variant_names)]
4823 enum GeneratedField {
4824 Reason,
4825 DurationSecs,
4826 RunningDatabaseIds,
4827 RecoveringDatabaseIds,
4828 }
4829 impl<'de> serde::Deserialize<'de> for GeneratedField {
4830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4831 where
4832 D: serde::Deserializer<'de>,
4833 {
4834 struct GeneratedVisitor;
4835
4836 impl serde::de::Visitor<'_> for GeneratedVisitor {
4837 type Value = GeneratedField;
4838
4839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4840 write!(formatter, "expected one of: {:?}", &FIELDS)
4841 }
4842
4843 #[allow(unused_variables)]
4844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4845 where
4846 E: serde::de::Error,
4847 {
4848 match value {
4849 "reason" => Ok(GeneratedField::Reason),
4850 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4851 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4852 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4853 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4854 }
4855 }
4856 }
4857 deserializer.deserialize_identifier(GeneratedVisitor)
4858 }
4859 }
4860 struct GeneratedVisitor;
4861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4862 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4863
4864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4865 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4866 }
4867
4868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4869 where
4870 V: serde::de::MapAccess<'de>,
4871 {
4872 let mut reason__ = None;
4873 let mut duration_secs__ = None;
4874 let mut running_database_ids__ = None;
4875 let mut recovering_database_ids__ = None;
4876 while let Some(k) = map_.next_key()? {
4877 match k {
4878 GeneratedField::Reason => {
4879 if reason__.is_some() {
4880 return Err(serde::de::Error::duplicate_field("reason"));
4881 }
4882 reason__ = Some(map_.next_value()?);
4883 }
4884 GeneratedField::DurationSecs => {
4885 if duration_secs__.is_some() {
4886 return Err(serde::de::Error::duplicate_field("durationSecs"));
4887 }
4888 duration_secs__ =
4889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4890 ;
4891 }
4892 GeneratedField::RunningDatabaseIds => {
4893 if running_database_ids__.is_some() {
4894 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4895 }
4896 running_database_ids__ =
4897 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4898 .into_iter().map(|x| x.0).collect())
4899 ;
4900 }
4901 GeneratedField::RecoveringDatabaseIds => {
4902 if recovering_database_ids__.is_some() {
4903 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4904 }
4905 recovering_database_ids__ =
4906 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4907 .into_iter().map(|x| x.0).collect())
4908 ;
4909 }
4910 }
4911 }
4912 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4913 reason: reason__.unwrap_or_default(),
4914 duration_secs: duration_secs__.unwrap_or_default(),
4915 running_database_ids: running_database_ids__.unwrap_or_default(),
4916 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4917 })
4918 }
4919 }
4920 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4921 }
4922}
4923impl serde::Serialize for event_log::EventSinkFail {
4924 #[allow(deprecated)]
4925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4926 where
4927 S: serde::Serializer,
4928 {
4929 use serde::ser::SerializeStruct;
4930 let mut len = 0;
4931 if self.sink_id != 0 {
4932 len += 1;
4933 }
4934 if !self.sink_name.is_empty() {
4935 len += 1;
4936 }
4937 if !self.connector.is_empty() {
4938 len += 1;
4939 }
4940 if !self.error.is_empty() {
4941 len += 1;
4942 }
4943 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4944 if self.sink_id != 0 {
4945 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4946 }
4947 if !self.sink_name.is_empty() {
4948 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4949 }
4950 if !self.connector.is_empty() {
4951 struct_ser.serialize_field("connector", &self.connector)?;
4952 }
4953 if !self.error.is_empty() {
4954 struct_ser.serialize_field("error", &self.error)?;
4955 }
4956 struct_ser.end()
4957 }
4958}
4959impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4960 #[allow(deprecated)]
4961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4962 where
4963 D: serde::Deserializer<'de>,
4964 {
4965 const FIELDS: &[&str] = &[
4966 "sink_id",
4967 "sinkId",
4968 "sink_name",
4969 "sinkName",
4970 "connector",
4971 "error",
4972 ];
4973
4974 #[allow(clippy::enum_variant_names)]
4975 enum GeneratedField {
4976 SinkId,
4977 SinkName,
4978 Connector,
4979 Error,
4980 }
4981 impl<'de> serde::Deserialize<'de> for GeneratedField {
4982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4983 where
4984 D: serde::Deserializer<'de>,
4985 {
4986 struct GeneratedVisitor;
4987
4988 impl serde::de::Visitor<'_> for GeneratedVisitor {
4989 type Value = GeneratedField;
4990
4991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4992 write!(formatter, "expected one of: {:?}", &FIELDS)
4993 }
4994
4995 #[allow(unused_variables)]
4996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4997 where
4998 E: serde::de::Error,
4999 {
5000 match value {
5001 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
5002 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
5003 "connector" => Ok(GeneratedField::Connector),
5004 "error" => Ok(GeneratedField::Error),
5005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5006 }
5007 }
5008 }
5009 deserializer.deserialize_identifier(GeneratedVisitor)
5010 }
5011 }
5012 struct GeneratedVisitor;
5013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5014 type Value = event_log::EventSinkFail;
5015
5016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5017 formatter.write_str("struct meta.EventLog.EventSinkFail")
5018 }
5019
5020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
5021 where
5022 V: serde::de::MapAccess<'de>,
5023 {
5024 let mut sink_id__ = None;
5025 let mut sink_name__ = None;
5026 let mut connector__ = None;
5027 let mut error__ = None;
5028 while let Some(k) = map_.next_key()? {
5029 match k {
5030 GeneratedField::SinkId => {
5031 if sink_id__.is_some() {
5032 return Err(serde::de::Error::duplicate_field("sinkId"));
5033 }
5034 sink_id__ =
5035 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5036 ;
5037 }
5038 GeneratedField::SinkName => {
5039 if sink_name__.is_some() {
5040 return Err(serde::de::Error::duplicate_field("sinkName"));
5041 }
5042 sink_name__ = Some(map_.next_value()?);
5043 }
5044 GeneratedField::Connector => {
5045 if connector__.is_some() {
5046 return Err(serde::de::Error::duplicate_field("connector"));
5047 }
5048 connector__ = Some(map_.next_value()?);
5049 }
5050 GeneratedField::Error => {
5051 if error__.is_some() {
5052 return Err(serde::de::Error::duplicate_field("error"));
5053 }
5054 error__ = Some(map_.next_value()?);
5055 }
5056 }
5057 }
5058 Ok(event_log::EventSinkFail {
5059 sink_id: sink_id__.unwrap_or_default(),
5060 sink_name: sink_name__.unwrap_or_default(),
5061 connector: connector__.unwrap_or_default(),
5062 error: error__.unwrap_or_default(),
5063 })
5064 }
5065 }
5066 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
5067 }
5068}
5069impl serde::Serialize for event_log::EventWorkerNodePanic {
5070 #[allow(deprecated)]
5071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5072 where
5073 S: serde::Serializer,
5074 {
5075 use serde::ser::SerializeStruct;
5076 let mut len = 0;
5077 if self.worker_id != 0 {
5078 len += 1;
5079 }
5080 if self.worker_type != 0 {
5081 len += 1;
5082 }
5083 if self.host_addr.is_some() {
5084 len += 1;
5085 }
5086 if !self.panic_info.is_empty() {
5087 len += 1;
5088 }
5089 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
5090 if self.worker_id != 0 {
5091 struct_ser.serialize_field("workerId", &self.worker_id)?;
5092 }
5093 if self.worker_type != 0 {
5094 let v = super::common::WorkerType::try_from(self.worker_type)
5095 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
5096 struct_ser.serialize_field("workerType", &v)?;
5097 }
5098 if let Some(v) = self.host_addr.as_ref() {
5099 struct_ser.serialize_field("hostAddr", v)?;
5100 }
5101 if !self.panic_info.is_empty() {
5102 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
5103 }
5104 struct_ser.end()
5105 }
5106}
5107impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
5108 #[allow(deprecated)]
5109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5110 where
5111 D: serde::Deserializer<'de>,
5112 {
5113 const FIELDS: &[&str] = &[
5114 "worker_id",
5115 "workerId",
5116 "worker_type",
5117 "workerType",
5118 "host_addr",
5119 "hostAddr",
5120 "panic_info",
5121 "panicInfo",
5122 ];
5123
5124 #[allow(clippy::enum_variant_names)]
5125 enum GeneratedField {
5126 WorkerId,
5127 WorkerType,
5128 HostAddr,
5129 PanicInfo,
5130 }
5131 impl<'de> serde::Deserialize<'de> for GeneratedField {
5132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5133 where
5134 D: serde::Deserializer<'de>,
5135 {
5136 struct GeneratedVisitor;
5137
5138 impl serde::de::Visitor<'_> for GeneratedVisitor {
5139 type Value = GeneratedField;
5140
5141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142 write!(formatter, "expected one of: {:?}", &FIELDS)
5143 }
5144
5145 #[allow(unused_variables)]
5146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5147 where
5148 E: serde::de::Error,
5149 {
5150 match value {
5151 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
5152 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
5153 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
5154 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
5155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5156 }
5157 }
5158 }
5159 deserializer.deserialize_identifier(GeneratedVisitor)
5160 }
5161 }
5162 struct GeneratedVisitor;
5163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5164 type Value = event_log::EventWorkerNodePanic;
5165
5166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5167 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
5168 }
5169
5170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
5171 where
5172 V: serde::de::MapAccess<'de>,
5173 {
5174 let mut worker_id__ = None;
5175 let mut worker_type__ = None;
5176 let mut host_addr__ = None;
5177 let mut panic_info__ = None;
5178 while let Some(k) = map_.next_key()? {
5179 match k {
5180 GeneratedField::WorkerId => {
5181 if worker_id__.is_some() {
5182 return Err(serde::de::Error::duplicate_field("workerId"));
5183 }
5184 worker_id__ =
5185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5186 ;
5187 }
5188 GeneratedField::WorkerType => {
5189 if worker_type__.is_some() {
5190 return Err(serde::de::Error::duplicate_field("workerType"));
5191 }
5192 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
5193 }
5194 GeneratedField::HostAddr => {
5195 if host_addr__.is_some() {
5196 return Err(serde::de::Error::duplicate_field("hostAddr"));
5197 }
5198 host_addr__ = map_.next_value()?;
5199 }
5200 GeneratedField::PanicInfo => {
5201 if panic_info__.is_some() {
5202 return Err(serde::de::Error::duplicate_field("panicInfo"));
5203 }
5204 panic_info__ = Some(map_.next_value()?);
5205 }
5206 }
5207 }
5208 Ok(event_log::EventWorkerNodePanic {
5209 worker_id: worker_id__.unwrap_or_default(),
5210 worker_type: worker_type__.unwrap_or_default(),
5211 host_addr: host_addr__,
5212 panic_info: panic_info__.unwrap_or_default(),
5213 })
5214 }
5215 }
5216 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
5217 }
5218}
5219impl serde::Serialize for FlushRequest {
5220 #[allow(deprecated)]
5221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5222 where
5223 S: serde::Serializer,
5224 {
5225 use serde::ser::SerializeStruct;
5226 let mut len = 0;
5227 if self.database_id != 0 {
5228 len += 1;
5229 }
5230 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
5231 if self.database_id != 0 {
5232 struct_ser.serialize_field("databaseId", &self.database_id)?;
5233 }
5234 struct_ser.end()
5235 }
5236}
5237impl<'de> serde::Deserialize<'de> for FlushRequest {
5238 #[allow(deprecated)]
5239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5240 where
5241 D: serde::Deserializer<'de>,
5242 {
5243 const FIELDS: &[&str] = &[
5244 "database_id",
5245 "databaseId",
5246 ];
5247
5248 #[allow(clippy::enum_variant_names)]
5249 enum GeneratedField {
5250 DatabaseId,
5251 }
5252 impl<'de> serde::Deserialize<'de> for GeneratedField {
5253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5254 where
5255 D: serde::Deserializer<'de>,
5256 {
5257 struct GeneratedVisitor;
5258
5259 impl serde::de::Visitor<'_> for GeneratedVisitor {
5260 type Value = GeneratedField;
5261
5262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5263 write!(formatter, "expected one of: {:?}", &FIELDS)
5264 }
5265
5266 #[allow(unused_variables)]
5267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5268 where
5269 E: serde::de::Error,
5270 {
5271 match value {
5272 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5273 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5274 }
5275 }
5276 }
5277 deserializer.deserialize_identifier(GeneratedVisitor)
5278 }
5279 }
5280 struct GeneratedVisitor;
5281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5282 type Value = FlushRequest;
5283
5284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5285 formatter.write_str("struct meta.FlushRequest")
5286 }
5287
5288 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5289 where
5290 V: serde::de::MapAccess<'de>,
5291 {
5292 let mut database_id__ = None;
5293 while let Some(k) = map_.next_key()? {
5294 match k {
5295 GeneratedField::DatabaseId => {
5296 if database_id__.is_some() {
5297 return Err(serde::de::Error::duplicate_field("databaseId"));
5298 }
5299 database_id__ =
5300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5301 ;
5302 }
5303 }
5304 }
5305 Ok(FlushRequest {
5306 database_id: database_id__.unwrap_or_default(),
5307 })
5308 }
5309 }
5310 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5311 }
5312}
5313impl serde::Serialize for FlushResponse {
5314 #[allow(deprecated)]
5315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5316 where
5317 S: serde::Serializer,
5318 {
5319 use serde::ser::SerializeStruct;
5320 let mut len = 0;
5321 if self.status.is_some() {
5322 len += 1;
5323 }
5324 if self.hummock_version_id != 0 {
5325 len += 1;
5326 }
5327 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5328 if let Some(v) = self.status.as_ref() {
5329 struct_ser.serialize_field("status", v)?;
5330 }
5331 if self.hummock_version_id != 0 {
5332 #[allow(clippy::needless_borrow)]
5333 #[allow(clippy::needless_borrows_for_generic_args)]
5334 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5335 }
5336 struct_ser.end()
5337 }
5338}
5339impl<'de> serde::Deserialize<'de> for FlushResponse {
5340 #[allow(deprecated)]
5341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5342 where
5343 D: serde::Deserializer<'de>,
5344 {
5345 const FIELDS: &[&str] = &[
5346 "status",
5347 "hummock_version_id",
5348 "hummockVersionId",
5349 ];
5350
5351 #[allow(clippy::enum_variant_names)]
5352 enum GeneratedField {
5353 Status,
5354 HummockVersionId,
5355 }
5356 impl<'de> serde::Deserialize<'de> for GeneratedField {
5357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5358 where
5359 D: serde::Deserializer<'de>,
5360 {
5361 struct GeneratedVisitor;
5362
5363 impl serde::de::Visitor<'_> for GeneratedVisitor {
5364 type Value = GeneratedField;
5365
5366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5367 write!(formatter, "expected one of: {:?}", &FIELDS)
5368 }
5369
5370 #[allow(unused_variables)]
5371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5372 where
5373 E: serde::de::Error,
5374 {
5375 match value {
5376 "status" => Ok(GeneratedField::Status),
5377 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5379 }
5380 }
5381 }
5382 deserializer.deserialize_identifier(GeneratedVisitor)
5383 }
5384 }
5385 struct GeneratedVisitor;
5386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5387 type Value = FlushResponse;
5388
5389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5390 formatter.write_str("struct meta.FlushResponse")
5391 }
5392
5393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5394 where
5395 V: serde::de::MapAccess<'de>,
5396 {
5397 let mut status__ = None;
5398 let mut hummock_version_id__ = None;
5399 while let Some(k) = map_.next_key()? {
5400 match k {
5401 GeneratedField::Status => {
5402 if status__.is_some() {
5403 return Err(serde::de::Error::duplicate_field("status"));
5404 }
5405 status__ = map_.next_value()?;
5406 }
5407 GeneratedField::HummockVersionId => {
5408 if hummock_version_id__.is_some() {
5409 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5410 }
5411 hummock_version_id__ =
5412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5413 ;
5414 }
5415 }
5416 }
5417 Ok(FlushResponse {
5418 status: status__,
5419 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5420 })
5421 }
5422 }
5423 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5424 }
5425}
5426impl serde::Serialize for FragmentDistribution {
5427 #[allow(deprecated)]
5428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5429 where
5430 S: serde::Serializer,
5431 {
5432 use serde::ser::SerializeStruct;
5433 let mut len = 0;
5434 if self.fragment_id != 0 {
5435 len += 1;
5436 }
5437 if self.table_id != 0 {
5438 len += 1;
5439 }
5440 if self.distribution_type != 0 {
5441 len += 1;
5442 }
5443 if !self.state_table_ids.is_empty() {
5444 len += 1;
5445 }
5446 if !self.upstream_fragment_ids.is_empty() {
5447 len += 1;
5448 }
5449 if self.fragment_type_mask != 0 {
5450 len += 1;
5451 }
5452 if self.parallelism != 0 {
5453 len += 1;
5454 }
5455 if self.vnode_count != 0 {
5456 len += 1;
5457 }
5458 if self.node.is_some() {
5459 len += 1;
5460 }
5461 if !self.parallelism_policy.is_empty() {
5462 len += 1;
5463 }
5464 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5465 if self.fragment_id != 0 {
5466 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5467 }
5468 if self.table_id != 0 {
5469 struct_ser.serialize_field("tableId", &self.table_id)?;
5470 }
5471 if self.distribution_type != 0 {
5472 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5473 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5474 struct_ser.serialize_field("distributionType", &v)?;
5475 }
5476 if !self.state_table_ids.is_empty() {
5477 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5478 }
5479 if !self.upstream_fragment_ids.is_empty() {
5480 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5481 }
5482 if self.fragment_type_mask != 0 {
5483 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5484 }
5485 if self.parallelism != 0 {
5486 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5487 }
5488 if self.vnode_count != 0 {
5489 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5490 }
5491 if let Some(v) = self.node.as_ref() {
5492 struct_ser.serialize_field("node", v)?;
5493 }
5494 if !self.parallelism_policy.is_empty() {
5495 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5496 }
5497 struct_ser.end()
5498 }
5499}
5500impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5501 #[allow(deprecated)]
5502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5503 where
5504 D: serde::Deserializer<'de>,
5505 {
5506 const FIELDS: &[&str] = &[
5507 "fragment_id",
5508 "fragmentId",
5509 "table_id",
5510 "tableId",
5511 "distribution_type",
5512 "distributionType",
5513 "state_table_ids",
5514 "stateTableIds",
5515 "upstream_fragment_ids",
5516 "upstreamFragmentIds",
5517 "fragment_type_mask",
5518 "fragmentTypeMask",
5519 "parallelism",
5520 "vnode_count",
5521 "vnodeCount",
5522 "node",
5523 "parallelism_policy",
5524 "parallelismPolicy",
5525 ];
5526
5527 #[allow(clippy::enum_variant_names)]
5528 enum GeneratedField {
5529 FragmentId,
5530 TableId,
5531 DistributionType,
5532 StateTableIds,
5533 UpstreamFragmentIds,
5534 FragmentTypeMask,
5535 Parallelism,
5536 VnodeCount,
5537 Node,
5538 ParallelismPolicy,
5539 }
5540 impl<'de> serde::Deserialize<'de> for GeneratedField {
5541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5542 where
5543 D: serde::Deserializer<'de>,
5544 {
5545 struct GeneratedVisitor;
5546
5547 impl serde::de::Visitor<'_> for GeneratedVisitor {
5548 type Value = GeneratedField;
5549
5550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5551 write!(formatter, "expected one of: {:?}", &FIELDS)
5552 }
5553
5554 #[allow(unused_variables)]
5555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5556 where
5557 E: serde::de::Error,
5558 {
5559 match value {
5560 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5561 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5562 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5563 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5564 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5565 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5566 "parallelism" => Ok(GeneratedField::Parallelism),
5567 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5568 "node" => Ok(GeneratedField::Node),
5569 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5570 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5571 }
5572 }
5573 }
5574 deserializer.deserialize_identifier(GeneratedVisitor)
5575 }
5576 }
5577 struct GeneratedVisitor;
5578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5579 type Value = FragmentDistribution;
5580
5581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5582 formatter.write_str("struct meta.FragmentDistribution")
5583 }
5584
5585 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5586 where
5587 V: serde::de::MapAccess<'de>,
5588 {
5589 let mut fragment_id__ = None;
5590 let mut table_id__ = None;
5591 let mut distribution_type__ = None;
5592 let mut state_table_ids__ = None;
5593 let mut upstream_fragment_ids__ = None;
5594 let mut fragment_type_mask__ = None;
5595 let mut parallelism__ = None;
5596 let mut vnode_count__ = None;
5597 let mut node__ = None;
5598 let mut parallelism_policy__ = None;
5599 while let Some(k) = map_.next_key()? {
5600 match k {
5601 GeneratedField::FragmentId => {
5602 if fragment_id__.is_some() {
5603 return Err(serde::de::Error::duplicate_field("fragmentId"));
5604 }
5605 fragment_id__ =
5606 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5607 ;
5608 }
5609 GeneratedField::TableId => {
5610 if table_id__.is_some() {
5611 return Err(serde::de::Error::duplicate_field("tableId"));
5612 }
5613 table_id__ =
5614 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5615 ;
5616 }
5617 GeneratedField::DistributionType => {
5618 if distribution_type__.is_some() {
5619 return Err(serde::de::Error::duplicate_field("distributionType"));
5620 }
5621 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5622 }
5623 GeneratedField::StateTableIds => {
5624 if state_table_ids__.is_some() {
5625 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5626 }
5627 state_table_ids__ =
5628 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5629 .into_iter().map(|x| x.0).collect())
5630 ;
5631 }
5632 GeneratedField::UpstreamFragmentIds => {
5633 if upstream_fragment_ids__.is_some() {
5634 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5635 }
5636 upstream_fragment_ids__ =
5637 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5638 .into_iter().map(|x| x.0).collect())
5639 ;
5640 }
5641 GeneratedField::FragmentTypeMask => {
5642 if fragment_type_mask__.is_some() {
5643 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5644 }
5645 fragment_type_mask__ =
5646 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5647 ;
5648 }
5649 GeneratedField::Parallelism => {
5650 if parallelism__.is_some() {
5651 return Err(serde::de::Error::duplicate_field("parallelism"));
5652 }
5653 parallelism__ =
5654 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5655 ;
5656 }
5657 GeneratedField::VnodeCount => {
5658 if vnode_count__.is_some() {
5659 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5660 }
5661 vnode_count__ =
5662 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5663 ;
5664 }
5665 GeneratedField::Node => {
5666 if node__.is_some() {
5667 return Err(serde::de::Error::duplicate_field("node"));
5668 }
5669 node__ = map_.next_value()?;
5670 }
5671 GeneratedField::ParallelismPolicy => {
5672 if parallelism_policy__.is_some() {
5673 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5674 }
5675 parallelism_policy__ = Some(map_.next_value()?);
5676 }
5677 }
5678 }
5679 Ok(FragmentDistribution {
5680 fragment_id: fragment_id__.unwrap_or_default(),
5681 table_id: table_id__.unwrap_or_default(),
5682 distribution_type: distribution_type__.unwrap_or_default(),
5683 state_table_ids: state_table_ids__.unwrap_or_default(),
5684 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5685 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5686 parallelism: parallelism__.unwrap_or_default(),
5687 vnode_count: vnode_count__.unwrap_or_default(),
5688 node: node__,
5689 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5690 })
5691 }
5692 }
5693 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5694 }
5695}
5696impl serde::Serialize for FragmentIdToActorIdMap {
5697 #[allow(deprecated)]
5698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5699 where
5700 S: serde::Serializer,
5701 {
5702 use serde::ser::SerializeStruct;
5703 let mut len = 0;
5704 if !self.map.is_empty() {
5705 len += 1;
5706 }
5707 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5708 if !self.map.is_empty() {
5709 struct_ser.serialize_field("map", &self.map)?;
5710 }
5711 struct_ser.end()
5712 }
5713}
5714impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5715 #[allow(deprecated)]
5716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5717 where
5718 D: serde::Deserializer<'de>,
5719 {
5720 const FIELDS: &[&str] = &[
5721 "map",
5722 ];
5723
5724 #[allow(clippy::enum_variant_names)]
5725 enum GeneratedField {
5726 Map,
5727 }
5728 impl<'de> serde::Deserialize<'de> for GeneratedField {
5729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5730 where
5731 D: serde::Deserializer<'de>,
5732 {
5733 struct GeneratedVisitor;
5734
5735 impl serde::de::Visitor<'_> for GeneratedVisitor {
5736 type Value = GeneratedField;
5737
5738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5739 write!(formatter, "expected one of: {:?}", &FIELDS)
5740 }
5741
5742 #[allow(unused_variables)]
5743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5744 where
5745 E: serde::de::Error,
5746 {
5747 match value {
5748 "map" => Ok(GeneratedField::Map),
5749 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5750 }
5751 }
5752 }
5753 deserializer.deserialize_identifier(GeneratedVisitor)
5754 }
5755 }
5756 struct GeneratedVisitor;
5757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5758 type Value = FragmentIdToActorIdMap;
5759
5760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5761 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5762 }
5763
5764 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5765 where
5766 V: serde::de::MapAccess<'de>,
5767 {
5768 let mut map__ = None;
5769 while let Some(k) = map_.next_key()? {
5770 match k {
5771 GeneratedField::Map => {
5772 if map__.is_some() {
5773 return Err(serde::de::Error::duplicate_field("map"));
5774 }
5775 map__ = Some(
5776 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5777 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5778 );
5779 }
5780 }
5781 }
5782 Ok(FragmentIdToActorIdMap {
5783 map: map__.unwrap_or_default(),
5784 })
5785 }
5786 }
5787 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5788 }
5789}
5790impl serde::Serialize for FragmentToRelationMap {
5791 #[allow(deprecated)]
5792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5793 where
5794 S: serde::Serializer,
5795 {
5796 use serde::ser::SerializeStruct;
5797 let mut len = 0;
5798 if !self.fragment_to_relation_map.is_empty() {
5799 len += 1;
5800 }
5801 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5802 if !self.fragment_to_relation_map.is_empty() {
5803 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5804 }
5805 struct_ser.end()
5806 }
5807}
5808impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5809 #[allow(deprecated)]
5810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5811 where
5812 D: serde::Deserializer<'de>,
5813 {
5814 const FIELDS: &[&str] = &[
5815 "fragment_to_relation_map",
5816 "fragmentToRelationMap",
5817 ];
5818
5819 #[allow(clippy::enum_variant_names)]
5820 enum GeneratedField {
5821 FragmentToRelationMap,
5822 }
5823 impl<'de> serde::Deserialize<'de> for GeneratedField {
5824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5825 where
5826 D: serde::Deserializer<'de>,
5827 {
5828 struct GeneratedVisitor;
5829
5830 impl serde::de::Visitor<'_> for GeneratedVisitor {
5831 type Value = GeneratedField;
5832
5833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5834 write!(formatter, "expected one of: {:?}", &FIELDS)
5835 }
5836
5837 #[allow(unused_variables)]
5838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5839 where
5840 E: serde::de::Error,
5841 {
5842 match value {
5843 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5844 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5845 }
5846 }
5847 }
5848 deserializer.deserialize_identifier(GeneratedVisitor)
5849 }
5850 }
5851 struct GeneratedVisitor;
5852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5853 type Value = FragmentToRelationMap;
5854
5855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5856 formatter.write_str("struct meta.FragmentToRelationMap")
5857 }
5858
5859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5860 where
5861 V: serde::de::MapAccess<'de>,
5862 {
5863 let mut fragment_to_relation_map__ = None;
5864 while let Some(k) = map_.next_key()? {
5865 match k {
5866 GeneratedField::FragmentToRelationMap => {
5867 if fragment_to_relation_map__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5869 }
5870 fragment_to_relation_map__ = Some(
5871 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5872 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
5873 );
5874 }
5875 }
5876 }
5877 Ok(FragmentToRelationMap {
5878 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5879 })
5880 }
5881 }
5882 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5883 }
5884}
5885impl serde::Serialize for FragmentWorkerSlotMapping {
5886 #[allow(deprecated)]
5887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5888 where
5889 S: serde::Serializer,
5890 {
5891 use serde::ser::SerializeStruct;
5892 let mut len = 0;
5893 if self.fragment_id != 0 {
5894 len += 1;
5895 }
5896 if self.mapping.is_some() {
5897 len += 1;
5898 }
5899 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5900 if self.fragment_id != 0 {
5901 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5902 }
5903 if let Some(v) = self.mapping.as_ref() {
5904 struct_ser.serialize_field("mapping", v)?;
5905 }
5906 struct_ser.end()
5907 }
5908}
5909impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5910 #[allow(deprecated)]
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 const FIELDS: &[&str] = &[
5916 "fragment_id",
5917 "fragmentId",
5918 "mapping",
5919 ];
5920
5921 #[allow(clippy::enum_variant_names)]
5922 enum GeneratedField {
5923 FragmentId,
5924 Mapping,
5925 }
5926 impl<'de> serde::Deserialize<'de> for GeneratedField {
5927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5928 where
5929 D: serde::Deserializer<'de>,
5930 {
5931 struct GeneratedVisitor;
5932
5933 impl serde::de::Visitor<'_> for GeneratedVisitor {
5934 type Value = GeneratedField;
5935
5936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5937 write!(formatter, "expected one of: {:?}", &FIELDS)
5938 }
5939
5940 #[allow(unused_variables)]
5941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5942 where
5943 E: serde::de::Error,
5944 {
5945 match value {
5946 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5947 "mapping" => Ok(GeneratedField::Mapping),
5948 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5949 }
5950 }
5951 }
5952 deserializer.deserialize_identifier(GeneratedVisitor)
5953 }
5954 }
5955 struct GeneratedVisitor;
5956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5957 type Value = FragmentWorkerSlotMapping;
5958
5959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5960 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5961 }
5962
5963 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5964 where
5965 V: serde::de::MapAccess<'de>,
5966 {
5967 let mut fragment_id__ = None;
5968 let mut mapping__ = None;
5969 while let Some(k) = map_.next_key()? {
5970 match k {
5971 GeneratedField::FragmentId => {
5972 if fragment_id__.is_some() {
5973 return Err(serde::de::Error::duplicate_field("fragmentId"));
5974 }
5975 fragment_id__ =
5976 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5977 ;
5978 }
5979 GeneratedField::Mapping => {
5980 if mapping__.is_some() {
5981 return Err(serde::de::Error::duplicate_field("mapping"));
5982 }
5983 mapping__ = map_.next_value()?;
5984 }
5985 }
5986 }
5987 Ok(FragmentWorkerSlotMapping {
5988 fragment_id: fragment_id__.unwrap_or_default(),
5989 mapping: mapping__,
5990 })
5991 }
5992 }
5993 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5994 }
5995}
5996impl serde::Serialize for FragmentWorkerSlotMappings {
5997 #[allow(deprecated)]
5998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5999 where
6000 S: serde::Serializer,
6001 {
6002 use serde::ser::SerializeStruct;
6003 let mut len = 0;
6004 if !self.mappings.is_empty() {
6005 len += 1;
6006 }
6007 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
6008 if !self.mappings.is_empty() {
6009 struct_ser.serialize_field("mappings", &self.mappings)?;
6010 }
6011 struct_ser.end()
6012 }
6013}
6014impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
6015 #[allow(deprecated)]
6016 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6017 where
6018 D: serde::Deserializer<'de>,
6019 {
6020 const FIELDS: &[&str] = &[
6021 "mappings",
6022 ];
6023
6024 #[allow(clippy::enum_variant_names)]
6025 enum GeneratedField {
6026 Mappings,
6027 }
6028 impl<'de> serde::Deserialize<'de> for GeneratedField {
6029 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6030 where
6031 D: serde::Deserializer<'de>,
6032 {
6033 struct GeneratedVisitor;
6034
6035 impl serde::de::Visitor<'_> for GeneratedVisitor {
6036 type Value = GeneratedField;
6037
6038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6039 write!(formatter, "expected one of: {:?}", &FIELDS)
6040 }
6041
6042 #[allow(unused_variables)]
6043 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6044 where
6045 E: serde::de::Error,
6046 {
6047 match value {
6048 "mappings" => Ok(GeneratedField::Mappings),
6049 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6050 }
6051 }
6052 }
6053 deserializer.deserialize_identifier(GeneratedVisitor)
6054 }
6055 }
6056 struct GeneratedVisitor;
6057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6058 type Value = FragmentWorkerSlotMappings;
6059
6060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6061 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
6062 }
6063
6064 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
6065 where
6066 V: serde::de::MapAccess<'de>,
6067 {
6068 let mut mappings__ = None;
6069 while let Some(k) = map_.next_key()? {
6070 match k {
6071 GeneratedField::Mappings => {
6072 if mappings__.is_some() {
6073 return Err(serde::de::Error::duplicate_field("mappings"));
6074 }
6075 mappings__ = Some(map_.next_value()?);
6076 }
6077 }
6078 }
6079 Ok(FragmentWorkerSlotMappings {
6080 mappings: mappings__.unwrap_or_default(),
6081 })
6082 }
6083 }
6084 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
6085 }
6086}
6087impl serde::Serialize for GetActorVnodesRequest {
6088 #[allow(deprecated)]
6089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6090 where
6091 S: serde::Serializer,
6092 {
6093 use serde::ser::SerializeStruct;
6094 let mut len = 0;
6095 if self.actor_id != 0 {
6096 len += 1;
6097 }
6098 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
6099 if self.actor_id != 0 {
6100 struct_ser.serialize_field("actorId", &self.actor_id)?;
6101 }
6102 struct_ser.end()
6103 }
6104}
6105impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
6106 #[allow(deprecated)]
6107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6108 where
6109 D: serde::Deserializer<'de>,
6110 {
6111 const FIELDS: &[&str] = &[
6112 "actor_id",
6113 "actorId",
6114 ];
6115
6116 #[allow(clippy::enum_variant_names)]
6117 enum GeneratedField {
6118 ActorId,
6119 }
6120 impl<'de> serde::Deserialize<'de> for GeneratedField {
6121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6122 where
6123 D: serde::Deserializer<'de>,
6124 {
6125 struct GeneratedVisitor;
6126
6127 impl serde::de::Visitor<'_> for GeneratedVisitor {
6128 type Value = GeneratedField;
6129
6130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6131 write!(formatter, "expected one of: {:?}", &FIELDS)
6132 }
6133
6134 #[allow(unused_variables)]
6135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6136 where
6137 E: serde::de::Error,
6138 {
6139 match value {
6140 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
6141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6142 }
6143 }
6144 }
6145 deserializer.deserialize_identifier(GeneratedVisitor)
6146 }
6147 }
6148 struct GeneratedVisitor;
6149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6150 type Value = GetActorVnodesRequest;
6151
6152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6153 formatter.write_str("struct meta.GetActorVnodesRequest")
6154 }
6155
6156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
6157 where
6158 V: serde::de::MapAccess<'de>,
6159 {
6160 let mut actor_id__ = None;
6161 while let Some(k) = map_.next_key()? {
6162 match k {
6163 GeneratedField::ActorId => {
6164 if actor_id__.is_some() {
6165 return Err(serde::de::Error::duplicate_field("actorId"));
6166 }
6167 actor_id__ =
6168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6169 ;
6170 }
6171 }
6172 }
6173 Ok(GetActorVnodesRequest {
6174 actor_id: actor_id__.unwrap_or_default(),
6175 })
6176 }
6177 }
6178 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
6179 }
6180}
6181impl serde::Serialize for GetActorVnodesResponse {
6182 #[allow(deprecated)]
6183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6184 where
6185 S: serde::Serializer,
6186 {
6187 use serde::ser::SerializeStruct;
6188 let mut len = 0;
6189 if !self.vnode_indices.is_empty() {
6190 len += 1;
6191 }
6192 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
6193 if !self.vnode_indices.is_empty() {
6194 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6195 }
6196 struct_ser.end()
6197 }
6198}
6199impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
6200 #[allow(deprecated)]
6201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6202 where
6203 D: serde::Deserializer<'de>,
6204 {
6205 const FIELDS: &[&str] = &[
6206 "vnode_indices",
6207 "vnodeIndices",
6208 ];
6209
6210 #[allow(clippy::enum_variant_names)]
6211 enum GeneratedField {
6212 VnodeIndices,
6213 }
6214 impl<'de> serde::Deserialize<'de> for GeneratedField {
6215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6216 where
6217 D: serde::Deserializer<'de>,
6218 {
6219 struct GeneratedVisitor;
6220
6221 impl serde::de::Visitor<'_> for GeneratedVisitor {
6222 type Value = GeneratedField;
6223
6224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6225 write!(formatter, "expected one of: {:?}", &FIELDS)
6226 }
6227
6228 #[allow(unused_variables)]
6229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6230 where
6231 E: serde::de::Error,
6232 {
6233 match value {
6234 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
6235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6236 }
6237 }
6238 }
6239 deserializer.deserialize_identifier(GeneratedVisitor)
6240 }
6241 }
6242 struct GeneratedVisitor;
6243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6244 type Value = GetActorVnodesResponse;
6245
6246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6247 formatter.write_str("struct meta.GetActorVnodesResponse")
6248 }
6249
6250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
6251 where
6252 V: serde::de::MapAccess<'de>,
6253 {
6254 let mut vnode_indices__ = None;
6255 while let Some(k) = map_.next_key()? {
6256 match k {
6257 GeneratedField::VnodeIndices => {
6258 if vnode_indices__.is_some() {
6259 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
6260 }
6261 vnode_indices__ =
6262 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6263 .into_iter().map(|x| x.0).collect())
6264 ;
6265 }
6266 }
6267 }
6268 Ok(GetActorVnodesResponse {
6269 vnode_indices: vnode_indices__.unwrap_or_default(),
6270 })
6271 }
6272 }
6273 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6274 }
6275}
6276impl serde::Serialize for GetClusterInfoRequest {
6277 #[allow(deprecated)]
6278 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6279 where
6280 S: serde::Serializer,
6281 {
6282 use serde::ser::SerializeStruct;
6283 let len = 0;
6284 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6285 struct_ser.end()
6286 }
6287}
6288impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6289 #[allow(deprecated)]
6290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6291 where
6292 D: serde::Deserializer<'de>,
6293 {
6294 const FIELDS: &[&str] = &[
6295 ];
6296
6297 #[allow(clippy::enum_variant_names)]
6298 enum GeneratedField {
6299 }
6300 impl<'de> serde::Deserialize<'de> for GeneratedField {
6301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6302 where
6303 D: serde::Deserializer<'de>,
6304 {
6305 struct GeneratedVisitor;
6306
6307 impl serde::de::Visitor<'_> for GeneratedVisitor {
6308 type Value = GeneratedField;
6309
6310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6311 write!(formatter, "expected one of: {:?}", &FIELDS)
6312 }
6313
6314 #[allow(unused_variables)]
6315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6316 where
6317 E: serde::de::Error,
6318 {
6319 Err(serde::de::Error::unknown_field(value, FIELDS))
6320 }
6321 }
6322 deserializer.deserialize_identifier(GeneratedVisitor)
6323 }
6324 }
6325 struct GeneratedVisitor;
6326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6327 type Value = GetClusterInfoRequest;
6328
6329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6330 formatter.write_str("struct meta.GetClusterInfoRequest")
6331 }
6332
6333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6334 where
6335 V: serde::de::MapAccess<'de>,
6336 {
6337 while map_.next_key::<GeneratedField>()?.is_some() {
6338 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6339 }
6340 Ok(GetClusterInfoRequest {
6341 })
6342 }
6343 }
6344 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6345 }
6346}
6347impl serde::Serialize for GetClusterInfoResponse {
6348 #[allow(deprecated)]
6349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6350 where
6351 S: serde::Serializer,
6352 {
6353 use serde::ser::SerializeStruct;
6354 let mut len = 0;
6355 if !self.worker_nodes.is_empty() {
6356 len += 1;
6357 }
6358 if !self.table_fragments.is_empty() {
6359 len += 1;
6360 }
6361 if !self.actor_splits.is_empty() {
6362 len += 1;
6363 }
6364 if !self.source_infos.is_empty() {
6365 len += 1;
6366 }
6367 if self.revision != 0 {
6368 len += 1;
6369 }
6370 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6371 if !self.worker_nodes.is_empty() {
6372 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6373 }
6374 if !self.table_fragments.is_empty() {
6375 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6376 }
6377 if !self.actor_splits.is_empty() {
6378 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6379 }
6380 if !self.source_infos.is_empty() {
6381 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6382 }
6383 if self.revision != 0 {
6384 #[allow(clippy::needless_borrow)]
6385 #[allow(clippy::needless_borrows_for_generic_args)]
6386 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6387 }
6388 struct_ser.end()
6389 }
6390}
6391impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6392 #[allow(deprecated)]
6393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6394 where
6395 D: serde::Deserializer<'de>,
6396 {
6397 const FIELDS: &[&str] = &[
6398 "worker_nodes",
6399 "workerNodes",
6400 "table_fragments",
6401 "tableFragments",
6402 "actor_splits",
6403 "actorSplits",
6404 "source_infos",
6405 "sourceInfos",
6406 "revision",
6407 ];
6408
6409 #[allow(clippy::enum_variant_names)]
6410 enum GeneratedField {
6411 WorkerNodes,
6412 TableFragments,
6413 ActorSplits,
6414 SourceInfos,
6415 Revision,
6416 }
6417 impl<'de> serde::Deserialize<'de> for GeneratedField {
6418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6419 where
6420 D: serde::Deserializer<'de>,
6421 {
6422 struct GeneratedVisitor;
6423
6424 impl serde::de::Visitor<'_> for GeneratedVisitor {
6425 type Value = GeneratedField;
6426
6427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6428 write!(formatter, "expected one of: {:?}", &FIELDS)
6429 }
6430
6431 #[allow(unused_variables)]
6432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6433 where
6434 E: serde::de::Error,
6435 {
6436 match value {
6437 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6438 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6439 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6440 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6441 "revision" => Ok(GeneratedField::Revision),
6442 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6443 }
6444 }
6445 }
6446 deserializer.deserialize_identifier(GeneratedVisitor)
6447 }
6448 }
6449 struct GeneratedVisitor;
6450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6451 type Value = GetClusterInfoResponse;
6452
6453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6454 formatter.write_str("struct meta.GetClusterInfoResponse")
6455 }
6456
6457 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6458 where
6459 V: serde::de::MapAccess<'de>,
6460 {
6461 let mut worker_nodes__ = None;
6462 let mut table_fragments__ = None;
6463 let mut actor_splits__ = None;
6464 let mut source_infos__ = None;
6465 let mut revision__ = None;
6466 while let Some(k) = map_.next_key()? {
6467 match k {
6468 GeneratedField::WorkerNodes => {
6469 if worker_nodes__.is_some() {
6470 return Err(serde::de::Error::duplicate_field("workerNodes"));
6471 }
6472 worker_nodes__ = Some(map_.next_value()?);
6473 }
6474 GeneratedField::TableFragments => {
6475 if table_fragments__.is_some() {
6476 return Err(serde::de::Error::duplicate_field("tableFragments"));
6477 }
6478 table_fragments__ = Some(map_.next_value()?);
6479 }
6480 GeneratedField::ActorSplits => {
6481 if actor_splits__.is_some() {
6482 return Err(serde::de::Error::duplicate_field("actorSplits"));
6483 }
6484 actor_splits__ = Some(
6485 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6486 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6487 );
6488 }
6489 GeneratedField::SourceInfos => {
6490 if source_infos__.is_some() {
6491 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6492 }
6493 source_infos__ = Some(
6494 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6495 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6496 );
6497 }
6498 GeneratedField::Revision => {
6499 if revision__.is_some() {
6500 return Err(serde::de::Error::duplicate_field("revision"));
6501 }
6502 revision__ =
6503 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6504 ;
6505 }
6506 }
6507 }
6508 Ok(GetClusterInfoResponse {
6509 worker_nodes: worker_nodes__.unwrap_or_default(),
6510 table_fragments: table_fragments__.unwrap_or_default(),
6511 actor_splits: actor_splits__.unwrap_or_default(),
6512 source_infos: source_infos__.unwrap_or_default(),
6513 revision: revision__.unwrap_or_default(),
6514 })
6515 }
6516 }
6517 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6518 }
6519}
6520impl serde::Serialize for GetClusterLimitsRequest {
6521 #[allow(deprecated)]
6522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6523 where
6524 S: serde::Serializer,
6525 {
6526 use serde::ser::SerializeStruct;
6527 let len = 0;
6528 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6529 struct_ser.end()
6530 }
6531}
6532impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6533 #[allow(deprecated)]
6534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6535 where
6536 D: serde::Deserializer<'de>,
6537 {
6538 const FIELDS: &[&str] = &[
6539 ];
6540
6541 #[allow(clippy::enum_variant_names)]
6542 enum GeneratedField {
6543 }
6544 impl<'de> serde::Deserialize<'de> for GeneratedField {
6545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6546 where
6547 D: serde::Deserializer<'de>,
6548 {
6549 struct GeneratedVisitor;
6550
6551 impl serde::de::Visitor<'_> for GeneratedVisitor {
6552 type Value = GeneratedField;
6553
6554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6555 write!(formatter, "expected one of: {:?}", &FIELDS)
6556 }
6557
6558 #[allow(unused_variables)]
6559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6560 where
6561 E: serde::de::Error,
6562 {
6563 Err(serde::de::Error::unknown_field(value, FIELDS))
6564 }
6565 }
6566 deserializer.deserialize_identifier(GeneratedVisitor)
6567 }
6568 }
6569 struct GeneratedVisitor;
6570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6571 type Value = GetClusterLimitsRequest;
6572
6573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6574 formatter.write_str("struct meta.GetClusterLimitsRequest")
6575 }
6576
6577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6578 where
6579 V: serde::de::MapAccess<'de>,
6580 {
6581 while map_.next_key::<GeneratedField>()?.is_some() {
6582 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6583 }
6584 Ok(GetClusterLimitsRequest {
6585 })
6586 }
6587 }
6588 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6589 }
6590}
6591impl serde::Serialize for GetClusterLimitsResponse {
6592 #[allow(deprecated)]
6593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6594 where
6595 S: serde::Serializer,
6596 {
6597 use serde::ser::SerializeStruct;
6598 let mut len = 0;
6599 if !self.active_limits.is_empty() {
6600 len += 1;
6601 }
6602 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6603 if !self.active_limits.is_empty() {
6604 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6605 }
6606 struct_ser.end()
6607 }
6608}
6609impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6610 #[allow(deprecated)]
6611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6612 where
6613 D: serde::Deserializer<'de>,
6614 {
6615 const FIELDS: &[&str] = &[
6616 "active_limits",
6617 "activeLimits",
6618 ];
6619
6620 #[allow(clippy::enum_variant_names)]
6621 enum GeneratedField {
6622 ActiveLimits,
6623 }
6624 impl<'de> serde::Deserialize<'de> for GeneratedField {
6625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6626 where
6627 D: serde::Deserializer<'de>,
6628 {
6629 struct GeneratedVisitor;
6630
6631 impl serde::de::Visitor<'_> for GeneratedVisitor {
6632 type Value = GeneratedField;
6633
6634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6635 write!(formatter, "expected one of: {:?}", &FIELDS)
6636 }
6637
6638 #[allow(unused_variables)]
6639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6640 where
6641 E: serde::de::Error,
6642 {
6643 match value {
6644 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6646 }
6647 }
6648 }
6649 deserializer.deserialize_identifier(GeneratedVisitor)
6650 }
6651 }
6652 struct GeneratedVisitor;
6653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6654 type Value = GetClusterLimitsResponse;
6655
6656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6657 formatter.write_str("struct meta.GetClusterLimitsResponse")
6658 }
6659
6660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6661 where
6662 V: serde::de::MapAccess<'de>,
6663 {
6664 let mut active_limits__ = None;
6665 while let Some(k) = map_.next_key()? {
6666 match k {
6667 GeneratedField::ActiveLimits => {
6668 if active_limits__.is_some() {
6669 return Err(serde::de::Error::duplicate_field("activeLimits"));
6670 }
6671 active_limits__ = Some(map_.next_value()?);
6672 }
6673 }
6674 }
6675 Ok(GetClusterLimitsResponse {
6676 active_limits: active_limits__.unwrap_or_default(),
6677 })
6678 }
6679 }
6680 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6681 }
6682}
6683impl serde::Serialize for GetClusterRecoveryStatusRequest {
6684 #[allow(deprecated)]
6685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6686 where
6687 S: serde::Serializer,
6688 {
6689 use serde::ser::SerializeStruct;
6690 let len = 0;
6691 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6692 struct_ser.end()
6693 }
6694}
6695impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6696 #[allow(deprecated)]
6697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6698 where
6699 D: serde::Deserializer<'de>,
6700 {
6701 const FIELDS: &[&str] = &[
6702 ];
6703
6704 #[allow(clippy::enum_variant_names)]
6705 enum GeneratedField {
6706 }
6707 impl<'de> serde::Deserialize<'de> for GeneratedField {
6708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6709 where
6710 D: serde::Deserializer<'de>,
6711 {
6712 struct GeneratedVisitor;
6713
6714 impl serde::de::Visitor<'_> for GeneratedVisitor {
6715 type Value = GeneratedField;
6716
6717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6718 write!(formatter, "expected one of: {:?}", &FIELDS)
6719 }
6720
6721 #[allow(unused_variables)]
6722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6723 where
6724 E: serde::de::Error,
6725 {
6726 Err(serde::de::Error::unknown_field(value, FIELDS))
6727 }
6728 }
6729 deserializer.deserialize_identifier(GeneratedVisitor)
6730 }
6731 }
6732 struct GeneratedVisitor;
6733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6734 type Value = GetClusterRecoveryStatusRequest;
6735
6736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6737 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6738 }
6739
6740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6741 where
6742 V: serde::de::MapAccess<'de>,
6743 {
6744 while map_.next_key::<GeneratedField>()?.is_some() {
6745 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6746 }
6747 Ok(GetClusterRecoveryStatusRequest {
6748 })
6749 }
6750 }
6751 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6752 }
6753}
6754impl serde::Serialize for GetClusterRecoveryStatusResponse {
6755 #[allow(deprecated)]
6756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6757 where
6758 S: serde::Serializer,
6759 {
6760 use serde::ser::SerializeStruct;
6761 let mut len = 0;
6762 if self.status != 0 {
6763 len += 1;
6764 }
6765 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6766 if self.status != 0 {
6767 let v = RecoveryStatus::try_from(self.status)
6768 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6769 struct_ser.serialize_field("status", &v)?;
6770 }
6771 struct_ser.end()
6772 }
6773}
6774impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6775 #[allow(deprecated)]
6776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6777 where
6778 D: serde::Deserializer<'de>,
6779 {
6780 const FIELDS: &[&str] = &[
6781 "status",
6782 ];
6783
6784 #[allow(clippy::enum_variant_names)]
6785 enum GeneratedField {
6786 Status,
6787 }
6788 impl<'de> serde::Deserialize<'de> for GeneratedField {
6789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6790 where
6791 D: serde::Deserializer<'de>,
6792 {
6793 struct GeneratedVisitor;
6794
6795 impl serde::de::Visitor<'_> for GeneratedVisitor {
6796 type Value = GeneratedField;
6797
6798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6799 write!(formatter, "expected one of: {:?}", &FIELDS)
6800 }
6801
6802 #[allow(unused_variables)]
6803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6804 where
6805 E: serde::de::Error,
6806 {
6807 match value {
6808 "status" => Ok(GeneratedField::Status),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = GetClusterRecoveryStatusResponse;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut status__ = None;
6829 while let Some(k) = map_.next_key()? {
6830 match k {
6831 GeneratedField::Status => {
6832 if status__.is_some() {
6833 return Err(serde::de::Error::duplicate_field("status"));
6834 }
6835 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6836 }
6837 }
6838 }
6839 Ok(GetClusterRecoveryStatusResponse {
6840 status: status__.unwrap_or_default(),
6841 })
6842 }
6843 }
6844 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6845 }
6846}
6847impl serde::Serialize for GetFragmentByIdRequest {
6848 #[allow(deprecated)]
6849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6850 where
6851 S: serde::Serializer,
6852 {
6853 use serde::ser::SerializeStruct;
6854 let mut len = 0;
6855 if self.fragment_id != 0 {
6856 len += 1;
6857 }
6858 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6859 if self.fragment_id != 0 {
6860 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6861 }
6862 struct_ser.end()
6863 }
6864}
6865impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6866 #[allow(deprecated)]
6867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6868 where
6869 D: serde::Deserializer<'de>,
6870 {
6871 const FIELDS: &[&str] = &[
6872 "fragment_id",
6873 "fragmentId",
6874 ];
6875
6876 #[allow(clippy::enum_variant_names)]
6877 enum GeneratedField {
6878 FragmentId,
6879 }
6880 impl<'de> serde::Deserialize<'de> for GeneratedField {
6881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6882 where
6883 D: serde::Deserializer<'de>,
6884 {
6885 struct GeneratedVisitor;
6886
6887 impl serde::de::Visitor<'_> for GeneratedVisitor {
6888 type Value = GeneratedField;
6889
6890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6891 write!(formatter, "expected one of: {:?}", &FIELDS)
6892 }
6893
6894 #[allow(unused_variables)]
6895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6896 where
6897 E: serde::de::Error,
6898 {
6899 match value {
6900 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6902 }
6903 }
6904 }
6905 deserializer.deserialize_identifier(GeneratedVisitor)
6906 }
6907 }
6908 struct GeneratedVisitor;
6909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6910 type Value = GetFragmentByIdRequest;
6911
6912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6913 formatter.write_str("struct meta.GetFragmentByIdRequest")
6914 }
6915
6916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6917 where
6918 V: serde::de::MapAccess<'de>,
6919 {
6920 let mut fragment_id__ = None;
6921 while let Some(k) = map_.next_key()? {
6922 match k {
6923 GeneratedField::FragmentId => {
6924 if fragment_id__.is_some() {
6925 return Err(serde::de::Error::duplicate_field("fragmentId"));
6926 }
6927 fragment_id__ =
6928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6929 ;
6930 }
6931 }
6932 }
6933 Ok(GetFragmentByIdRequest {
6934 fragment_id: fragment_id__.unwrap_or_default(),
6935 })
6936 }
6937 }
6938 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6939 }
6940}
6941impl serde::Serialize for GetFragmentByIdResponse {
6942 #[allow(deprecated)]
6943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6944 where
6945 S: serde::Serializer,
6946 {
6947 use serde::ser::SerializeStruct;
6948 let mut len = 0;
6949 if self.distribution.is_some() {
6950 len += 1;
6951 }
6952 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6953 if let Some(v) = self.distribution.as_ref() {
6954 struct_ser.serialize_field("distribution", v)?;
6955 }
6956 struct_ser.end()
6957 }
6958}
6959impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6960 #[allow(deprecated)]
6961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6962 where
6963 D: serde::Deserializer<'de>,
6964 {
6965 const FIELDS: &[&str] = &[
6966 "distribution",
6967 ];
6968
6969 #[allow(clippy::enum_variant_names)]
6970 enum GeneratedField {
6971 Distribution,
6972 }
6973 impl<'de> serde::Deserialize<'de> for GeneratedField {
6974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6975 where
6976 D: serde::Deserializer<'de>,
6977 {
6978 struct GeneratedVisitor;
6979
6980 impl serde::de::Visitor<'_> for GeneratedVisitor {
6981 type Value = GeneratedField;
6982
6983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6984 write!(formatter, "expected one of: {:?}", &FIELDS)
6985 }
6986
6987 #[allow(unused_variables)]
6988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6989 where
6990 E: serde::de::Error,
6991 {
6992 match value {
6993 "distribution" => Ok(GeneratedField::Distribution),
6994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6995 }
6996 }
6997 }
6998 deserializer.deserialize_identifier(GeneratedVisitor)
6999 }
7000 }
7001 struct GeneratedVisitor;
7002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7003 type Value = GetFragmentByIdResponse;
7004
7005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7006 formatter.write_str("struct meta.GetFragmentByIdResponse")
7007 }
7008
7009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
7010 where
7011 V: serde::de::MapAccess<'de>,
7012 {
7013 let mut distribution__ = None;
7014 while let Some(k) = map_.next_key()? {
7015 match k {
7016 GeneratedField::Distribution => {
7017 if distribution__.is_some() {
7018 return Err(serde::de::Error::duplicate_field("distribution"));
7019 }
7020 distribution__ = map_.next_value()?;
7021 }
7022 }
7023 }
7024 Ok(GetFragmentByIdResponse {
7025 distribution: distribution__,
7026 })
7027 }
7028 }
7029 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
7030 }
7031}
7032impl serde::Serialize for GetFragmentVnodesRequest {
7033 #[allow(deprecated)]
7034 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7035 where
7036 S: serde::Serializer,
7037 {
7038 use serde::ser::SerializeStruct;
7039 let mut len = 0;
7040 if self.fragment_id != 0 {
7041 len += 1;
7042 }
7043 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
7044 if self.fragment_id != 0 {
7045 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7046 }
7047 struct_ser.end()
7048 }
7049}
7050impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
7051 #[allow(deprecated)]
7052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7053 where
7054 D: serde::Deserializer<'de>,
7055 {
7056 const FIELDS: &[&str] = &[
7057 "fragment_id",
7058 "fragmentId",
7059 ];
7060
7061 #[allow(clippy::enum_variant_names)]
7062 enum GeneratedField {
7063 FragmentId,
7064 }
7065 impl<'de> serde::Deserialize<'de> for GeneratedField {
7066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7067 where
7068 D: serde::Deserializer<'de>,
7069 {
7070 struct GeneratedVisitor;
7071
7072 impl serde::de::Visitor<'_> for GeneratedVisitor {
7073 type Value = GeneratedField;
7074
7075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7076 write!(formatter, "expected one of: {:?}", &FIELDS)
7077 }
7078
7079 #[allow(unused_variables)]
7080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7081 where
7082 E: serde::de::Error,
7083 {
7084 match value {
7085 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7086 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7087 }
7088 }
7089 }
7090 deserializer.deserialize_identifier(GeneratedVisitor)
7091 }
7092 }
7093 struct GeneratedVisitor;
7094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7095 type Value = GetFragmentVnodesRequest;
7096
7097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7098 formatter.write_str("struct meta.GetFragmentVnodesRequest")
7099 }
7100
7101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
7102 where
7103 V: serde::de::MapAccess<'de>,
7104 {
7105 let mut fragment_id__ = None;
7106 while let Some(k) = map_.next_key()? {
7107 match k {
7108 GeneratedField::FragmentId => {
7109 if fragment_id__.is_some() {
7110 return Err(serde::de::Error::duplicate_field("fragmentId"));
7111 }
7112 fragment_id__ =
7113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7114 ;
7115 }
7116 }
7117 }
7118 Ok(GetFragmentVnodesRequest {
7119 fragment_id: fragment_id__.unwrap_or_default(),
7120 })
7121 }
7122 }
7123 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
7124 }
7125}
7126impl serde::Serialize for GetFragmentVnodesResponse {
7127 #[allow(deprecated)]
7128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7129 where
7130 S: serde::Serializer,
7131 {
7132 use serde::ser::SerializeStruct;
7133 let mut len = 0;
7134 if !self.actor_vnodes.is_empty() {
7135 len += 1;
7136 }
7137 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
7138 if !self.actor_vnodes.is_empty() {
7139 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
7140 }
7141 struct_ser.end()
7142 }
7143}
7144impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
7145 #[allow(deprecated)]
7146 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7147 where
7148 D: serde::Deserializer<'de>,
7149 {
7150 const FIELDS: &[&str] = &[
7151 "actor_vnodes",
7152 "actorVnodes",
7153 ];
7154
7155 #[allow(clippy::enum_variant_names)]
7156 enum GeneratedField {
7157 ActorVnodes,
7158 }
7159 impl<'de> serde::Deserialize<'de> for GeneratedField {
7160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7161 where
7162 D: serde::Deserializer<'de>,
7163 {
7164 struct GeneratedVisitor;
7165
7166 impl serde::de::Visitor<'_> for GeneratedVisitor {
7167 type Value = GeneratedField;
7168
7169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7170 write!(formatter, "expected one of: {:?}", &FIELDS)
7171 }
7172
7173 #[allow(unused_variables)]
7174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7175 where
7176 E: serde::de::Error,
7177 {
7178 match value {
7179 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
7180 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7181 }
7182 }
7183 }
7184 deserializer.deserialize_identifier(GeneratedVisitor)
7185 }
7186 }
7187 struct GeneratedVisitor;
7188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7189 type Value = GetFragmentVnodesResponse;
7190
7191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7192 formatter.write_str("struct meta.GetFragmentVnodesResponse")
7193 }
7194
7195 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
7196 where
7197 V: serde::de::MapAccess<'de>,
7198 {
7199 let mut actor_vnodes__ = None;
7200 while let Some(k) = map_.next_key()? {
7201 match k {
7202 GeneratedField::ActorVnodes => {
7203 if actor_vnodes__.is_some() {
7204 return Err(serde::de::Error::duplicate_field("actorVnodes"));
7205 }
7206 actor_vnodes__ = Some(map_.next_value()?);
7207 }
7208 }
7209 }
7210 Ok(GetFragmentVnodesResponse {
7211 actor_vnodes: actor_vnodes__.unwrap_or_default(),
7212 })
7213 }
7214 }
7215 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
7216 }
7217}
7218impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
7219 #[allow(deprecated)]
7220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7221 where
7222 S: serde::Serializer,
7223 {
7224 use serde::ser::SerializeStruct;
7225 let mut len = 0;
7226 if self.actor_id != 0 {
7227 len += 1;
7228 }
7229 if !self.vnode_indices.is_empty() {
7230 len += 1;
7231 }
7232 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
7233 if self.actor_id != 0 {
7234 struct_ser.serialize_field("actorId", &self.actor_id)?;
7235 }
7236 if !self.vnode_indices.is_empty() {
7237 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
7238 }
7239 struct_ser.end()
7240 }
7241}
7242impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
7243 #[allow(deprecated)]
7244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7245 where
7246 D: serde::Deserializer<'de>,
7247 {
7248 const FIELDS: &[&str] = &[
7249 "actor_id",
7250 "actorId",
7251 "vnode_indices",
7252 "vnodeIndices",
7253 ];
7254
7255 #[allow(clippy::enum_variant_names)]
7256 enum GeneratedField {
7257 ActorId,
7258 VnodeIndices,
7259 }
7260 impl<'de> serde::Deserialize<'de> for GeneratedField {
7261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7262 where
7263 D: serde::Deserializer<'de>,
7264 {
7265 struct GeneratedVisitor;
7266
7267 impl serde::de::Visitor<'_> for GeneratedVisitor {
7268 type Value = GeneratedField;
7269
7270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7271 write!(formatter, "expected one of: {:?}", &FIELDS)
7272 }
7273
7274 #[allow(unused_variables)]
7275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7276 where
7277 E: serde::de::Error,
7278 {
7279 match value {
7280 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7281 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7283 }
7284 }
7285 }
7286 deserializer.deserialize_identifier(GeneratedVisitor)
7287 }
7288 }
7289 struct GeneratedVisitor;
7290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7291 type Value = get_fragment_vnodes_response::ActorVnodes;
7292
7293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7294 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7295 }
7296
7297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7298 where
7299 V: serde::de::MapAccess<'de>,
7300 {
7301 let mut actor_id__ = None;
7302 let mut vnode_indices__ = None;
7303 while let Some(k) = map_.next_key()? {
7304 match k {
7305 GeneratedField::ActorId => {
7306 if actor_id__.is_some() {
7307 return Err(serde::de::Error::duplicate_field("actorId"));
7308 }
7309 actor_id__ =
7310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7311 ;
7312 }
7313 GeneratedField::VnodeIndices => {
7314 if vnode_indices__.is_some() {
7315 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7316 }
7317 vnode_indices__ =
7318 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7319 .into_iter().map(|x| x.0).collect())
7320 ;
7321 }
7322 }
7323 }
7324 Ok(get_fragment_vnodes_response::ActorVnodes {
7325 actor_id: actor_id__.unwrap_or_default(),
7326 vnode_indices: vnode_indices__.unwrap_or_default(),
7327 })
7328 }
7329 }
7330 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7331 }
7332}
7333impl serde::Serialize for GetMetaStoreInfoRequest {
7334 #[allow(deprecated)]
7335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7336 where
7337 S: serde::Serializer,
7338 {
7339 use serde::ser::SerializeStruct;
7340 let len = 0;
7341 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7342 struct_ser.end()
7343 }
7344}
7345impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7346 #[allow(deprecated)]
7347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7348 where
7349 D: serde::Deserializer<'de>,
7350 {
7351 const FIELDS: &[&str] = &[
7352 ];
7353
7354 #[allow(clippy::enum_variant_names)]
7355 enum GeneratedField {
7356 }
7357 impl<'de> serde::Deserialize<'de> for GeneratedField {
7358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7359 where
7360 D: serde::Deserializer<'de>,
7361 {
7362 struct GeneratedVisitor;
7363
7364 impl serde::de::Visitor<'_> for GeneratedVisitor {
7365 type Value = GeneratedField;
7366
7367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7368 write!(formatter, "expected one of: {:?}", &FIELDS)
7369 }
7370
7371 #[allow(unused_variables)]
7372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7373 where
7374 E: serde::de::Error,
7375 {
7376 Err(serde::de::Error::unknown_field(value, FIELDS))
7377 }
7378 }
7379 deserializer.deserialize_identifier(GeneratedVisitor)
7380 }
7381 }
7382 struct GeneratedVisitor;
7383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7384 type Value = GetMetaStoreInfoRequest;
7385
7386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7387 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7388 }
7389
7390 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7391 where
7392 V: serde::de::MapAccess<'de>,
7393 {
7394 while map_.next_key::<GeneratedField>()?.is_some() {
7395 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7396 }
7397 Ok(GetMetaStoreInfoRequest {
7398 })
7399 }
7400 }
7401 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7402 }
7403}
7404impl serde::Serialize for GetMetaStoreInfoResponse {
7405 #[allow(deprecated)]
7406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7407 where
7408 S: serde::Serializer,
7409 {
7410 use serde::ser::SerializeStruct;
7411 let mut len = 0;
7412 if !self.meta_store_endpoint.is_empty() {
7413 len += 1;
7414 }
7415 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7416 if !self.meta_store_endpoint.is_empty() {
7417 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7418 }
7419 struct_ser.end()
7420 }
7421}
7422impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7423 #[allow(deprecated)]
7424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7425 where
7426 D: serde::Deserializer<'de>,
7427 {
7428 const FIELDS: &[&str] = &[
7429 "meta_store_endpoint",
7430 "metaStoreEndpoint",
7431 ];
7432
7433 #[allow(clippy::enum_variant_names)]
7434 enum GeneratedField {
7435 MetaStoreEndpoint,
7436 }
7437 impl<'de> serde::Deserialize<'de> for GeneratedField {
7438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7439 where
7440 D: serde::Deserializer<'de>,
7441 {
7442 struct GeneratedVisitor;
7443
7444 impl serde::de::Visitor<'_> for GeneratedVisitor {
7445 type Value = GeneratedField;
7446
7447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7448 write!(formatter, "expected one of: {:?}", &FIELDS)
7449 }
7450
7451 #[allow(unused_variables)]
7452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7453 where
7454 E: serde::de::Error,
7455 {
7456 match value {
7457 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7459 }
7460 }
7461 }
7462 deserializer.deserialize_identifier(GeneratedVisitor)
7463 }
7464 }
7465 struct GeneratedVisitor;
7466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7467 type Value = GetMetaStoreInfoResponse;
7468
7469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7470 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7471 }
7472
7473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7474 where
7475 V: serde::de::MapAccess<'de>,
7476 {
7477 let mut meta_store_endpoint__ = None;
7478 while let Some(k) = map_.next_key()? {
7479 match k {
7480 GeneratedField::MetaStoreEndpoint => {
7481 if meta_store_endpoint__.is_some() {
7482 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7483 }
7484 meta_store_endpoint__ = Some(map_.next_value()?);
7485 }
7486 }
7487 }
7488 Ok(GetMetaStoreInfoResponse {
7489 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7490 })
7491 }
7492 }
7493 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7494 }
7495}
7496impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7497 #[allow(deprecated)]
7498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7499 where
7500 S: serde::Serializer,
7501 {
7502 use serde::ser::SerializeStruct;
7503 let len = 0;
7504 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7505 struct_ser.end()
7506 }
7507}
7508impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
7509 #[allow(deprecated)]
7510 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7511 where
7512 D: serde::Deserializer<'de>,
7513 {
7514 const FIELDS: &[&str] = &[
7515 ];
7516
7517 #[allow(clippy::enum_variant_names)]
7518 enum GeneratedField {
7519 }
7520 impl<'de> serde::Deserialize<'de> for GeneratedField {
7521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7522 where
7523 D: serde::Deserializer<'de>,
7524 {
7525 struct GeneratedVisitor;
7526
7527 impl serde::de::Visitor<'_> for GeneratedVisitor {
7528 type Value = GeneratedField;
7529
7530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7531 write!(formatter, "expected one of: {:?}", &FIELDS)
7532 }
7533
7534 #[allow(unused_variables)]
7535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7536 where
7537 E: serde::de::Error,
7538 {
7539 Err(serde::de::Error::unknown_field(value, FIELDS))
7540 }
7541 }
7542 deserializer.deserialize_identifier(GeneratedVisitor)
7543 }
7544 }
7545 struct GeneratedVisitor;
7546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7547 type Value = GetServerlessStreamingJobsStatusRequest;
7548
7549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7550 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7551 }
7552
7553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7554 where
7555 V: serde::de::MapAccess<'de>,
7556 {
7557 while map_.next_key::<GeneratedField>()?.is_some() {
7558 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7559 }
7560 Ok(GetServerlessStreamingJobsStatusRequest {
7561 })
7562 }
7563 }
7564 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7565 }
7566}
7567impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
7568 #[allow(deprecated)]
7569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7570 where
7571 S: serde::Serializer,
7572 {
7573 use serde::ser::SerializeStruct;
7574 let mut len = 0;
7575 if !self.streaming_job_statuses.is_empty() {
7576 len += 1;
7577 }
7578 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7579 if !self.streaming_job_statuses.is_empty() {
7580 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7581 }
7582 struct_ser.end()
7583 }
7584}
7585impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7586 #[allow(deprecated)]
7587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7588 where
7589 D: serde::Deserializer<'de>,
7590 {
7591 const FIELDS: &[&str] = &[
7592 "streaming_job_statuses",
7593 "streamingJobStatuses",
7594 ];
7595
7596 #[allow(clippy::enum_variant_names)]
7597 enum GeneratedField {
7598 StreamingJobStatuses,
7599 }
7600 impl<'de> serde::Deserialize<'de> for GeneratedField {
7601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7602 where
7603 D: serde::Deserializer<'de>,
7604 {
7605 struct GeneratedVisitor;
7606
7607 impl serde::de::Visitor<'_> for GeneratedVisitor {
7608 type Value = GeneratedField;
7609
7610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7611 write!(formatter, "expected one of: {:?}", &FIELDS)
7612 }
7613
7614 #[allow(unused_variables)]
7615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7616 where
7617 E: serde::de::Error,
7618 {
7619 match value {
7620 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7622 }
7623 }
7624 }
7625 deserializer.deserialize_identifier(GeneratedVisitor)
7626 }
7627 }
7628 struct GeneratedVisitor;
7629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7630 type Value = GetServerlessStreamingJobsStatusResponse;
7631
7632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7633 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7634 }
7635
7636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7637 where
7638 V: serde::de::MapAccess<'de>,
7639 {
7640 let mut streaming_job_statuses__ = None;
7641 while let Some(k) = map_.next_key()? {
7642 match k {
7643 GeneratedField::StreamingJobStatuses => {
7644 if streaming_job_statuses__.is_some() {
7645 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7646 }
7647 streaming_job_statuses__ = Some(map_.next_value()?);
7648 }
7649 }
7650 }
7651 Ok(GetServerlessStreamingJobsStatusResponse {
7652 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7653 })
7654 }
7655 }
7656 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7657 }
7658}
7659impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7660 #[allow(deprecated)]
7661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7662 where
7663 S: serde::Serializer,
7664 {
7665 use serde::ser::SerializeStruct;
7666 let mut len = 0;
7667 if self.table_id != 0 {
7668 len += 1;
7669 }
7670 if !self.node_label.is_empty() {
7671 len += 1;
7672 }
7673 if self.backfill_done {
7674 len += 1;
7675 }
7676 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7677 if self.table_id != 0 {
7678 struct_ser.serialize_field("tableId", &self.table_id)?;
7679 }
7680 if !self.node_label.is_empty() {
7681 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7682 }
7683 if self.backfill_done {
7684 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7685 }
7686 struct_ser.end()
7687 }
7688}
7689impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7690 #[allow(deprecated)]
7691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7692 where
7693 D: serde::Deserializer<'de>,
7694 {
7695 const FIELDS: &[&str] = &[
7696 "table_id",
7697 "tableId",
7698 "node_label",
7699 "nodeLabel",
7700 "backfill_done",
7701 "backfillDone",
7702 ];
7703
7704 #[allow(clippy::enum_variant_names)]
7705 enum GeneratedField {
7706 TableId,
7707 NodeLabel,
7708 BackfillDone,
7709 }
7710 impl<'de> serde::Deserialize<'de> for GeneratedField {
7711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7712 where
7713 D: serde::Deserializer<'de>,
7714 {
7715 struct GeneratedVisitor;
7716
7717 impl serde::de::Visitor<'_> for GeneratedVisitor {
7718 type Value = GeneratedField;
7719
7720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7721 write!(formatter, "expected one of: {:?}", &FIELDS)
7722 }
7723
7724 #[allow(unused_variables)]
7725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7726 where
7727 E: serde::de::Error,
7728 {
7729 match value {
7730 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7731 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7732 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7734 }
7735 }
7736 }
7737 deserializer.deserialize_identifier(GeneratedVisitor)
7738 }
7739 }
7740 struct GeneratedVisitor;
7741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7742 type Value = get_serverless_streaming_jobs_status_response::Status;
7743
7744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7745 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7746 }
7747
7748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7749 where
7750 V: serde::de::MapAccess<'de>,
7751 {
7752 let mut table_id__ = None;
7753 let mut node_label__ = None;
7754 let mut backfill_done__ = None;
7755 while let Some(k) = map_.next_key()? {
7756 match k {
7757 GeneratedField::TableId => {
7758 if table_id__.is_some() {
7759 return Err(serde::de::Error::duplicate_field("tableId"));
7760 }
7761 table_id__ =
7762 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7763 ;
7764 }
7765 GeneratedField::NodeLabel => {
7766 if node_label__.is_some() {
7767 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7768 }
7769 node_label__ = Some(map_.next_value()?);
7770 }
7771 GeneratedField::BackfillDone => {
7772 if backfill_done__.is_some() {
7773 return Err(serde::de::Error::duplicate_field("backfillDone"));
7774 }
7775 backfill_done__ = Some(map_.next_value()?);
7776 }
7777 }
7778 }
7779 Ok(get_serverless_streaming_jobs_status_response::Status {
7780 table_id: table_id__.unwrap_or_default(),
7781 node_label: node_label__.unwrap_or_default(),
7782 backfill_done: backfill_done__.unwrap_or_default(),
7783 })
7784 }
7785 }
7786 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7787 }
7788}
7789impl serde::Serialize for GetServingVnodeMappingsRequest {
7790 #[allow(deprecated)]
7791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7792 where
7793 S: serde::Serializer,
7794 {
7795 use serde::ser::SerializeStruct;
7796 let len = 0;
7797 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7798 struct_ser.end()
7799 }
7800}
7801impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7802 #[allow(deprecated)]
7803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7804 where
7805 D: serde::Deserializer<'de>,
7806 {
7807 const FIELDS: &[&str] = &[
7808 ];
7809
7810 #[allow(clippy::enum_variant_names)]
7811 enum GeneratedField {
7812 }
7813 impl<'de> serde::Deserialize<'de> for GeneratedField {
7814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7815 where
7816 D: serde::Deserializer<'de>,
7817 {
7818 struct GeneratedVisitor;
7819
7820 impl serde::de::Visitor<'_> for GeneratedVisitor {
7821 type Value = GeneratedField;
7822
7823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7824 write!(formatter, "expected one of: {:?}", &FIELDS)
7825 }
7826
7827 #[allow(unused_variables)]
7828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7829 where
7830 E: serde::de::Error,
7831 {
7832 Err(serde::de::Error::unknown_field(value, FIELDS))
7833 }
7834 }
7835 deserializer.deserialize_identifier(GeneratedVisitor)
7836 }
7837 }
7838 struct GeneratedVisitor;
7839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7840 type Value = GetServingVnodeMappingsRequest;
7841
7842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7843 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7844 }
7845
7846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7847 where
7848 V: serde::de::MapAccess<'de>,
7849 {
7850 while map_.next_key::<GeneratedField>()?.is_some() {
7851 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7852 }
7853 Ok(GetServingVnodeMappingsRequest {
7854 })
7855 }
7856 }
7857 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7858 }
7859}
7860impl serde::Serialize for GetServingVnodeMappingsResponse {
7861 #[allow(deprecated)]
7862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7863 where
7864 S: serde::Serializer,
7865 {
7866 use serde::ser::SerializeStruct;
7867 let mut len = 0;
7868 if !self.fragment_to_table.is_empty() {
7869 len += 1;
7870 }
7871 if !self.worker_slot_mappings.is_empty() {
7872 len += 1;
7873 }
7874 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7875 if !self.fragment_to_table.is_empty() {
7876 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7877 }
7878 if !self.worker_slot_mappings.is_empty() {
7879 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7880 }
7881 struct_ser.end()
7882 }
7883}
7884impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7885 #[allow(deprecated)]
7886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7887 where
7888 D: serde::Deserializer<'de>,
7889 {
7890 const FIELDS: &[&str] = &[
7891 "fragment_to_table",
7892 "fragmentToTable",
7893 "worker_slot_mappings",
7894 "workerSlotMappings",
7895 ];
7896
7897 #[allow(clippy::enum_variant_names)]
7898 enum GeneratedField {
7899 FragmentToTable,
7900 WorkerSlotMappings,
7901 }
7902 impl<'de> serde::Deserialize<'de> for GeneratedField {
7903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7904 where
7905 D: serde::Deserializer<'de>,
7906 {
7907 struct GeneratedVisitor;
7908
7909 impl serde::de::Visitor<'_> for GeneratedVisitor {
7910 type Value = GeneratedField;
7911
7912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7913 write!(formatter, "expected one of: {:?}", &FIELDS)
7914 }
7915
7916 #[allow(unused_variables)]
7917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7918 where
7919 E: serde::de::Error,
7920 {
7921 match value {
7922 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7923 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7924 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7925 }
7926 }
7927 }
7928 deserializer.deserialize_identifier(GeneratedVisitor)
7929 }
7930 }
7931 struct GeneratedVisitor;
7932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7933 type Value = GetServingVnodeMappingsResponse;
7934
7935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7936 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7937 }
7938
7939 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7940 where
7941 V: serde::de::MapAccess<'de>,
7942 {
7943 let mut fragment_to_table__ = None;
7944 let mut worker_slot_mappings__ = None;
7945 while let Some(k) = map_.next_key()? {
7946 match k {
7947 GeneratedField::FragmentToTable => {
7948 if fragment_to_table__.is_some() {
7949 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7950 }
7951 fragment_to_table__ = Some(
7952 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7953 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
7954 );
7955 }
7956 GeneratedField::WorkerSlotMappings => {
7957 if worker_slot_mappings__.is_some() {
7958 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7959 }
7960 worker_slot_mappings__ = Some(map_.next_value()?);
7961 }
7962 }
7963 }
7964 Ok(GetServingVnodeMappingsResponse {
7965 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7966 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7967 })
7968 }
7969 }
7970 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7971 }
7972}
7973impl serde::Serialize for GetSessionParamsRequest {
7974 #[allow(deprecated)]
7975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7976 where
7977 S: serde::Serializer,
7978 {
7979 use serde::ser::SerializeStruct;
7980 let len = 0;
7981 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7982 struct_ser.end()
7983 }
7984}
7985impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7986 #[allow(deprecated)]
7987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7988 where
7989 D: serde::Deserializer<'de>,
7990 {
7991 const FIELDS: &[&str] = &[
7992 ];
7993
7994 #[allow(clippy::enum_variant_names)]
7995 enum GeneratedField {
7996 }
7997 impl<'de> serde::Deserialize<'de> for GeneratedField {
7998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7999 where
8000 D: serde::Deserializer<'de>,
8001 {
8002 struct GeneratedVisitor;
8003
8004 impl serde::de::Visitor<'_> for GeneratedVisitor {
8005 type Value = GeneratedField;
8006
8007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8008 write!(formatter, "expected one of: {:?}", &FIELDS)
8009 }
8010
8011 #[allow(unused_variables)]
8012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8013 where
8014 E: serde::de::Error,
8015 {
8016 Err(serde::de::Error::unknown_field(value, FIELDS))
8017 }
8018 }
8019 deserializer.deserialize_identifier(GeneratedVisitor)
8020 }
8021 }
8022 struct GeneratedVisitor;
8023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8024 type Value = GetSessionParamsRequest;
8025
8026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8027 formatter.write_str("struct meta.GetSessionParamsRequest")
8028 }
8029
8030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
8031 where
8032 V: serde::de::MapAccess<'de>,
8033 {
8034 while map_.next_key::<GeneratedField>()?.is_some() {
8035 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8036 }
8037 Ok(GetSessionParamsRequest {
8038 })
8039 }
8040 }
8041 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
8042 }
8043}
8044impl serde::Serialize for GetSessionParamsResponse {
8045 #[allow(deprecated)]
8046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8047 where
8048 S: serde::Serializer,
8049 {
8050 use serde::ser::SerializeStruct;
8051 let mut len = 0;
8052 if !self.params.is_empty() {
8053 len += 1;
8054 }
8055 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
8056 if !self.params.is_empty() {
8057 struct_ser.serialize_field("params", &self.params)?;
8058 }
8059 struct_ser.end()
8060 }
8061}
8062impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
8063 #[allow(deprecated)]
8064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8065 where
8066 D: serde::Deserializer<'de>,
8067 {
8068 const FIELDS: &[&str] = &[
8069 "params",
8070 ];
8071
8072 #[allow(clippy::enum_variant_names)]
8073 enum GeneratedField {
8074 Params,
8075 }
8076 impl<'de> serde::Deserialize<'de> for GeneratedField {
8077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8078 where
8079 D: serde::Deserializer<'de>,
8080 {
8081 struct GeneratedVisitor;
8082
8083 impl serde::de::Visitor<'_> for GeneratedVisitor {
8084 type Value = GeneratedField;
8085
8086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087 write!(formatter, "expected one of: {:?}", &FIELDS)
8088 }
8089
8090 #[allow(unused_variables)]
8091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8092 where
8093 E: serde::de::Error,
8094 {
8095 match value {
8096 "params" => Ok(GeneratedField::Params),
8097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8098 }
8099 }
8100 }
8101 deserializer.deserialize_identifier(GeneratedVisitor)
8102 }
8103 }
8104 struct GeneratedVisitor;
8105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8106 type Value = GetSessionParamsResponse;
8107
8108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8109 formatter.write_str("struct meta.GetSessionParamsResponse")
8110 }
8111
8112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
8113 where
8114 V: serde::de::MapAccess<'de>,
8115 {
8116 let mut params__ = None;
8117 while let Some(k) = map_.next_key()? {
8118 match k {
8119 GeneratedField::Params => {
8120 if params__.is_some() {
8121 return Err(serde::de::Error::duplicate_field("params"));
8122 }
8123 params__ = Some(map_.next_value()?);
8124 }
8125 }
8126 }
8127 Ok(GetSessionParamsResponse {
8128 params: params__.unwrap_or_default(),
8129 })
8130 }
8131 }
8132 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
8133 }
8134}
8135impl serde::Serialize for GetSystemParamsRequest {
8136 #[allow(deprecated)]
8137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8138 where
8139 S: serde::Serializer,
8140 {
8141 use serde::ser::SerializeStruct;
8142 let len = 0;
8143 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
8144 struct_ser.end()
8145 }
8146}
8147impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
8148 #[allow(deprecated)]
8149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8150 where
8151 D: serde::Deserializer<'de>,
8152 {
8153 const FIELDS: &[&str] = &[
8154 ];
8155
8156 #[allow(clippy::enum_variant_names)]
8157 enum GeneratedField {
8158 }
8159 impl<'de> serde::Deserialize<'de> for GeneratedField {
8160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8161 where
8162 D: serde::Deserializer<'de>,
8163 {
8164 struct GeneratedVisitor;
8165
8166 impl serde::de::Visitor<'_> for GeneratedVisitor {
8167 type Value = GeneratedField;
8168
8169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8170 write!(formatter, "expected one of: {:?}", &FIELDS)
8171 }
8172
8173 #[allow(unused_variables)]
8174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8175 where
8176 E: serde::de::Error,
8177 {
8178 Err(serde::de::Error::unknown_field(value, FIELDS))
8179 }
8180 }
8181 deserializer.deserialize_identifier(GeneratedVisitor)
8182 }
8183 }
8184 struct GeneratedVisitor;
8185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8186 type Value = GetSystemParamsRequest;
8187
8188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8189 formatter.write_str("struct meta.GetSystemParamsRequest")
8190 }
8191
8192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
8193 where
8194 V: serde::de::MapAccess<'de>,
8195 {
8196 while map_.next_key::<GeneratedField>()?.is_some() {
8197 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8198 }
8199 Ok(GetSystemParamsRequest {
8200 })
8201 }
8202 }
8203 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
8204 }
8205}
8206impl serde::Serialize for GetSystemParamsResponse {
8207 #[allow(deprecated)]
8208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8209 where
8210 S: serde::Serializer,
8211 {
8212 use serde::ser::SerializeStruct;
8213 let mut len = 0;
8214 if self.params.is_some() {
8215 len += 1;
8216 }
8217 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
8218 if let Some(v) = self.params.as_ref() {
8219 struct_ser.serialize_field("params", v)?;
8220 }
8221 struct_ser.end()
8222 }
8223}
8224impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
8225 #[allow(deprecated)]
8226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8227 where
8228 D: serde::Deserializer<'de>,
8229 {
8230 const FIELDS: &[&str] = &[
8231 "params",
8232 ];
8233
8234 #[allow(clippy::enum_variant_names)]
8235 enum GeneratedField {
8236 Params,
8237 }
8238 impl<'de> serde::Deserialize<'de> for GeneratedField {
8239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8240 where
8241 D: serde::Deserializer<'de>,
8242 {
8243 struct GeneratedVisitor;
8244
8245 impl serde::de::Visitor<'_> for GeneratedVisitor {
8246 type Value = GeneratedField;
8247
8248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8249 write!(formatter, "expected one of: {:?}", &FIELDS)
8250 }
8251
8252 #[allow(unused_variables)]
8253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8254 where
8255 E: serde::de::Error,
8256 {
8257 match value {
8258 "params" => Ok(GeneratedField::Params),
8259 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8260 }
8261 }
8262 }
8263 deserializer.deserialize_identifier(GeneratedVisitor)
8264 }
8265 }
8266 struct GeneratedVisitor;
8267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8268 type Value = GetSystemParamsResponse;
8269
8270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8271 formatter.write_str("struct meta.GetSystemParamsResponse")
8272 }
8273
8274 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8275 where
8276 V: serde::de::MapAccess<'de>,
8277 {
8278 let mut params__ = None;
8279 while let Some(k) = map_.next_key()? {
8280 match k {
8281 GeneratedField::Params => {
8282 if params__.is_some() {
8283 return Err(serde::de::Error::duplicate_field("params"));
8284 }
8285 params__ = map_.next_value()?;
8286 }
8287 }
8288 }
8289 Ok(GetSystemParamsResponse {
8290 params: params__,
8291 })
8292 }
8293 }
8294 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8295 }
8296}
8297impl serde::Serialize for GetTelemetryInfoRequest {
8298 #[allow(deprecated)]
8299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8300 where
8301 S: serde::Serializer,
8302 {
8303 use serde::ser::SerializeStruct;
8304 let len = 0;
8305 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8306 struct_ser.end()
8307 }
8308}
8309impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8310 #[allow(deprecated)]
8311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8312 where
8313 D: serde::Deserializer<'de>,
8314 {
8315 const FIELDS: &[&str] = &[
8316 ];
8317
8318 #[allow(clippy::enum_variant_names)]
8319 enum GeneratedField {
8320 }
8321 impl<'de> serde::Deserialize<'de> for GeneratedField {
8322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8323 where
8324 D: serde::Deserializer<'de>,
8325 {
8326 struct GeneratedVisitor;
8327
8328 impl serde::de::Visitor<'_> for GeneratedVisitor {
8329 type Value = GeneratedField;
8330
8331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8332 write!(formatter, "expected one of: {:?}", &FIELDS)
8333 }
8334
8335 #[allow(unused_variables)]
8336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8337 where
8338 E: serde::de::Error,
8339 {
8340 Err(serde::de::Error::unknown_field(value, FIELDS))
8341 }
8342 }
8343 deserializer.deserialize_identifier(GeneratedVisitor)
8344 }
8345 }
8346 struct GeneratedVisitor;
8347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8348 type Value = GetTelemetryInfoRequest;
8349
8350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8351 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8352 }
8353
8354 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8355 where
8356 V: serde::de::MapAccess<'de>,
8357 {
8358 while map_.next_key::<GeneratedField>()?.is_some() {
8359 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8360 }
8361 Ok(GetTelemetryInfoRequest {
8362 })
8363 }
8364 }
8365 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8366 }
8367}
8368impl serde::Serialize for HeartbeatRequest {
8369 #[allow(deprecated)]
8370 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8371 where
8372 S: serde::Serializer,
8373 {
8374 use serde::ser::SerializeStruct;
8375 let mut len = 0;
8376 if self.node_id != 0 {
8377 len += 1;
8378 }
8379 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8380 if self.node_id != 0 {
8381 struct_ser.serialize_field("nodeId", &self.node_id)?;
8382 }
8383 struct_ser.end()
8384 }
8385}
8386impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8387 #[allow(deprecated)]
8388 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8389 where
8390 D: serde::Deserializer<'de>,
8391 {
8392 const FIELDS: &[&str] = &[
8393 "node_id",
8394 "nodeId",
8395 ];
8396
8397 #[allow(clippy::enum_variant_names)]
8398 enum GeneratedField {
8399 NodeId,
8400 }
8401 impl<'de> serde::Deserialize<'de> for GeneratedField {
8402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8403 where
8404 D: serde::Deserializer<'de>,
8405 {
8406 struct GeneratedVisitor;
8407
8408 impl serde::de::Visitor<'_> for GeneratedVisitor {
8409 type Value = GeneratedField;
8410
8411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8412 write!(formatter, "expected one of: {:?}", &FIELDS)
8413 }
8414
8415 #[allow(unused_variables)]
8416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8417 where
8418 E: serde::de::Error,
8419 {
8420 match value {
8421 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8423 }
8424 }
8425 }
8426 deserializer.deserialize_identifier(GeneratedVisitor)
8427 }
8428 }
8429 struct GeneratedVisitor;
8430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8431 type Value = HeartbeatRequest;
8432
8433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8434 formatter.write_str("struct meta.HeartbeatRequest")
8435 }
8436
8437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8438 where
8439 V: serde::de::MapAccess<'de>,
8440 {
8441 let mut node_id__ = None;
8442 while let Some(k) = map_.next_key()? {
8443 match k {
8444 GeneratedField::NodeId => {
8445 if node_id__.is_some() {
8446 return Err(serde::de::Error::duplicate_field("nodeId"));
8447 }
8448 node_id__ =
8449 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8450 ;
8451 }
8452 }
8453 }
8454 Ok(HeartbeatRequest {
8455 node_id: node_id__.unwrap_or_default(),
8456 })
8457 }
8458 }
8459 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8460 }
8461}
8462impl serde::Serialize for HeartbeatResponse {
8463 #[allow(deprecated)]
8464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8465 where
8466 S: serde::Serializer,
8467 {
8468 use serde::ser::SerializeStruct;
8469 let mut len = 0;
8470 if self.status.is_some() {
8471 len += 1;
8472 }
8473 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8474 if let Some(v) = self.status.as_ref() {
8475 struct_ser.serialize_field("status", v)?;
8476 }
8477 struct_ser.end()
8478 }
8479}
8480impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8481 #[allow(deprecated)]
8482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8483 where
8484 D: serde::Deserializer<'de>,
8485 {
8486 const FIELDS: &[&str] = &[
8487 "status",
8488 ];
8489
8490 #[allow(clippy::enum_variant_names)]
8491 enum GeneratedField {
8492 Status,
8493 }
8494 impl<'de> serde::Deserialize<'de> for GeneratedField {
8495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8496 where
8497 D: serde::Deserializer<'de>,
8498 {
8499 struct GeneratedVisitor;
8500
8501 impl serde::de::Visitor<'_> for GeneratedVisitor {
8502 type Value = GeneratedField;
8503
8504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8505 write!(formatter, "expected one of: {:?}", &FIELDS)
8506 }
8507
8508 #[allow(unused_variables)]
8509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8510 where
8511 E: serde::de::Error,
8512 {
8513 match value {
8514 "status" => Ok(GeneratedField::Status),
8515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8516 }
8517 }
8518 }
8519 deserializer.deserialize_identifier(GeneratedVisitor)
8520 }
8521 }
8522 struct GeneratedVisitor;
8523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8524 type Value = HeartbeatResponse;
8525
8526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8527 formatter.write_str("struct meta.HeartbeatResponse")
8528 }
8529
8530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8531 where
8532 V: serde::de::MapAccess<'de>,
8533 {
8534 let mut status__ = None;
8535 while let Some(k) = map_.next_key()? {
8536 match k {
8537 GeneratedField::Status => {
8538 if status__.is_some() {
8539 return Err(serde::de::Error::duplicate_field("status"));
8540 }
8541 status__ = map_.next_value()?;
8542 }
8543 }
8544 }
8545 Ok(HeartbeatResponse {
8546 status: status__,
8547 })
8548 }
8549 }
8550 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8551 }
8552}
8553impl serde::Serialize for InjectSourceOffsetsRequest {
8554 #[allow(deprecated)]
8555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8556 where
8557 S: serde::Serializer,
8558 {
8559 use serde::ser::SerializeStruct;
8560 let mut len = 0;
8561 if self.source_id != 0 {
8562 len += 1;
8563 }
8564 if !self.split_offsets.is_empty() {
8565 len += 1;
8566 }
8567 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsRequest", len)?;
8568 if self.source_id != 0 {
8569 struct_ser.serialize_field("sourceId", &self.source_id)?;
8570 }
8571 if !self.split_offsets.is_empty() {
8572 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
8573 }
8574 struct_ser.end()
8575 }
8576}
8577impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsRequest {
8578 #[allow(deprecated)]
8579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8580 where
8581 D: serde::Deserializer<'de>,
8582 {
8583 const FIELDS: &[&str] = &[
8584 "source_id",
8585 "sourceId",
8586 "split_offsets",
8587 "splitOffsets",
8588 ];
8589
8590 #[allow(clippy::enum_variant_names)]
8591 enum GeneratedField {
8592 SourceId,
8593 SplitOffsets,
8594 }
8595 impl<'de> serde::Deserialize<'de> for GeneratedField {
8596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8597 where
8598 D: serde::Deserializer<'de>,
8599 {
8600 struct GeneratedVisitor;
8601
8602 impl serde::de::Visitor<'_> for GeneratedVisitor {
8603 type Value = GeneratedField;
8604
8605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8606 write!(formatter, "expected one of: {:?}", &FIELDS)
8607 }
8608
8609 #[allow(unused_variables)]
8610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8611 where
8612 E: serde::de::Error,
8613 {
8614 match value {
8615 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8616 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
8617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8618 }
8619 }
8620 }
8621 deserializer.deserialize_identifier(GeneratedVisitor)
8622 }
8623 }
8624 struct GeneratedVisitor;
8625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8626 type Value = InjectSourceOffsetsRequest;
8627
8628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8629 formatter.write_str("struct meta.InjectSourceOffsetsRequest")
8630 }
8631
8632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsRequest, V::Error>
8633 where
8634 V: serde::de::MapAccess<'de>,
8635 {
8636 let mut source_id__ = None;
8637 let mut split_offsets__ = None;
8638 while let Some(k) = map_.next_key()? {
8639 match k {
8640 GeneratedField::SourceId => {
8641 if source_id__.is_some() {
8642 return Err(serde::de::Error::duplicate_field("sourceId"));
8643 }
8644 source_id__ =
8645 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8646 ;
8647 }
8648 GeneratedField::SplitOffsets => {
8649 if split_offsets__.is_some() {
8650 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8651 }
8652 split_offsets__ = Some(
8653 map_.next_value::<std::collections::HashMap<_, _>>()?
8654 );
8655 }
8656 }
8657 }
8658 Ok(InjectSourceOffsetsRequest {
8659 source_id: source_id__.unwrap_or_default(),
8660 split_offsets: split_offsets__.unwrap_or_default(),
8661 })
8662 }
8663 }
8664 deserializer.deserialize_struct("meta.InjectSourceOffsetsRequest", FIELDS, GeneratedVisitor)
8665 }
8666}
8667impl serde::Serialize for InjectSourceOffsetsResponse {
8668 #[allow(deprecated)]
8669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8670 where
8671 S: serde::Serializer,
8672 {
8673 use serde::ser::SerializeStruct;
8674 let mut len = 0;
8675 if !self.applied_split_ids.is_empty() {
8676 len += 1;
8677 }
8678 let mut struct_ser = serializer.serialize_struct("meta.InjectSourceOffsetsResponse", len)?;
8679 if !self.applied_split_ids.is_empty() {
8680 struct_ser.serialize_field("appliedSplitIds", &self.applied_split_ids)?;
8681 }
8682 struct_ser.end()
8683 }
8684}
8685impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsResponse {
8686 #[allow(deprecated)]
8687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8688 where
8689 D: serde::Deserializer<'de>,
8690 {
8691 const FIELDS: &[&str] = &[
8692 "applied_split_ids",
8693 "appliedSplitIds",
8694 ];
8695
8696 #[allow(clippy::enum_variant_names)]
8697 enum GeneratedField {
8698 AppliedSplitIds,
8699 }
8700 impl<'de> serde::Deserialize<'de> for GeneratedField {
8701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8702 where
8703 D: serde::Deserializer<'de>,
8704 {
8705 struct GeneratedVisitor;
8706
8707 impl serde::de::Visitor<'_> for GeneratedVisitor {
8708 type Value = GeneratedField;
8709
8710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8711 write!(formatter, "expected one of: {:?}", &FIELDS)
8712 }
8713
8714 #[allow(unused_variables)]
8715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8716 where
8717 E: serde::de::Error,
8718 {
8719 match value {
8720 "appliedSplitIds" | "applied_split_ids" => Ok(GeneratedField::AppliedSplitIds),
8721 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8722 }
8723 }
8724 }
8725 deserializer.deserialize_identifier(GeneratedVisitor)
8726 }
8727 }
8728 struct GeneratedVisitor;
8729 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8730 type Value = InjectSourceOffsetsResponse;
8731
8732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8733 formatter.write_str("struct meta.InjectSourceOffsetsResponse")
8734 }
8735
8736 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsResponse, V::Error>
8737 where
8738 V: serde::de::MapAccess<'de>,
8739 {
8740 let mut applied_split_ids__ = None;
8741 while let Some(k) = map_.next_key()? {
8742 match k {
8743 GeneratedField::AppliedSplitIds => {
8744 if applied_split_ids__.is_some() {
8745 return Err(serde::de::Error::duplicate_field("appliedSplitIds"));
8746 }
8747 applied_split_ids__ = Some(map_.next_value()?);
8748 }
8749 }
8750 }
8751 Ok(InjectSourceOffsetsResponse {
8752 applied_split_ids: applied_split_ids__.unwrap_or_default(),
8753 })
8754 }
8755 }
8756 deserializer.deserialize_struct("meta.InjectSourceOffsetsResponse", FIELDS, GeneratedVisitor)
8757 }
8758}
8759impl serde::Serialize for ListActorSplitsRequest {
8760 #[allow(deprecated)]
8761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8762 where
8763 S: serde::Serializer,
8764 {
8765 use serde::ser::SerializeStruct;
8766 let len = 0;
8767 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8768 struct_ser.end()
8769 }
8770}
8771impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8772 #[allow(deprecated)]
8773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8774 where
8775 D: serde::Deserializer<'de>,
8776 {
8777 const FIELDS: &[&str] = &[
8778 ];
8779
8780 #[allow(clippy::enum_variant_names)]
8781 enum GeneratedField {
8782 }
8783 impl<'de> serde::Deserialize<'de> for GeneratedField {
8784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8785 where
8786 D: serde::Deserializer<'de>,
8787 {
8788 struct GeneratedVisitor;
8789
8790 impl serde::de::Visitor<'_> for GeneratedVisitor {
8791 type Value = GeneratedField;
8792
8793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8794 write!(formatter, "expected one of: {:?}", &FIELDS)
8795 }
8796
8797 #[allow(unused_variables)]
8798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8799 where
8800 E: serde::de::Error,
8801 {
8802 Err(serde::de::Error::unknown_field(value, FIELDS))
8803 }
8804 }
8805 deserializer.deserialize_identifier(GeneratedVisitor)
8806 }
8807 }
8808 struct GeneratedVisitor;
8809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8810 type Value = ListActorSplitsRequest;
8811
8812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8813 formatter.write_str("struct meta.ListActorSplitsRequest")
8814 }
8815
8816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8817 where
8818 V: serde::de::MapAccess<'de>,
8819 {
8820 while map_.next_key::<GeneratedField>()?.is_some() {
8821 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8822 }
8823 Ok(ListActorSplitsRequest {
8824 })
8825 }
8826 }
8827 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
8828 }
8829}
8830impl serde::Serialize for ListActorSplitsResponse {
8831 #[allow(deprecated)]
8832 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8833 where
8834 S: serde::Serializer,
8835 {
8836 use serde::ser::SerializeStruct;
8837 let mut len = 0;
8838 if !self.actor_splits.is_empty() {
8839 len += 1;
8840 }
8841 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
8842 if !self.actor_splits.is_empty() {
8843 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
8844 }
8845 struct_ser.end()
8846 }
8847}
8848impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
8849 #[allow(deprecated)]
8850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8851 where
8852 D: serde::Deserializer<'de>,
8853 {
8854 const FIELDS: &[&str] = &[
8855 "actor_splits",
8856 "actorSplits",
8857 ];
8858
8859 #[allow(clippy::enum_variant_names)]
8860 enum GeneratedField {
8861 ActorSplits,
8862 }
8863 impl<'de> serde::Deserialize<'de> for GeneratedField {
8864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8865 where
8866 D: serde::Deserializer<'de>,
8867 {
8868 struct GeneratedVisitor;
8869
8870 impl serde::de::Visitor<'_> for GeneratedVisitor {
8871 type Value = GeneratedField;
8872
8873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8874 write!(formatter, "expected one of: {:?}", &FIELDS)
8875 }
8876
8877 #[allow(unused_variables)]
8878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8879 where
8880 E: serde::de::Error,
8881 {
8882 match value {
8883 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
8884 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8885 }
8886 }
8887 }
8888 deserializer.deserialize_identifier(GeneratedVisitor)
8889 }
8890 }
8891 struct GeneratedVisitor;
8892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8893 type Value = ListActorSplitsResponse;
8894
8895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8896 formatter.write_str("struct meta.ListActorSplitsResponse")
8897 }
8898
8899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
8900 where
8901 V: serde::de::MapAccess<'de>,
8902 {
8903 let mut actor_splits__ = None;
8904 while let Some(k) = map_.next_key()? {
8905 match k {
8906 GeneratedField::ActorSplits => {
8907 if actor_splits__.is_some() {
8908 return Err(serde::de::Error::duplicate_field("actorSplits"));
8909 }
8910 actor_splits__ = Some(map_.next_value()?);
8911 }
8912 }
8913 }
8914 Ok(ListActorSplitsResponse {
8915 actor_splits: actor_splits__.unwrap_or_default(),
8916 })
8917 }
8918 }
8919 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
8920 }
8921}
8922impl serde::Serialize for list_actor_splits_response::ActorSplit {
8923 #[allow(deprecated)]
8924 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8925 where
8926 S: serde::Serializer,
8927 {
8928 use serde::ser::SerializeStruct;
8929 let mut len = 0;
8930 if self.actor_id != 0 {
8931 len += 1;
8932 }
8933 if self.fragment_id != 0 {
8934 len += 1;
8935 }
8936 if self.source_id != 0 {
8937 len += 1;
8938 }
8939 if !self.split_id.is_empty() {
8940 len += 1;
8941 }
8942 if self.fragment_type != 0 {
8943 len += 1;
8944 }
8945 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
8946 if self.actor_id != 0 {
8947 struct_ser.serialize_field("actorId", &self.actor_id)?;
8948 }
8949 if self.fragment_id != 0 {
8950 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8951 }
8952 if self.source_id != 0 {
8953 struct_ser.serialize_field("sourceId", &self.source_id)?;
8954 }
8955 if !self.split_id.is_empty() {
8956 struct_ser.serialize_field("splitId", &self.split_id)?;
8957 }
8958 if self.fragment_type != 0 {
8959 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
8960 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8961 struct_ser.serialize_field("fragmentType", &v)?;
8962 }
8963 struct_ser.end()
8964 }
8965}
8966impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8967 #[allow(deprecated)]
8968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8969 where
8970 D: serde::Deserializer<'de>,
8971 {
8972 const FIELDS: &[&str] = &[
8973 "actor_id",
8974 "actorId",
8975 "fragment_id",
8976 "fragmentId",
8977 "source_id",
8978 "sourceId",
8979 "split_id",
8980 "splitId",
8981 "fragment_type",
8982 "fragmentType",
8983 ];
8984
8985 #[allow(clippy::enum_variant_names)]
8986 enum GeneratedField {
8987 ActorId,
8988 FragmentId,
8989 SourceId,
8990 SplitId,
8991 FragmentType,
8992 }
8993 impl<'de> serde::Deserialize<'de> for GeneratedField {
8994 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8995 where
8996 D: serde::Deserializer<'de>,
8997 {
8998 struct GeneratedVisitor;
8999
9000 impl serde::de::Visitor<'_> for GeneratedVisitor {
9001 type Value = GeneratedField;
9002
9003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9004 write!(formatter, "expected one of: {:?}", &FIELDS)
9005 }
9006
9007 #[allow(unused_variables)]
9008 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9009 where
9010 E: serde::de::Error,
9011 {
9012 match value {
9013 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9014 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9015 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9016 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
9017 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
9018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9019 }
9020 }
9021 }
9022 deserializer.deserialize_identifier(GeneratedVisitor)
9023 }
9024 }
9025 struct GeneratedVisitor;
9026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9027 type Value = list_actor_splits_response::ActorSplit;
9028
9029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9030 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
9031 }
9032
9033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
9034 where
9035 V: serde::de::MapAccess<'de>,
9036 {
9037 let mut actor_id__ = None;
9038 let mut fragment_id__ = None;
9039 let mut source_id__ = None;
9040 let mut split_id__ = None;
9041 let mut fragment_type__ = None;
9042 while let Some(k) = map_.next_key()? {
9043 match k {
9044 GeneratedField::ActorId => {
9045 if actor_id__.is_some() {
9046 return Err(serde::de::Error::duplicate_field("actorId"));
9047 }
9048 actor_id__ =
9049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9050 ;
9051 }
9052 GeneratedField::FragmentId => {
9053 if fragment_id__.is_some() {
9054 return Err(serde::de::Error::duplicate_field("fragmentId"));
9055 }
9056 fragment_id__ =
9057 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9058 ;
9059 }
9060 GeneratedField::SourceId => {
9061 if source_id__.is_some() {
9062 return Err(serde::de::Error::duplicate_field("sourceId"));
9063 }
9064 source_id__ =
9065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9066 ;
9067 }
9068 GeneratedField::SplitId => {
9069 if split_id__.is_some() {
9070 return Err(serde::de::Error::duplicate_field("splitId"));
9071 }
9072 split_id__ = Some(map_.next_value()?);
9073 }
9074 GeneratedField::FragmentType => {
9075 if fragment_type__.is_some() {
9076 return Err(serde::de::Error::duplicate_field("fragmentType"));
9077 }
9078 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
9079 }
9080 }
9081 }
9082 Ok(list_actor_splits_response::ActorSplit {
9083 actor_id: actor_id__.unwrap_or_default(),
9084 fragment_id: fragment_id__.unwrap_or_default(),
9085 source_id: source_id__.unwrap_or_default(),
9086 split_id: split_id__.unwrap_or_default(),
9087 fragment_type: fragment_type__.unwrap_or_default(),
9088 })
9089 }
9090 }
9091 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
9092 }
9093}
9094impl serde::Serialize for list_actor_splits_response::FragmentType {
9095 #[allow(deprecated)]
9096 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9097 where
9098 S: serde::Serializer,
9099 {
9100 let variant = match self {
9101 Self::Unspecified => "UNSPECIFIED",
9102 Self::NonSharedSource => "NON_SHARED_SOURCE",
9103 Self::SharedSource => "SHARED_SOURCE",
9104 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
9105 };
9106 serializer.serialize_str(variant)
9107 }
9108}
9109impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
9110 #[allow(deprecated)]
9111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9112 where
9113 D: serde::Deserializer<'de>,
9114 {
9115 const FIELDS: &[&str] = &[
9116 "UNSPECIFIED",
9117 "NON_SHARED_SOURCE",
9118 "SHARED_SOURCE",
9119 "SHARED_SOURCE_BACKFILL",
9120 ];
9121
9122 struct GeneratedVisitor;
9123
9124 impl serde::de::Visitor<'_> for GeneratedVisitor {
9125 type Value = list_actor_splits_response::FragmentType;
9126
9127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9128 write!(formatter, "expected one of: {:?}", &FIELDS)
9129 }
9130
9131 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9132 where
9133 E: serde::de::Error,
9134 {
9135 i32::try_from(v)
9136 .ok()
9137 .and_then(|x| x.try_into().ok())
9138 .ok_or_else(|| {
9139 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9140 })
9141 }
9142
9143 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9144 where
9145 E: serde::de::Error,
9146 {
9147 i32::try_from(v)
9148 .ok()
9149 .and_then(|x| x.try_into().ok())
9150 .ok_or_else(|| {
9151 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9152 })
9153 }
9154
9155 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9156 where
9157 E: serde::de::Error,
9158 {
9159 match value {
9160 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
9161 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
9162 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
9163 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
9164 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9165 }
9166 }
9167 }
9168 deserializer.deserialize_any(GeneratedVisitor)
9169 }
9170}
9171impl serde::Serialize for ListActorStatesRequest {
9172 #[allow(deprecated)]
9173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9174 where
9175 S: serde::Serializer,
9176 {
9177 use serde::ser::SerializeStruct;
9178 let len = 0;
9179 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
9180 struct_ser.end()
9181 }
9182}
9183impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
9184 #[allow(deprecated)]
9185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9186 where
9187 D: serde::Deserializer<'de>,
9188 {
9189 const FIELDS: &[&str] = &[
9190 ];
9191
9192 #[allow(clippy::enum_variant_names)]
9193 enum GeneratedField {
9194 }
9195 impl<'de> serde::Deserialize<'de> for GeneratedField {
9196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9197 where
9198 D: serde::Deserializer<'de>,
9199 {
9200 struct GeneratedVisitor;
9201
9202 impl serde::de::Visitor<'_> for GeneratedVisitor {
9203 type Value = GeneratedField;
9204
9205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9206 write!(formatter, "expected one of: {:?}", &FIELDS)
9207 }
9208
9209 #[allow(unused_variables)]
9210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9211 where
9212 E: serde::de::Error,
9213 {
9214 Err(serde::de::Error::unknown_field(value, FIELDS))
9215 }
9216 }
9217 deserializer.deserialize_identifier(GeneratedVisitor)
9218 }
9219 }
9220 struct GeneratedVisitor;
9221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9222 type Value = ListActorStatesRequest;
9223
9224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9225 formatter.write_str("struct meta.ListActorStatesRequest")
9226 }
9227
9228 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
9229 where
9230 V: serde::de::MapAccess<'de>,
9231 {
9232 while map_.next_key::<GeneratedField>()?.is_some() {
9233 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9234 }
9235 Ok(ListActorStatesRequest {
9236 })
9237 }
9238 }
9239 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
9240 }
9241}
9242impl serde::Serialize for ListActorStatesResponse {
9243 #[allow(deprecated)]
9244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9245 where
9246 S: serde::Serializer,
9247 {
9248 use serde::ser::SerializeStruct;
9249 let mut len = 0;
9250 if !self.states.is_empty() {
9251 len += 1;
9252 }
9253 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
9254 if !self.states.is_empty() {
9255 struct_ser.serialize_field("states", &self.states)?;
9256 }
9257 struct_ser.end()
9258 }
9259}
9260impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
9261 #[allow(deprecated)]
9262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9263 where
9264 D: serde::Deserializer<'de>,
9265 {
9266 const FIELDS: &[&str] = &[
9267 "states",
9268 ];
9269
9270 #[allow(clippy::enum_variant_names)]
9271 enum GeneratedField {
9272 States,
9273 }
9274 impl<'de> serde::Deserialize<'de> for GeneratedField {
9275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9276 where
9277 D: serde::Deserializer<'de>,
9278 {
9279 struct GeneratedVisitor;
9280
9281 impl serde::de::Visitor<'_> for GeneratedVisitor {
9282 type Value = GeneratedField;
9283
9284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9285 write!(formatter, "expected one of: {:?}", &FIELDS)
9286 }
9287
9288 #[allow(unused_variables)]
9289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9290 where
9291 E: serde::de::Error,
9292 {
9293 match value {
9294 "states" => Ok(GeneratedField::States),
9295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9296 }
9297 }
9298 }
9299 deserializer.deserialize_identifier(GeneratedVisitor)
9300 }
9301 }
9302 struct GeneratedVisitor;
9303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9304 type Value = ListActorStatesResponse;
9305
9306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9307 formatter.write_str("struct meta.ListActorStatesResponse")
9308 }
9309
9310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
9311 where
9312 V: serde::de::MapAccess<'de>,
9313 {
9314 let mut states__ = None;
9315 while let Some(k) = map_.next_key()? {
9316 match k {
9317 GeneratedField::States => {
9318 if states__.is_some() {
9319 return Err(serde::de::Error::duplicate_field("states"));
9320 }
9321 states__ = Some(map_.next_value()?);
9322 }
9323 }
9324 }
9325 Ok(ListActorStatesResponse {
9326 states: states__.unwrap_or_default(),
9327 })
9328 }
9329 }
9330 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
9331 }
9332}
9333impl serde::Serialize for list_actor_states_response::ActorState {
9334 #[allow(deprecated)]
9335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9336 where
9337 S: serde::Serializer,
9338 {
9339 use serde::ser::SerializeStruct;
9340 let mut len = 0;
9341 if self.actor_id != 0 {
9342 len += 1;
9343 }
9344 if self.fragment_id != 0 {
9345 len += 1;
9346 }
9347 if self.worker_id != 0 {
9348 len += 1;
9349 }
9350 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
9351 if self.actor_id != 0 {
9352 struct_ser.serialize_field("actorId", &self.actor_id)?;
9353 }
9354 if self.fragment_id != 0 {
9355 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9356 }
9357 if self.worker_id != 0 {
9358 struct_ser.serialize_field("workerId", &self.worker_id)?;
9359 }
9360 struct_ser.end()
9361 }
9362}
9363impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
9364 #[allow(deprecated)]
9365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9366 where
9367 D: serde::Deserializer<'de>,
9368 {
9369 const FIELDS: &[&str] = &[
9370 "actor_id",
9371 "actorId",
9372 "fragment_id",
9373 "fragmentId",
9374 "worker_id",
9375 "workerId",
9376 ];
9377
9378 #[allow(clippy::enum_variant_names)]
9379 enum GeneratedField {
9380 ActorId,
9381 FragmentId,
9382 WorkerId,
9383 }
9384 impl<'de> serde::Deserialize<'de> for GeneratedField {
9385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9386 where
9387 D: serde::Deserializer<'de>,
9388 {
9389 struct GeneratedVisitor;
9390
9391 impl serde::de::Visitor<'_> for GeneratedVisitor {
9392 type Value = GeneratedField;
9393
9394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9395 write!(formatter, "expected one of: {:?}", &FIELDS)
9396 }
9397
9398 #[allow(unused_variables)]
9399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9400 where
9401 E: serde::de::Error,
9402 {
9403 match value {
9404 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9405 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9406 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
9407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9408 }
9409 }
9410 }
9411 deserializer.deserialize_identifier(GeneratedVisitor)
9412 }
9413 }
9414 struct GeneratedVisitor;
9415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9416 type Value = list_actor_states_response::ActorState;
9417
9418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9419 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
9420 }
9421
9422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
9423 where
9424 V: serde::de::MapAccess<'de>,
9425 {
9426 let mut actor_id__ = None;
9427 let mut fragment_id__ = None;
9428 let mut worker_id__ = None;
9429 while let Some(k) = map_.next_key()? {
9430 match k {
9431 GeneratedField::ActorId => {
9432 if actor_id__.is_some() {
9433 return Err(serde::de::Error::duplicate_field("actorId"));
9434 }
9435 actor_id__ =
9436 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9437 ;
9438 }
9439 GeneratedField::FragmentId => {
9440 if fragment_id__.is_some() {
9441 return Err(serde::de::Error::duplicate_field("fragmentId"));
9442 }
9443 fragment_id__ =
9444 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9445 ;
9446 }
9447 GeneratedField::WorkerId => {
9448 if worker_id__.is_some() {
9449 return Err(serde::de::Error::duplicate_field("workerId"));
9450 }
9451 worker_id__ =
9452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9453 ;
9454 }
9455 }
9456 }
9457 Ok(list_actor_states_response::ActorState {
9458 actor_id: actor_id__.unwrap_or_default(),
9459 fragment_id: fragment_id__.unwrap_or_default(),
9460 worker_id: worker_id__.unwrap_or_default(),
9461 })
9462 }
9463 }
9464 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
9465 }
9466}
9467impl serde::Serialize for ListAllNodesRequest {
9468 #[allow(deprecated)]
9469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9470 where
9471 S: serde::Serializer,
9472 {
9473 use serde::ser::SerializeStruct;
9474 let mut len = 0;
9475 if self.worker_type.is_some() {
9476 len += 1;
9477 }
9478 if self.include_starting_nodes {
9479 len += 1;
9480 }
9481 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9482 if let Some(v) = self.worker_type.as_ref() {
9483 let v = super::common::WorkerType::try_from(*v)
9484 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9485 struct_ser.serialize_field("workerType", &v)?;
9486 }
9487 if self.include_starting_nodes {
9488 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9489 }
9490 struct_ser.end()
9491 }
9492}
9493impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9494 #[allow(deprecated)]
9495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9496 where
9497 D: serde::Deserializer<'de>,
9498 {
9499 const FIELDS: &[&str] = &[
9500 "worker_type",
9501 "workerType",
9502 "include_starting_nodes",
9503 "includeStartingNodes",
9504 ];
9505
9506 #[allow(clippy::enum_variant_names)]
9507 enum GeneratedField {
9508 WorkerType,
9509 IncludeStartingNodes,
9510 }
9511 impl<'de> serde::Deserialize<'de> for GeneratedField {
9512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9513 where
9514 D: serde::Deserializer<'de>,
9515 {
9516 struct GeneratedVisitor;
9517
9518 impl serde::de::Visitor<'_> for GeneratedVisitor {
9519 type Value = GeneratedField;
9520
9521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9522 write!(formatter, "expected one of: {:?}", &FIELDS)
9523 }
9524
9525 #[allow(unused_variables)]
9526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9527 where
9528 E: serde::de::Error,
9529 {
9530 match value {
9531 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9532 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9534 }
9535 }
9536 }
9537 deserializer.deserialize_identifier(GeneratedVisitor)
9538 }
9539 }
9540 struct GeneratedVisitor;
9541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9542 type Value = ListAllNodesRequest;
9543
9544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9545 formatter.write_str("struct meta.ListAllNodesRequest")
9546 }
9547
9548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9549 where
9550 V: serde::de::MapAccess<'de>,
9551 {
9552 let mut worker_type__ = None;
9553 let mut include_starting_nodes__ = None;
9554 while let Some(k) = map_.next_key()? {
9555 match k {
9556 GeneratedField::WorkerType => {
9557 if worker_type__.is_some() {
9558 return Err(serde::de::Error::duplicate_field("workerType"));
9559 }
9560 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9561 }
9562 GeneratedField::IncludeStartingNodes => {
9563 if include_starting_nodes__.is_some() {
9564 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9565 }
9566 include_starting_nodes__ = Some(map_.next_value()?);
9567 }
9568 }
9569 }
9570 Ok(ListAllNodesRequest {
9571 worker_type: worker_type__,
9572 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9573 })
9574 }
9575 }
9576 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9577 }
9578}
9579impl serde::Serialize for ListAllNodesResponse {
9580 #[allow(deprecated)]
9581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9582 where
9583 S: serde::Serializer,
9584 {
9585 use serde::ser::SerializeStruct;
9586 let mut len = 0;
9587 if self.status.is_some() {
9588 len += 1;
9589 }
9590 if !self.nodes.is_empty() {
9591 len += 1;
9592 }
9593 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9594 if let Some(v) = self.status.as_ref() {
9595 struct_ser.serialize_field("status", v)?;
9596 }
9597 if !self.nodes.is_empty() {
9598 struct_ser.serialize_field("nodes", &self.nodes)?;
9599 }
9600 struct_ser.end()
9601 }
9602}
9603impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9604 #[allow(deprecated)]
9605 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9606 where
9607 D: serde::Deserializer<'de>,
9608 {
9609 const FIELDS: &[&str] = &[
9610 "status",
9611 "nodes",
9612 ];
9613
9614 #[allow(clippy::enum_variant_names)]
9615 enum GeneratedField {
9616 Status,
9617 Nodes,
9618 }
9619 impl<'de> serde::Deserialize<'de> for GeneratedField {
9620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9621 where
9622 D: serde::Deserializer<'de>,
9623 {
9624 struct GeneratedVisitor;
9625
9626 impl serde::de::Visitor<'_> for GeneratedVisitor {
9627 type Value = GeneratedField;
9628
9629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9630 write!(formatter, "expected one of: {:?}", &FIELDS)
9631 }
9632
9633 #[allow(unused_variables)]
9634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9635 where
9636 E: serde::de::Error,
9637 {
9638 match value {
9639 "status" => Ok(GeneratedField::Status),
9640 "nodes" => Ok(GeneratedField::Nodes),
9641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9642 }
9643 }
9644 }
9645 deserializer.deserialize_identifier(GeneratedVisitor)
9646 }
9647 }
9648 struct GeneratedVisitor;
9649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9650 type Value = ListAllNodesResponse;
9651
9652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9653 formatter.write_str("struct meta.ListAllNodesResponse")
9654 }
9655
9656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9657 where
9658 V: serde::de::MapAccess<'de>,
9659 {
9660 let mut status__ = None;
9661 let mut nodes__ = None;
9662 while let Some(k) = map_.next_key()? {
9663 match k {
9664 GeneratedField::Status => {
9665 if status__.is_some() {
9666 return Err(serde::de::Error::duplicate_field("status"));
9667 }
9668 status__ = map_.next_value()?;
9669 }
9670 GeneratedField::Nodes => {
9671 if nodes__.is_some() {
9672 return Err(serde::de::Error::duplicate_field("nodes"));
9673 }
9674 nodes__ = Some(map_.next_value()?);
9675 }
9676 }
9677 }
9678 Ok(ListAllNodesResponse {
9679 status: status__,
9680 nodes: nodes__.unwrap_or_default(),
9681 })
9682 }
9683 }
9684 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9685 }
9686}
9687impl serde::Serialize for ListCdcProgressRequest {
9688 #[allow(deprecated)]
9689 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9690 where
9691 S: serde::Serializer,
9692 {
9693 use serde::ser::SerializeStruct;
9694 let len = 0;
9695 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9696 struct_ser.end()
9697 }
9698}
9699impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9700 #[allow(deprecated)]
9701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9702 where
9703 D: serde::Deserializer<'de>,
9704 {
9705 const FIELDS: &[&str] = &[
9706 ];
9707
9708 #[allow(clippy::enum_variant_names)]
9709 enum GeneratedField {
9710 }
9711 impl<'de> serde::Deserialize<'de> for GeneratedField {
9712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9713 where
9714 D: serde::Deserializer<'de>,
9715 {
9716 struct GeneratedVisitor;
9717
9718 impl serde::de::Visitor<'_> for GeneratedVisitor {
9719 type Value = GeneratedField;
9720
9721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9722 write!(formatter, "expected one of: {:?}", &FIELDS)
9723 }
9724
9725 #[allow(unused_variables)]
9726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9727 where
9728 E: serde::de::Error,
9729 {
9730 Err(serde::de::Error::unknown_field(value, FIELDS))
9731 }
9732 }
9733 deserializer.deserialize_identifier(GeneratedVisitor)
9734 }
9735 }
9736 struct GeneratedVisitor;
9737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9738 type Value = ListCdcProgressRequest;
9739
9740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9741 formatter.write_str("struct meta.ListCdcProgressRequest")
9742 }
9743
9744 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9745 where
9746 V: serde::de::MapAccess<'de>,
9747 {
9748 while map_.next_key::<GeneratedField>()?.is_some() {
9749 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9750 }
9751 Ok(ListCdcProgressRequest {
9752 })
9753 }
9754 }
9755 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9756 }
9757}
9758impl serde::Serialize for ListCdcProgressResponse {
9759 #[allow(deprecated)]
9760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9761 where
9762 S: serde::Serializer,
9763 {
9764 use serde::ser::SerializeStruct;
9765 let mut len = 0;
9766 if !self.cdc_progress.is_empty() {
9767 len += 1;
9768 }
9769 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9770 if !self.cdc_progress.is_empty() {
9771 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9772 }
9773 struct_ser.end()
9774 }
9775}
9776impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9777 #[allow(deprecated)]
9778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9779 where
9780 D: serde::Deserializer<'de>,
9781 {
9782 const FIELDS: &[&str] = &[
9783 "cdc_progress",
9784 "cdcProgress",
9785 ];
9786
9787 #[allow(clippy::enum_variant_names)]
9788 enum GeneratedField {
9789 CdcProgress,
9790 }
9791 impl<'de> serde::Deserialize<'de> for GeneratedField {
9792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9793 where
9794 D: serde::Deserializer<'de>,
9795 {
9796 struct GeneratedVisitor;
9797
9798 impl serde::de::Visitor<'_> for GeneratedVisitor {
9799 type Value = GeneratedField;
9800
9801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9802 write!(formatter, "expected one of: {:?}", &FIELDS)
9803 }
9804
9805 #[allow(unused_variables)]
9806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9807 where
9808 E: serde::de::Error,
9809 {
9810 match value {
9811 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9813 }
9814 }
9815 }
9816 deserializer.deserialize_identifier(GeneratedVisitor)
9817 }
9818 }
9819 struct GeneratedVisitor;
9820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9821 type Value = ListCdcProgressResponse;
9822
9823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9824 formatter.write_str("struct meta.ListCdcProgressResponse")
9825 }
9826
9827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
9828 where
9829 V: serde::de::MapAccess<'de>,
9830 {
9831 let mut cdc_progress__ = None;
9832 while let Some(k) = map_.next_key()? {
9833 match k {
9834 GeneratedField::CdcProgress => {
9835 if cdc_progress__.is_some() {
9836 return Err(serde::de::Error::duplicate_field("cdcProgress"));
9837 }
9838 cdc_progress__ = Some(
9839 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9840 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9841 );
9842 }
9843 }
9844 }
9845 Ok(ListCdcProgressResponse {
9846 cdc_progress: cdc_progress__.unwrap_or_default(),
9847 })
9848 }
9849 }
9850 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
9851 }
9852}
9853impl serde::Serialize for list_cdc_progress_response::CdcProgress {
9854 #[allow(deprecated)]
9855 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9856 where
9857 S: serde::Serializer,
9858 {
9859 use serde::ser::SerializeStruct;
9860 let mut len = 0;
9861 if self.split_total_count != 0 {
9862 len += 1;
9863 }
9864 if self.split_backfilled_count != 0 {
9865 len += 1;
9866 }
9867 if self.split_completed_count != 0 {
9868 len += 1;
9869 }
9870 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
9871 if self.split_total_count != 0 {
9872 #[allow(clippy::needless_borrow)]
9873 #[allow(clippy::needless_borrows_for_generic_args)]
9874 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
9875 }
9876 if self.split_backfilled_count != 0 {
9877 #[allow(clippy::needless_borrow)]
9878 #[allow(clippy::needless_borrows_for_generic_args)]
9879 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
9880 }
9881 if self.split_completed_count != 0 {
9882 #[allow(clippy::needless_borrow)]
9883 #[allow(clippy::needless_borrows_for_generic_args)]
9884 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
9885 }
9886 struct_ser.end()
9887 }
9888}
9889impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
9890 #[allow(deprecated)]
9891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9892 where
9893 D: serde::Deserializer<'de>,
9894 {
9895 const FIELDS: &[&str] = &[
9896 "split_total_count",
9897 "splitTotalCount",
9898 "split_backfilled_count",
9899 "splitBackfilledCount",
9900 "split_completed_count",
9901 "splitCompletedCount",
9902 ];
9903
9904 #[allow(clippy::enum_variant_names)]
9905 enum GeneratedField {
9906 SplitTotalCount,
9907 SplitBackfilledCount,
9908 SplitCompletedCount,
9909 }
9910 impl<'de> serde::Deserialize<'de> for GeneratedField {
9911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9912 where
9913 D: serde::Deserializer<'de>,
9914 {
9915 struct GeneratedVisitor;
9916
9917 impl serde::de::Visitor<'_> for GeneratedVisitor {
9918 type Value = GeneratedField;
9919
9920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9921 write!(formatter, "expected one of: {:?}", &FIELDS)
9922 }
9923
9924 #[allow(unused_variables)]
9925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9926 where
9927 E: serde::de::Error,
9928 {
9929 match value {
9930 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
9931 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
9932 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
9933 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9934 }
9935 }
9936 }
9937 deserializer.deserialize_identifier(GeneratedVisitor)
9938 }
9939 }
9940 struct GeneratedVisitor;
9941 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9942 type Value = list_cdc_progress_response::CdcProgress;
9943
9944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9945 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
9946 }
9947
9948 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
9949 where
9950 V: serde::de::MapAccess<'de>,
9951 {
9952 let mut split_total_count__ = None;
9953 let mut split_backfilled_count__ = None;
9954 let mut split_completed_count__ = None;
9955 while let Some(k) = map_.next_key()? {
9956 match k {
9957 GeneratedField::SplitTotalCount => {
9958 if split_total_count__.is_some() {
9959 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9960 }
9961 split_total_count__ =
9962 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9963 ;
9964 }
9965 GeneratedField::SplitBackfilledCount => {
9966 if split_backfilled_count__.is_some() {
9967 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9968 }
9969 split_backfilled_count__ =
9970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9971 ;
9972 }
9973 GeneratedField::SplitCompletedCount => {
9974 if split_completed_count__.is_some() {
9975 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9976 }
9977 split_completed_count__ =
9978 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9979 ;
9980 }
9981 }
9982 }
9983 Ok(list_cdc_progress_response::CdcProgress {
9984 split_total_count: split_total_count__.unwrap_or_default(),
9985 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9986 split_completed_count: split_completed_count__.unwrap_or_default(),
9987 })
9988 }
9989 }
9990 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9991 }
9992}
9993impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9994 #[allow(deprecated)]
9995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9996 where
9997 S: serde::Serializer,
9998 {
9999 use serde::ser::SerializeStruct;
10000 let mut len = 0;
10001 if self.include_node.is_some() {
10002 len += 1;
10003 }
10004 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
10005 if let Some(v) = self.include_node.as_ref() {
10006 struct_ser.serialize_field("includeNode", v)?;
10007 }
10008 struct_ser.end()
10009 }
10010}
10011impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
10012 #[allow(deprecated)]
10013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10014 where
10015 D: serde::Deserializer<'de>,
10016 {
10017 const FIELDS: &[&str] = &[
10018 "include_node",
10019 "includeNode",
10020 ];
10021
10022 #[allow(clippy::enum_variant_names)]
10023 enum GeneratedField {
10024 IncludeNode,
10025 }
10026 impl<'de> serde::Deserialize<'de> for GeneratedField {
10027 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10028 where
10029 D: serde::Deserializer<'de>,
10030 {
10031 struct GeneratedVisitor;
10032
10033 impl serde::de::Visitor<'_> for GeneratedVisitor {
10034 type Value = GeneratedField;
10035
10036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10037 write!(formatter, "expected one of: {:?}", &FIELDS)
10038 }
10039
10040 #[allow(unused_variables)]
10041 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10042 where
10043 E: serde::de::Error,
10044 {
10045 match value {
10046 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10048 }
10049 }
10050 }
10051 deserializer.deserialize_identifier(GeneratedVisitor)
10052 }
10053 }
10054 struct GeneratedVisitor;
10055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10056 type Value = ListCreatingFragmentDistributionRequest;
10057
10058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10059 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
10060 }
10061
10062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
10063 where
10064 V: serde::de::MapAccess<'de>,
10065 {
10066 let mut include_node__ = None;
10067 while let Some(k) = map_.next_key()? {
10068 match k {
10069 GeneratedField::IncludeNode => {
10070 if include_node__.is_some() {
10071 return Err(serde::de::Error::duplicate_field("includeNode"));
10072 }
10073 include_node__ = map_.next_value()?;
10074 }
10075 }
10076 }
10077 Ok(ListCreatingFragmentDistributionRequest {
10078 include_node: include_node__,
10079 })
10080 }
10081 }
10082 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10083 }
10084}
10085impl serde::Serialize for ListCreatingFragmentDistributionResponse {
10086 #[allow(deprecated)]
10087 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10088 where
10089 S: serde::Serializer,
10090 {
10091 use serde::ser::SerializeStruct;
10092 let mut len = 0;
10093 if !self.distributions.is_empty() {
10094 len += 1;
10095 }
10096 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
10097 if !self.distributions.is_empty() {
10098 struct_ser.serialize_field("distributions", &self.distributions)?;
10099 }
10100 struct_ser.end()
10101 }
10102}
10103impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
10104 #[allow(deprecated)]
10105 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10106 where
10107 D: serde::Deserializer<'de>,
10108 {
10109 const FIELDS: &[&str] = &[
10110 "distributions",
10111 ];
10112
10113 #[allow(clippy::enum_variant_names)]
10114 enum GeneratedField {
10115 Distributions,
10116 }
10117 impl<'de> serde::Deserialize<'de> for GeneratedField {
10118 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10119 where
10120 D: serde::Deserializer<'de>,
10121 {
10122 struct GeneratedVisitor;
10123
10124 impl serde::de::Visitor<'_> for GeneratedVisitor {
10125 type Value = GeneratedField;
10126
10127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10128 write!(formatter, "expected one of: {:?}", &FIELDS)
10129 }
10130
10131 #[allow(unused_variables)]
10132 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10133 where
10134 E: serde::de::Error,
10135 {
10136 match value {
10137 "distributions" => Ok(GeneratedField::Distributions),
10138 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10139 }
10140 }
10141 }
10142 deserializer.deserialize_identifier(GeneratedVisitor)
10143 }
10144 }
10145 struct GeneratedVisitor;
10146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10147 type Value = ListCreatingFragmentDistributionResponse;
10148
10149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10150 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
10151 }
10152
10153 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
10154 where
10155 V: serde::de::MapAccess<'de>,
10156 {
10157 let mut distributions__ = None;
10158 while let Some(k) = map_.next_key()? {
10159 match k {
10160 GeneratedField::Distributions => {
10161 if distributions__.is_some() {
10162 return Err(serde::de::Error::duplicate_field("distributions"));
10163 }
10164 distributions__ = Some(map_.next_value()?);
10165 }
10166 }
10167 }
10168 Ok(ListCreatingFragmentDistributionResponse {
10169 distributions: distributions__.unwrap_or_default(),
10170 })
10171 }
10172 }
10173 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10174 }
10175}
10176impl serde::Serialize for ListEventLogRequest {
10177 #[allow(deprecated)]
10178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10179 where
10180 S: serde::Serializer,
10181 {
10182 use serde::ser::SerializeStruct;
10183 let len = 0;
10184 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
10185 struct_ser.end()
10186 }
10187}
10188impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
10189 #[allow(deprecated)]
10190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10191 where
10192 D: serde::Deserializer<'de>,
10193 {
10194 const FIELDS: &[&str] = &[
10195 ];
10196
10197 #[allow(clippy::enum_variant_names)]
10198 enum GeneratedField {
10199 }
10200 impl<'de> serde::Deserialize<'de> for GeneratedField {
10201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10202 where
10203 D: serde::Deserializer<'de>,
10204 {
10205 struct GeneratedVisitor;
10206
10207 impl serde::de::Visitor<'_> for GeneratedVisitor {
10208 type Value = GeneratedField;
10209
10210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10211 write!(formatter, "expected one of: {:?}", &FIELDS)
10212 }
10213
10214 #[allow(unused_variables)]
10215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10216 where
10217 E: serde::de::Error,
10218 {
10219 Err(serde::de::Error::unknown_field(value, FIELDS))
10220 }
10221 }
10222 deserializer.deserialize_identifier(GeneratedVisitor)
10223 }
10224 }
10225 struct GeneratedVisitor;
10226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10227 type Value = ListEventLogRequest;
10228
10229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10230 formatter.write_str("struct meta.ListEventLogRequest")
10231 }
10232
10233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
10234 where
10235 V: serde::de::MapAccess<'de>,
10236 {
10237 while map_.next_key::<GeneratedField>()?.is_some() {
10238 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10239 }
10240 Ok(ListEventLogRequest {
10241 })
10242 }
10243 }
10244 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
10245 }
10246}
10247impl serde::Serialize for ListEventLogResponse {
10248 #[allow(deprecated)]
10249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10250 where
10251 S: serde::Serializer,
10252 {
10253 use serde::ser::SerializeStruct;
10254 let mut len = 0;
10255 if !self.event_logs.is_empty() {
10256 len += 1;
10257 }
10258 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
10259 if !self.event_logs.is_empty() {
10260 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
10261 }
10262 struct_ser.end()
10263 }
10264}
10265impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
10266 #[allow(deprecated)]
10267 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10268 where
10269 D: serde::Deserializer<'de>,
10270 {
10271 const FIELDS: &[&str] = &[
10272 "event_logs",
10273 "eventLogs",
10274 ];
10275
10276 #[allow(clippy::enum_variant_names)]
10277 enum GeneratedField {
10278 EventLogs,
10279 }
10280 impl<'de> serde::Deserialize<'de> for GeneratedField {
10281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10282 where
10283 D: serde::Deserializer<'de>,
10284 {
10285 struct GeneratedVisitor;
10286
10287 impl serde::de::Visitor<'_> for GeneratedVisitor {
10288 type Value = GeneratedField;
10289
10290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10291 write!(formatter, "expected one of: {:?}", &FIELDS)
10292 }
10293
10294 #[allow(unused_variables)]
10295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10296 where
10297 E: serde::de::Error,
10298 {
10299 match value {
10300 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
10301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10302 }
10303 }
10304 }
10305 deserializer.deserialize_identifier(GeneratedVisitor)
10306 }
10307 }
10308 struct GeneratedVisitor;
10309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10310 type Value = ListEventLogResponse;
10311
10312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10313 formatter.write_str("struct meta.ListEventLogResponse")
10314 }
10315
10316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
10317 where
10318 V: serde::de::MapAccess<'de>,
10319 {
10320 let mut event_logs__ = None;
10321 while let Some(k) = map_.next_key()? {
10322 match k {
10323 GeneratedField::EventLogs => {
10324 if event_logs__.is_some() {
10325 return Err(serde::de::Error::duplicate_field("eventLogs"));
10326 }
10327 event_logs__ = Some(map_.next_value()?);
10328 }
10329 }
10330 }
10331 Ok(ListEventLogResponse {
10332 event_logs: event_logs__.unwrap_or_default(),
10333 })
10334 }
10335 }
10336 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
10337 }
10338}
10339impl serde::Serialize for ListFragmentDistributionRequest {
10340 #[allow(deprecated)]
10341 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10342 where
10343 S: serde::Serializer,
10344 {
10345 use serde::ser::SerializeStruct;
10346 let mut len = 0;
10347 if self.include_node.is_some() {
10348 len += 1;
10349 }
10350 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
10351 if let Some(v) = self.include_node.as_ref() {
10352 struct_ser.serialize_field("includeNode", v)?;
10353 }
10354 struct_ser.end()
10355 }
10356}
10357impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
10358 #[allow(deprecated)]
10359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10360 where
10361 D: serde::Deserializer<'de>,
10362 {
10363 const FIELDS: &[&str] = &[
10364 "include_node",
10365 "includeNode",
10366 ];
10367
10368 #[allow(clippy::enum_variant_names)]
10369 enum GeneratedField {
10370 IncludeNode,
10371 }
10372 impl<'de> serde::Deserialize<'de> for GeneratedField {
10373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10374 where
10375 D: serde::Deserializer<'de>,
10376 {
10377 struct GeneratedVisitor;
10378
10379 impl serde::de::Visitor<'_> for GeneratedVisitor {
10380 type Value = GeneratedField;
10381
10382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10383 write!(formatter, "expected one of: {:?}", &FIELDS)
10384 }
10385
10386 #[allow(unused_variables)]
10387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10388 where
10389 E: serde::de::Error,
10390 {
10391 match value {
10392 "includeNode" | "include_node" => Ok(GeneratedField::IncludeNode),
10393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10394 }
10395 }
10396 }
10397 deserializer.deserialize_identifier(GeneratedVisitor)
10398 }
10399 }
10400 struct GeneratedVisitor;
10401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10402 type Value = ListFragmentDistributionRequest;
10403
10404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10405 formatter.write_str("struct meta.ListFragmentDistributionRequest")
10406 }
10407
10408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
10409 where
10410 V: serde::de::MapAccess<'de>,
10411 {
10412 let mut include_node__ = None;
10413 while let Some(k) = map_.next_key()? {
10414 match k {
10415 GeneratedField::IncludeNode => {
10416 if include_node__.is_some() {
10417 return Err(serde::de::Error::duplicate_field("includeNode"));
10418 }
10419 include_node__ = map_.next_value()?;
10420 }
10421 }
10422 }
10423 Ok(ListFragmentDistributionRequest {
10424 include_node: include_node__,
10425 })
10426 }
10427 }
10428 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
10429 }
10430}
10431impl serde::Serialize for ListFragmentDistributionResponse {
10432 #[allow(deprecated)]
10433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10434 where
10435 S: serde::Serializer,
10436 {
10437 use serde::ser::SerializeStruct;
10438 let mut len = 0;
10439 if !self.distributions.is_empty() {
10440 len += 1;
10441 }
10442 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
10443 if !self.distributions.is_empty() {
10444 struct_ser.serialize_field("distributions", &self.distributions)?;
10445 }
10446 struct_ser.end()
10447 }
10448}
10449impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
10450 #[allow(deprecated)]
10451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10452 where
10453 D: serde::Deserializer<'de>,
10454 {
10455 const FIELDS: &[&str] = &[
10456 "distributions",
10457 ];
10458
10459 #[allow(clippy::enum_variant_names)]
10460 enum GeneratedField {
10461 Distributions,
10462 }
10463 impl<'de> serde::Deserialize<'de> for GeneratedField {
10464 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10465 where
10466 D: serde::Deserializer<'de>,
10467 {
10468 struct GeneratedVisitor;
10469
10470 impl serde::de::Visitor<'_> for GeneratedVisitor {
10471 type Value = GeneratedField;
10472
10473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10474 write!(formatter, "expected one of: {:?}", &FIELDS)
10475 }
10476
10477 #[allow(unused_variables)]
10478 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10479 where
10480 E: serde::de::Error,
10481 {
10482 match value {
10483 "distributions" => Ok(GeneratedField::Distributions),
10484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10485 }
10486 }
10487 }
10488 deserializer.deserialize_identifier(GeneratedVisitor)
10489 }
10490 }
10491 struct GeneratedVisitor;
10492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10493 type Value = ListFragmentDistributionResponse;
10494
10495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10496 formatter.write_str("struct meta.ListFragmentDistributionResponse")
10497 }
10498
10499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
10500 where
10501 V: serde::de::MapAccess<'de>,
10502 {
10503 let mut distributions__ = None;
10504 while let Some(k) = map_.next_key()? {
10505 match k {
10506 GeneratedField::Distributions => {
10507 if distributions__.is_some() {
10508 return Err(serde::de::Error::duplicate_field("distributions"));
10509 }
10510 distributions__ = Some(map_.next_value()?);
10511 }
10512 }
10513 }
10514 Ok(ListFragmentDistributionResponse {
10515 distributions: distributions__.unwrap_or_default(),
10516 })
10517 }
10518 }
10519 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10520 }
10521}
10522impl serde::Serialize for ListIcebergCompactionStatusRequest {
10523 #[allow(deprecated)]
10524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10525 where
10526 S: serde::Serializer,
10527 {
10528 use serde::ser::SerializeStruct;
10529 let len = 0;
10530 let struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusRequest", len)?;
10531 struct_ser.end()
10532 }
10533}
10534impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusRequest {
10535 #[allow(deprecated)]
10536 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10537 where
10538 D: serde::Deserializer<'de>,
10539 {
10540 const FIELDS: &[&str] = &[
10541 ];
10542
10543 #[allow(clippy::enum_variant_names)]
10544 enum GeneratedField {
10545 }
10546 impl<'de> serde::Deserialize<'de> for GeneratedField {
10547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10548 where
10549 D: serde::Deserializer<'de>,
10550 {
10551 struct GeneratedVisitor;
10552
10553 impl serde::de::Visitor<'_> for GeneratedVisitor {
10554 type Value = GeneratedField;
10555
10556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10557 write!(formatter, "expected one of: {:?}", &FIELDS)
10558 }
10559
10560 #[allow(unused_variables)]
10561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10562 where
10563 E: serde::de::Error,
10564 {
10565 Err(serde::de::Error::unknown_field(value, FIELDS))
10566 }
10567 }
10568 deserializer.deserialize_identifier(GeneratedVisitor)
10569 }
10570 }
10571 struct GeneratedVisitor;
10572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10573 type Value = ListIcebergCompactionStatusRequest;
10574
10575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10576 formatter.write_str("struct meta.ListIcebergCompactionStatusRequest")
10577 }
10578
10579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusRequest, V::Error>
10580 where
10581 V: serde::de::MapAccess<'de>,
10582 {
10583 while map_.next_key::<GeneratedField>()?.is_some() {
10584 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10585 }
10586 Ok(ListIcebergCompactionStatusRequest {
10587 })
10588 }
10589 }
10590 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusRequest", FIELDS, GeneratedVisitor)
10591 }
10592}
10593impl serde::Serialize for ListIcebergCompactionStatusResponse {
10594 #[allow(deprecated)]
10595 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10596 where
10597 S: serde::Serializer,
10598 {
10599 use serde::ser::SerializeStruct;
10600 let mut len = 0;
10601 if !self.statuses.is_empty() {
10602 len += 1;
10603 }
10604 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse", len)?;
10605 if !self.statuses.is_empty() {
10606 struct_ser.serialize_field("statuses", &self.statuses)?;
10607 }
10608 struct_ser.end()
10609 }
10610}
10611impl<'de> serde::Deserialize<'de> for ListIcebergCompactionStatusResponse {
10612 #[allow(deprecated)]
10613 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10614 where
10615 D: serde::Deserializer<'de>,
10616 {
10617 const FIELDS: &[&str] = &[
10618 "statuses",
10619 ];
10620
10621 #[allow(clippy::enum_variant_names)]
10622 enum GeneratedField {
10623 Statuses,
10624 }
10625 impl<'de> serde::Deserialize<'de> for GeneratedField {
10626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10627 where
10628 D: serde::Deserializer<'de>,
10629 {
10630 struct GeneratedVisitor;
10631
10632 impl serde::de::Visitor<'_> for GeneratedVisitor {
10633 type Value = GeneratedField;
10634
10635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10636 write!(formatter, "expected one of: {:?}", &FIELDS)
10637 }
10638
10639 #[allow(unused_variables)]
10640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10641 where
10642 E: serde::de::Error,
10643 {
10644 match value {
10645 "statuses" => Ok(GeneratedField::Statuses),
10646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10647 }
10648 }
10649 }
10650 deserializer.deserialize_identifier(GeneratedVisitor)
10651 }
10652 }
10653 struct GeneratedVisitor;
10654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10655 type Value = ListIcebergCompactionStatusResponse;
10656
10657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10658 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse")
10659 }
10660
10661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergCompactionStatusResponse, V::Error>
10662 where
10663 V: serde::de::MapAccess<'de>,
10664 {
10665 let mut statuses__ = None;
10666 while let Some(k) = map_.next_key()? {
10667 match k {
10668 GeneratedField::Statuses => {
10669 if statuses__.is_some() {
10670 return Err(serde::de::Error::duplicate_field("statuses"));
10671 }
10672 statuses__ = Some(map_.next_value()?);
10673 }
10674 }
10675 }
10676 Ok(ListIcebergCompactionStatusResponse {
10677 statuses: statuses__.unwrap_or_default(),
10678 })
10679 }
10680 }
10681 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse", FIELDS, GeneratedVisitor)
10682 }
10683}
10684impl serde::Serialize for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10685 #[allow(deprecated)]
10686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10687 where
10688 S: serde::Serializer,
10689 {
10690 use serde::ser::SerializeStruct;
10691 let mut len = 0;
10692 if self.sink_id != 0 {
10693 len += 1;
10694 }
10695 if !self.task_type.is_empty() {
10696 len += 1;
10697 }
10698 if self.trigger_interval_sec != 0 {
10699 len += 1;
10700 }
10701 if self.trigger_snapshot_count != 0 {
10702 len += 1;
10703 }
10704 if !self.schedule_state.is_empty() {
10705 len += 1;
10706 }
10707 if self.next_compaction_after_sec.is_some() {
10708 len += 1;
10709 }
10710 if self.pending_snapshot_count.is_some() {
10711 len += 1;
10712 }
10713 if self.is_triggerable {
10714 len += 1;
10715 }
10716 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", len)?;
10717 if self.sink_id != 0 {
10718 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10719 }
10720 if !self.task_type.is_empty() {
10721 struct_ser.serialize_field("taskType", &self.task_type)?;
10722 }
10723 if self.trigger_interval_sec != 0 {
10724 #[allow(clippy::needless_borrow)]
10725 #[allow(clippy::needless_borrows_for_generic_args)]
10726 struct_ser.serialize_field("triggerIntervalSec", ToString::to_string(&self.trigger_interval_sec).as_str())?;
10727 }
10728 if self.trigger_snapshot_count != 0 {
10729 #[allow(clippy::needless_borrow)]
10730 #[allow(clippy::needless_borrows_for_generic_args)]
10731 struct_ser.serialize_field("triggerSnapshotCount", ToString::to_string(&self.trigger_snapshot_count).as_str())?;
10732 }
10733 if !self.schedule_state.is_empty() {
10734 struct_ser.serialize_field("scheduleState", &self.schedule_state)?;
10735 }
10736 if let Some(v) = self.next_compaction_after_sec.as_ref() {
10737 #[allow(clippy::needless_borrow)]
10738 #[allow(clippy::needless_borrows_for_generic_args)]
10739 struct_ser.serialize_field("nextCompactionAfterSec", ToString::to_string(&v).as_str())?;
10740 }
10741 if let Some(v) = self.pending_snapshot_count.as_ref() {
10742 #[allow(clippy::needless_borrow)]
10743 #[allow(clippy::needless_borrows_for_generic_args)]
10744 struct_ser.serialize_field("pendingSnapshotCount", ToString::to_string(&v).as_str())?;
10745 }
10746 if self.is_triggerable {
10747 struct_ser.serialize_field("isTriggerable", &self.is_triggerable)?;
10748 }
10749 struct_ser.end()
10750 }
10751}
10752impl<'de> serde::Deserialize<'de> for list_iceberg_compaction_status_response::IcebergCompactionStatus {
10753 #[allow(deprecated)]
10754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10755 where
10756 D: serde::Deserializer<'de>,
10757 {
10758 const FIELDS: &[&str] = &[
10759 "sink_id",
10760 "sinkId",
10761 "task_type",
10762 "taskType",
10763 "trigger_interval_sec",
10764 "triggerIntervalSec",
10765 "trigger_snapshot_count",
10766 "triggerSnapshotCount",
10767 "schedule_state",
10768 "scheduleState",
10769 "next_compaction_after_sec",
10770 "nextCompactionAfterSec",
10771 "pending_snapshot_count",
10772 "pendingSnapshotCount",
10773 "is_triggerable",
10774 "isTriggerable",
10775 ];
10776
10777 #[allow(clippy::enum_variant_names)]
10778 enum GeneratedField {
10779 SinkId,
10780 TaskType,
10781 TriggerIntervalSec,
10782 TriggerSnapshotCount,
10783 ScheduleState,
10784 NextCompactionAfterSec,
10785 PendingSnapshotCount,
10786 IsTriggerable,
10787 }
10788 impl<'de> serde::Deserialize<'de> for GeneratedField {
10789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10790 where
10791 D: serde::Deserializer<'de>,
10792 {
10793 struct GeneratedVisitor;
10794
10795 impl serde::de::Visitor<'_> for GeneratedVisitor {
10796 type Value = GeneratedField;
10797
10798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10799 write!(formatter, "expected one of: {:?}", &FIELDS)
10800 }
10801
10802 #[allow(unused_variables)]
10803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10804 where
10805 E: serde::de::Error,
10806 {
10807 match value {
10808 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10809 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
10810 "triggerIntervalSec" | "trigger_interval_sec" => Ok(GeneratedField::TriggerIntervalSec),
10811 "triggerSnapshotCount" | "trigger_snapshot_count" => Ok(GeneratedField::TriggerSnapshotCount),
10812 "scheduleState" | "schedule_state" => Ok(GeneratedField::ScheduleState),
10813 "nextCompactionAfterSec" | "next_compaction_after_sec" => Ok(GeneratedField::NextCompactionAfterSec),
10814 "pendingSnapshotCount" | "pending_snapshot_count" => Ok(GeneratedField::PendingSnapshotCount),
10815 "isTriggerable" | "is_triggerable" => Ok(GeneratedField::IsTriggerable),
10816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10817 }
10818 }
10819 }
10820 deserializer.deserialize_identifier(GeneratedVisitor)
10821 }
10822 }
10823 struct GeneratedVisitor;
10824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10825 type Value = list_iceberg_compaction_status_response::IcebergCompactionStatus;
10826
10827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10828 formatter.write_str("struct meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus")
10829 }
10830
10831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_compaction_status_response::IcebergCompactionStatus, V::Error>
10832 where
10833 V: serde::de::MapAccess<'de>,
10834 {
10835 let mut sink_id__ = None;
10836 let mut task_type__ = None;
10837 let mut trigger_interval_sec__ = None;
10838 let mut trigger_snapshot_count__ = None;
10839 let mut schedule_state__ = None;
10840 let mut next_compaction_after_sec__ = None;
10841 let mut pending_snapshot_count__ = None;
10842 let mut is_triggerable__ = None;
10843 while let Some(k) = map_.next_key()? {
10844 match k {
10845 GeneratedField::SinkId => {
10846 if sink_id__.is_some() {
10847 return Err(serde::de::Error::duplicate_field("sinkId"));
10848 }
10849 sink_id__ =
10850 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10851 ;
10852 }
10853 GeneratedField::TaskType => {
10854 if task_type__.is_some() {
10855 return Err(serde::de::Error::duplicate_field("taskType"));
10856 }
10857 task_type__ = Some(map_.next_value()?);
10858 }
10859 GeneratedField::TriggerIntervalSec => {
10860 if trigger_interval_sec__.is_some() {
10861 return Err(serde::de::Error::duplicate_field("triggerIntervalSec"));
10862 }
10863 trigger_interval_sec__ =
10864 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10865 ;
10866 }
10867 GeneratedField::TriggerSnapshotCount => {
10868 if trigger_snapshot_count__.is_some() {
10869 return Err(serde::de::Error::duplicate_field("triggerSnapshotCount"));
10870 }
10871 trigger_snapshot_count__ =
10872 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10873 ;
10874 }
10875 GeneratedField::ScheduleState => {
10876 if schedule_state__.is_some() {
10877 return Err(serde::de::Error::duplicate_field("scheduleState"));
10878 }
10879 schedule_state__ = Some(map_.next_value()?);
10880 }
10881 GeneratedField::NextCompactionAfterSec => {
10882 if next_compaction_after_sec__.is_some() {
10883 return Err(serde::de::Error::duplicate_field("nextCompactionAfterSec"));
10884 }
10885 next_compaction_after_sec__ =
10886 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10887 ;
10888 }
10889 GeneratedField::PendingSnapshotCount => {
10890 if pending_snapshot_count__.is_some() {
10891 return Err(serde::de::Error::duplicate_field("pendingSnapshotCount"));
10892 }
10893 pending_snapshot_count__ =
10894 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10895 ;
10896 }
10897 GeneratedField::IsTriggerable => {
10898 if is_triggerable__.is_some() {
10899 return Err(serde::de::Error::duplicate_field("isTriggerable"));
10900 }
10901 is_triggerable__ = Some(map_.next_value()?);
10902 }
10903 }
10904 }
10905 Ok(list_iceberg_compaction_status_response::IcebergCompactionStatus {
10906 sink_id: sink_id__.unwrap_or_default(),
10907 task_type: task_type__.unwrap_or_default(),
10908 trigger_interval_sec: trigger_interval_sec__.unwrap_or_default(),
10909 trigger_snapshot_count: trigger_snapshot_count__.unwrap_or_default(),
10910 schedule_state: schedule_state__.unwrap_or_default(),
10911 next_compaction_after_sec: next_compaction_after_sec__,
10912 pending_snapshot_count: pending_snapshot_count__,
10913 is_triggerable: is_triggerable__.unwrap_or_default(),
10914 })
10915 }
10916 }
10917 deserializer.deserialize_struct("meta.ListIcebergCompactionStatusResponse.IcebergCompactionStatus", FIELDS, GeneratedVisitor)
10918 }
10919}
10920impl serde::Serialize for ListIcebergTablesRequest {
10921 #[allow(deprecated)]
10922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10923 where
10924 S: serde::Serializer,
10925 {
10926 use serde::ser::SerializeStruct;
10927 let len = 0;
10928 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
10929 struct_ser.end()
10930 }
10931}
10932impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
10933 #[allow(deprecated)]
10934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10935 where
10936 D: serde::Deserializer<'de>,
10937 {
10938 const FIELDS: &[&str] = &[
10939 ];
10940
10941 #[allow(clippy::enum_variant_names)]
10942 enum GeneratedField {
10943 }
10944 impl<'de> serde::Deserialize<'de> for GeneratedField {
10945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10946 where
10947 D: serde::Deserializer<'de>,
10948 {
10949 struct GeneratedVisitor;
10950
10951 impl serde::de::Visitor<'_> for GeneratedVisitor {
10952 type Value = GeneratedField;
10953
10954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10955 write!(formatter, "expected one of: {:?}", &FIELDS)
10956 }
10957
10958 #[allow(unused_variables)]
10959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10960 where
10961 E: serde::de::Error,
10962 {
10963 Err(serde::de::Error::unknown_field(value, FIELDS))
10964 }
10965 }
10966 deserializer.deserialize_identifier(GeneratedVisitor)
10967 }
10968 }
10969 struct GeneratedVisitor;
10970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10971 type Value = ListIcebergTablesRequest;
10972
10973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10974 formatter.write_str("struct meta.ListIcebergTablesRequest")
10975 }
10976
10977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
10978 where
10979 V: serde::de::MapAccess<'de>,
10980 {
10981 while map_.next_key::<GeneratedField>()?.is_some() {
10982 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10983 }
10984 Ok(ListIcebergTablesRequest {
10985 })
10986 }
10987 }
10988 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
10989 }
10990}
10991impl serde::Serialize for ListIcebergTablesResponse {
10992 #[allow(deprecated)]
10993 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10994 where
10995 S: serde::Serializer,
10996 {
10997 use serde::ser::SerializeStruct;
10998 let mut len = 0;
10999 if !self.iceberg_tables.is_empty() {
11000 len += 1;
11001 }
11002 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
11003 if !self.iceberg_tables.is_empty() {
11004 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
11005 }
11006 struct_ser.end()
11007 }
11008}
11009impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
11010 #[allow(deprecated)]
11011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11012 where
11013 D: serde::Deserializer<'de>,
11014 {
11015 const FIELDS: &[&str] = &[
11016 "iceberg_tables",
11017 "icebergTables",
11018 ];
11019
11020 #[allow(clippy::enum_variant_names)]
11021 enum GeneratedField {
11022 IcebergTables,
11023 }
11024 impl<'de> serde::Deserialize<'de> for GeneratedField {
11025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11026 where
11027 D: serde::Deserializer<'de>,
11028 {
11029 struct GeneratedVisitor;
11030
11031 impl serde::de::Visitor<'_> for GeneratedVisitor {
11032 type Value = GeneratedField;
11033
11034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11035 write!(formatter, "expected one of: {:?}", &FIELDS)
11036 }
11037
11038 #[allow(unused_variables)]
11039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11040 where
11041 E: serde::de::Error,
11042 {
11043 match value {
11044 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
11045 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11046 }
11047 }
11048 }
11049 deserializer.deserialize_identifier(GeneratedVisitor)
11050 }
11051 }
11052 struct GeneratedVisitor;
11053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11054 type Value = ListIcebergTablesResponse;
11055
11056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11057 formatter.write_str("struct meta.ListIcebergTablesResponse")
11058 }
11059
11060 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
11061 where
11062 V: serde::de::MapAccess<'de>,
11063 {
11064 let mut iceberg_tables__ = None;
11065 while let Some(k) = map_.next_key()? {
11066 match k {
11067 GeneratedField::IcebergTables => {
11068 if iceberg_tables__.is_some() {
11069 return Err(serde::de::Error::duplicate_field("icebergTables"));
11070 }
11071 iceberg_tables__ = Some(map_.next_value()?);
11072 }
11073 }
11074 }
11075 Ok(ListIcebergTablesResponse {
11076 iceberg_tables: iceberg_tables__.unwrap_or_default(),
11077 })
11078 }
11079 }
11080 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
11081 }
11082}
11083impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
11084 #[allow(deprecated)]
11085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11086 where
11087 S: serde::Serializer,
11088 {
11089 use serde::ser::SerializeStruct;
11090 let mut len = 0;
11091 if !self.catalog_name.is_empty() {
11092 len += 1;
11093 }
11094 if !self.table_namespace.is_empty() {
11095 len += 1;
11096 }
11097 if !self.table_name.is_empty() {
11098 len += 1;
11099 }
11100 if self.metadata_location.is_some() {
11101 len += 1;
11102 }
11103 if self.previous_metadata_location.is_some() {
11104 len += 1;
11105 }
11106 if self.iceberg_type.is_some() {
11107 len += 1;
11108 }
11109 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
11110 if !self.catalog_name.is_empty() {
11111 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
11112 }
11113 if !self.table_namespace.is_empty() {
11114 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
11115 }
11116 if !self.table_name.is_empty() {
11117 struct_ser.serialize_field("tableName", &self.table_name)?;
11118 }
11119 if let Some(v) = self.metadata_location.as_ref() {
11120 struct_ser.serialize_field("metadataLocation", v)?;
11121 }
11122 if let Some(v) = self.previous_metadata_location.as_ref() {
11123 struct_ser.serialize_field("previousMetadataLocation", v)?;
11124 }
11125 if let Some(v) = self.iceberg_type.as_ref() {
11126 struct_ser.serialize_field("icebergType", v)?;
11127 }
11128 struct_ser.end()
11129 }
11130}
11131impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
11132 #[allow(deprecated)]
11133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11134 where
11135 D: serde::Deserializer<'de>,
11136 {
11137 const FIELDS: &[&str] = &[
11138 "catalog_name",
11139 "catalogName",
11140 "table_namespace",
11141 "tableNamespace",
11142 "table_name",
11143 "tableName",
11144 "metadata_location",
11145 "metadataLocation",
11146 "previous_metadata_location",
11147 "previousMetadataLocation",
11148 "iceberg_type",
11149 "icebergType",
11150 ];
11151
11152 #[allow(clippy::enum_variant_names)]
11153 enum GeneratedField {
11154 CatalogName,
11155 TableNamespace,
11156 TableName,
11157 MetadataLocation,
11158 PreviousMetadataLocation,
11159 IcebergType,
11160 }
11161 impl<'de> serde::Deserialize<'de> for GeneratedField {
11162 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11163 where
11164 D: serde::Deserializer<'de>,
11165 {
11166 struct GeneratedVisitor;
11167
11168 impl serde::de::Visitor<'_> for GeneratedVisitor {
11169 type Value = GeneratedField;
11170
11171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11172 write!(formatter, "expected one of: {:?}", &FIELDS)
11173 }
11174
11175 #[allow(unused_variables)]
11176 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11177 where
11178 E: serde::de::Error,
11179 {
11180 match value {
11181 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
11182 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
11183 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11184 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
11185 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
11186 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
11187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11188 }
11189 }
11190 }
11191 deserializer.deserialize_identifier(GeneratedVisitor)
11192 }
11193 }
11194 struct GeneratedVisitor;
11195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11196 type Value = list_iceberg_tables_response::IcebergTable;
11197
11198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11199 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
11200 }
11201
11202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
11203 where
11204 V: serde::de::MapAccess<'de>,
11205 {
11206 let mut catalog_name__ = None;
11207 let mut table_namespace__ = None;
11208 let mut table_name__ = None;
11209 let mut metadata_location__ = None;
11210 let mut previous_metadata_location__ = None;
11211 let mut iceberg_type__ = None;
11212 while let Some(k) = map_.next_key()? {
11213 match k {
11214 GeneratedField::CatalogName => {
11215 if catalog_name__.is_some() {
11216 return Err(serde::de::Error::duplicate_field("catalogName"));
11217 }
11218 catalog_name__ = Some(map_.next_value()?);
11219 }
11220 GeneratedField::TableNamespace => {
11221 if table_namespace__.is_some() {
11222 return Err(serde::de::Error::duplicate_field("tableNamespace"));
11223 }
11224 table_namespace__ = Some(map_.next_value()?);
11225 }
11226 GeneratedField::TableName => {
11227 if table_name__.is_some() {
11228 return Err(serde::de::Error::duplicate_field("tableName"));
11229 }
11230 table_name__ = Some(map_.next_value()?);
11231 }
11232 GeneratedField::MetadataLocation => {
11233 if metadata_location__.is_some() {
11234 return Err(serde::de::Error::duplicate_field("metadataLocation"));
11235 }
11236 metadata_location__ = map_.next_value()?;
11237 }
11238 GeneratedField::PreviousMetadataLocation => {
11239 if previous_metadata_location__.is_some() {
11240 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
11241 }
11242 previous_metadata_location__ = map_.next_value()?;
11243 }
11244 GeneratedField::IcebergType => {
11245 if iceberg_type__.is_some() {
11246 return Err(serde::de::Error::duplicate_field("icebergType"));
11247 }
11248 iceberg_type__ = map_.next_value()?;
11249 }
11250 }
11251 }
11252 Ok(list_iceberg_tables_response::IcebergTable {
11253 catalog_name: catalog_name__.unwrap_or_default(),
11254 table_namespace: table_namespace__.unwrap_or_default(),
11255 table_name: table_name__.unwrap_or_default(),
11256 metadata_location: metadata_location__,
11257 previous_metadata_location: previous_metadata_location__,
11258 iceberg_type: iceberg_type__,
11259 })
11260 }
11261 }
11262 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
11263 }
11264}
11265impl serde::Serialize for ListRateLimitsRequest {
11266 #[allow(deprecated)]
11267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11268 where
11269 S: serde::Serializer,
11270 {
11271 use serde::ser::SerializeStruct;
11272 let len = 0;
11273 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
11274 struct_ser.end()
11275 }
11276}
11277impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
11278 #[allow(deprecated)]
11279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11280 where
11281 D: serde::Deserializer<'de>,
11282 {
11283 const FIELDS: &[&str] = &[
11284 ];
11285
11286 #[allow(clippy::enum_variant_names)]
11287 enum GeneratedField {
11288 }
11289 impl<'de> serde::Deserialize<'de> for GeneratedField {
11290 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11291 where
11292 D: serde::Deserializer<'de>,
11293 {
11294 struct GeneratedVisitor;
11295
11296 impl serde::de::Visitor<'_> for GeneratedVisitor {
11297 type Value = GeneratedField;
11298
11299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11300 write!(formatter, "expected one of: {:?}", &FIELDS)
11301 }
11302
11303 #[allow(unused_variables)]
11304 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11305 where
11306 E: serde::de::Error,
11307 {
11308 Err(serde::de::Error::unknown_field(value, FIELDS))
11309 }
11310 }
11311 deserializer.deserialize_identifier(GeneratedVisitor)
11312 }
11313 }
11314 struct GeneratedVisitor;
11315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11316 type Value = ListRateLimitsRequest;
11317
11318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11319 formatter.write_str("struct meta.ListRateLimitsRequest")
11320 }
11321
11322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
11323 where
11324 V: serde::de::MapAccess<'de>,
11325 {
11326 while map_.next_key::<GeneratedField>()?.is_some() {
11327 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11328 }
11329 Ok(ListRateLimitsRequest {
11330 })
11331 }
11332 }
11333 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
11334 }
11335}
11336impl serde::Serialize for ListRateLimitsResponse {
11337 #[allow(deprecated)]
11338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11339 where
11340 S: serde::Serializer,
11341 {
11342 use serde::ser::SerializeStruct;
11343 let mut len = 0;
11344 if !self.rate_limits.is_empty() {
11345 len += 1;
11346 }
11347 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
11348 if !self.rate_limits.is_empty() {
11349 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
11350 }
11351 struct_ser.end()
11352 }
11353}
11354impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
11355 #[allow(deprecated)]
11356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11357 where
11358 D: serde::Deserializer<'de>,
11359 {
11360 const FIELDS: &[&str] = &[
11361 "rate_limits",
11362 "rateLimits",
11363 ];
11364
11365 #[allow(clippy::enum_variant_names)]
11366 enum GeneratedField {
11367 RateLimits,
11368 }
11369 impl<'de> serde::Deserialize<'de> for GeneratedField {
11370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11371 where
11372 D: serde::Deserializer<'de>,
11373 {
11374 struct GeneratedVisitor;
11375
11376 impl serde::de::Visitor<'_> for GeneratedVisitor {
11377 type Value = GeneratedField;
11378
11379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11380 write!(formatter, "expected one of: {:?}", &FIELDS)
11381 }
11382
11383 #[allow(unused_variables)]
11384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11385 where
11386 E: serde::de::Error,
11387 {
11388 match value {
11389 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
11390 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11391 }
11392 }
11393 }
11394 deserializer.deserialize_identifier(GeneratedVisitor)
11395 }
11396 }
11397 struct GeneratedVisitor;
11398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11399 type Value = ListRateLimitsResponse;
11400
11401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11402 formatter.write_str("struct meta.ListRateLimitsResponse")
11403 }
11404
11405 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
11406 where
11407 V: serde::de::MapAccess<'de>,
11408 {
11409 let mut rate_limits__ = None;
11410 while let Some(k) = map_.next_key()? {
11411 match k {
11412 GeneratedField::RateLimits => {
11413 if rate_limits__.is_some() {
11414 return Err(serde::de::Error::duplicate_field("rateLimits"));
11415 }
11416 rate_limits__ = Some(map_.next_value()?);
11417 }
11418 }
11419 }
11420 Ok(ListRateLimitsResponse {
11421 rate_limits: rate_limits__.unwrap_or_default(),
11422 })
11423 }
11424 }
11425 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
11426 }
11427}
11428impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
11429 #[allow(deprecated)]
11430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11431 where
11432 S: serde::Serializer,
11433 {
11434 use serde::ser::SerializeStruct;
11435 let mut len = 0;
11436 if self.fragment_id != 0 {
11437 len += 1;
11438 }
11439 if self.job_id != 0 {
11440 len += 1;
11441 }
11442 if self.fragment_type_mask != 0 {
11443 len += 1;
11444 }
11445 if self.rate_limit != 0 {
11446 len += 1;
11447 }
11448 if !self.node_name.is_empty() {
11449 len += 1;
11450 }
11451 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
11452 if self.fragment_id != 0 {
11453 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11454 }
11455 if self.job_id != 0 {
11456 struct_ser.serialize_field("jobId", &self.job_id)?;
11457 }
11458 if self.fragment_type_mask != 0 {
11459 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11460 }
11461 if self.rate_limit != 0 {
11462 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
11463 }
11464 if !self.node_name.is_empty() {
11465 struct_ser.serialize_field("nodeName", &self.node_name)?;
11466 }
11467 struct_ser.end()
11468 }
11469}
11470impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
11471 #[allow(deprecated)]
11472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11473 where
11474 D: serde::Deserializer<'de>,
11475 {
11476 const FIELDS: &[&str] = &[
11477 "fragment_id",
11478 "fragmentId",
11479 "job_id",
11480 "jobId",
11481 "fragment_type_mask",
11482 "fragmentTypeMask",
11483 "rate_limit",
11484 "rateLimit",
11485 "node_name",
11486 "nodeName",
11487 ];
11488
11489 #[allow(clippy::enum_variant_names)]
11490 enum GeneratedField {
11491 FragmentId,
11492 JobId,
11493 FragmentTypeMask,
11494 RateLimit,
11495 NodeName,
11496 }
11497 impl<'de> serde::Deserialize<'de> for GeneratedField {
11498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11499 where
11500 D: serde::Deserializer<'de>,
11501 {
11502 struct GeneratedVisitor;
11503
11504 impl serde::de::Visitor<'_> for GeneratedVisitor {
11505 type Value = GeneratedField;
11506
11507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11508 write!(formatter, "expected one of: {:?}", &FIELDS)
11509 }
11510
11511 #[allow(unused_variables)]
11512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11513 where
11514 E: serde::de::Error,
11515 {
11516 match value {
11517 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11518 "jobId" | "job_id" => Ok(GeneratedField::JobId),
11519 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11520 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11521 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
11522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11523 }
11524 }
11525 }
11526 deserializer.deserialize_identifier(GeneratedVisitor)
11527 }
11528 }
11529 struct GeneratedVisitor;
11530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11531 type Value = list_rate_limits_response::RateLimitInfo;
11532
11533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11534 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
11535 }
11536
11537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
11538 where
11539 V: serde::de::MapAccess<'de>,
11540 {
11541 let mut fragment_id__ = None;
11542 let mut job_id__ = None;
11543 let mut fragment_type_mask__ = None;
11544 let mut rate_limit__ = None;
11545 let mut node_name__ = None;
11546 while let Some(k) = map_.next_key()? {
11547 match k {
11548 GeneratedField::FragmentId => {
11549 if fragment_id__.is_some() {
11550 return Err(serde::de::Error::duplicate_field("fragmentId"));
11551 }
11552 fragment_id__ =
11553 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11554 ;
11555 }
11556 GeneratedField::JobId => {
11557 if job_id__.is_some() {
11558 return Err(serde::de::Error::duplicate_field("jobId"));
11559 }
11560 job_id__ =
11561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11562 ;
11563 }
11564 GeneratedField::FragmentTypeMask => {
11565 if fragment_type_mask__.is_some() {
11566 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11567 }
11568 fragment_type_mask__ =
11569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11570 ;
11571 }
11572 GeneratedField::RateLimit => {
11573 if rate_limit__.is_some() {
11574 return Err(serde::de::Error::duplicate_field("rateLimit"));
11575 }
11576 rate_limit__ =
11577 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11578 ;
11579 }
11580 GeneratedField::NodeName => {
11581 if node_name__.is_some() {
11582 return Err(serde::de::Error::duplicate_field("nodeName"));
11583 }
11584 node_name__ = Some(map_.next_value()?);
11585 }
11586 }
11587 }
11588 Ok(list_rate_limits_response::RateLimitInfo {
11589 fragment_id: fragment_id__.unwrap_or_default(),
11590 job_id: job_id__.unwrap_or_default(),
11591 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11592 rate_limit: rate_limit__.unwrap_or_default(),
11593 node_name: node_name__.unwrap_or_default(),
11594 })
11595 }
11596 }
11597 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
11598 }
11599}
11600impl serde::Serialize for ListRefreshTableStatesRequest {
11601 #[allow(deprecated)]
11602 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11603 where
11604 S: serde::Serializer,
11605 {
11606 use serde::ser::SerializeStruct;
11607 let len = 0;
11608 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
11609 struct_ser.end()
11610 }
11611}
11612impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
11613 #[allow(deprecated)]
11614 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11615 where
11616 D: serde::Deserializer<'de>,
11617 {
11618 const FIELDS: &[&str] = &[
11619 ];
11620
11621 #[allow(clippy::enum_variant_names)]
11622 enum GeneratedField {
11623 }
11624 impl<'de> serde::Deserialize<'de> for GeneratedField {
11625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11626 where
11627 D: serde::Deserializer<'de>,
11628 {
11629 struct GeneratedVisitor;
11630
11631 impl serde::de::Visitor<'_> for GeneratedVisitor {
11632 type Value = GeneratedField;
11633
11634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11635 write!(formatter, "expected one of: {:?}", &FIELDS)
11636 }
11637
11638 #[allow(unused_variables)]
11639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11640 where
11641 E: serde::de::Error,
11642 {
11643 Err(serde::de::Error::unknown_field(value, FIELDS))
11644 }
11645 }
11646 deserializer.deserialize_identifier(GeneratedVisitor)
11647 }
11648 }
11649 struct GeneratedVisitor;
11650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11651 type Value = ListRefreshTableStatesRequest;
11652
11653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11654 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11655 }
11656
11657 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11658 where
11659 V: serde::de::MapAccess<'de>,
11660 {
11661 while map_.next_key::<GeneratedField>()?.is_some() {
11662 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11663 }
11664 Ok(ListRefreshTableStatesRequest {
11665 })
11666 }
11667 }
11668 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11669 }
11670}
11671impl serde::Serialize for ListRefreshTableStatesResponse {
11672 #[allow(deprecated)]
11673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11674 where
11675 S: serde::Serializer,
11676 {
11677 use serde::ser::SerializeStruct;
11678 let mut len = 0;
11679 if !self.states.is_empty() {
11680 len += 1;
11681 }
11682 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11683 if !self.states.is_empty() {
11684 struct_ser.serialize_field("states", &self.states)?;
11685 }
11686 struct_ser.end()
11687 }
11688}
11689impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11690 #[allow(deprecated)]
11691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11692 where
11693 D: serde::Deserializer<'de>,
11694 {
11695 const FIELDS: &[&str] = &[
11696 "states",
11697 ];
11698
11699 #[allow(clippy::enum_variant_names)]
11700 enum GeneratedField {
11701 States,
11702 }
11703 impl<'de> serde::Deserialize<'de> for GeneratedField {
11704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11705 where
11706 D: serde::Deserializer<'de>,
11707 {
11708 struct GeneratedVisitor;
11709
11710 impl serde::de::Visitor<'_> for GeneratedVisitor {
11711 type Value = GeneratedField;
11712
11713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11714 write!(formatter, "expected one of: {:?}", &FIELDS)
11715 }
11716
11717 #[allow(unused_variables)]
11718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11719 where
11720 E: serde::de::Error,
11721 {
11722 match value {
11723 "states" => Ok(GeneratedField::States),
11724 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11725 }
11726 }
11727 }
11728 deserializer.deserialize_identifier(GeneratedVisitor)
11729 }
11730 }
11731 struct GeneratedVisitor;
11732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11733 type Value = ListRefreshTableStatesResponse;
11734
11735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11736 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11737 }
11738
11739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11740 where
11741 V: serde::de::MapAccess<'de>,
11742 {
11743 let mut states__ = None;
11744 while let Some(k) = map_.next_key()? {
11745 match k {
11746 GeneratedField::States => {
11747 if states__.is_some() {
11748 return Err(serde::de::Error::duplicate_field("states"));
11749 }
11750 states__ = Some(map_.next_value()?);
11751 }
11752 }
11753 }
11754 Ok(ListRefreshTableStatesResponse {
11755 states: states__.unwrap_or_default(),
11756 })
11757 }
11758 }
11759 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11760 }
11761}
11762impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11763 #[allow(deprecated)]
11764 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11765 where
11766 S: serde::Serializer,
11767 {
11768 use serde::ser::SerializeStruct;
11769 let mut len = 0;
11770 if self.table_id != 0 {
11771 len += 1;
11772 }
11773 if !self.current_status.is_empty() {
11774 len += 1;
11775 }
11776 if self.last_trigger_time.is_some() {
11777 len += 1;
11778 }
11779 if self.trigger_interval_secs.is_some() {
11780 len += 1;
11781 }
11782 if self.last_success_time.is_some() {
11783 len += 1;
11784 }
11785 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11786 if self.table_id != 0 {
11787 struct_ser.serialize_field("tableId", &self.table_id)?;
11788 }
11789 if !self.current_status.is_empty() {
11790 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11791 }
11792 if let Some(v) = self.last_trigger_time.as_ref() {
11793 struct_ser.serialize_field("lastTriggerTime", v)?;
11794 }
11795 if let Some(v) = self.trigger_interval_secs.as_ref() {
11796 #[allow(clippy::needless_borrow)]
11797 #[allow(clippy::needless_borrows_for_generic_args)]
11798 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11799 }
11800 if let Some(v) = self.last_success_time.as_ref() {
11801 struct_ser.serialize_field("lastSuccessTime", v)?;
11802 }
11803 struct_ser.end()
11804 }
11805}
11806impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11807 #[allow(deprecated)]
11808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11809 where
11810 D: serde::Deserializer<'de>,
11811 {
11812 const FIELDS: &[&str] = &[
11813 "table_id",
11814 "tableId",
11815 "current_status",
11816 "currentStatus",
11817 "last_trigger_time",
11818 "lastTriggerTime",
11819 "trigger_interval_secs",
11820 "triggerIntervalSecs",
11821 "last_success_time",
11822 "lastSuccessTime",
11823 ];
11824
11825 #[allow(clippy::enum_variant_names)]
11826 enum GeneratedField {
11827 TableId,
11828 CurrentStatus,
11829 LastTriggerTime,
11830 TriggerIntervalSecs,
11831 LastSuccessTime,
11832 }
11833 impl<'de> serde::Deserialize<'de> for GeneratedField {
11834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11835 where
11836 D: serde::Deserializer<'de>,
11837 {
11838 struct GeneratedVisitor;
11839
11840 impl serde::de::Visitor<'_> for GeneratedVisitor {
11841 type Value = GeneratedField;
11842
11843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11844 write!(formatter, "expected one of: {:?}", &FIELDS)
11845 }
11846
11847 #[allow(unused_variables)]
11848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11849 where
11850 E: serde::de::Error,
11851 {
11852 match value {
11853 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11854 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11855 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11856 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11857 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11858 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11859 }
11860 }
11861 }
11862 deserializer.deserialize_identifier(GeneratedVisitor)
11863 }
11864 }
11865 struct GeneratedVisitor;
11866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11867 type Value = list_refresh_table_states_response::RefreshTableState;
11868
11869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11870 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11871 }
11872
11873 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11874 where
11875 V: serde::de::MapAccess<'de>,
11876 {
11877 let mut table_id__ = None;
11878 let mut current_status__ = None;
11879 let mut last_trigger_time__ = None;
11880 let mut trigger_interval_secs__ = None;
11881 let mut last_success_time__ = None;
11882 while let Some(k) = map_.next_key()? {
11883 match k {
11884 GeneratedField::TableId => {
11885 if table_id__.is_some() {
11886 return Err(serde::de::Error::duplicate_field("tableId"));
11887 }
11888 table_id__ =
11889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11890 ;
11891 }
11892 GeneratedField::CurrentStatus => {
11893 if current_status__.is_some() {
11894 return Err(serde::de::Error::duplicate_field("currentStatus"));
11895 }
11896 current_status__ = Some(map_.next_value()?);
11897 }
11898 GeneratedField::LastTriggerTime => {
11899 if last_trigger_time__.is_some() {
11900 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11901 }
11902 last_trigger_time__ = map_.next_value()?;
11903 }
11904 GeneratedField::TriggerIntervalSecs => {
11905 if trigger_interval_secs__.is_some() {
11906 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11907 }
11908 trigger_interval_secs__ =
11909 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11910 ;
11911 }
11912 GeneratedField::LastSuccessTime => {
11913 if last_success_time__.is_some() {
11914 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11915 }
11916 last_success_time__ = map_.next_value()?;
11917 }
11918 }
11919 }
11920 Ok(list_refresh_table_states_response::RefreshTableState {
11921 table_id: table_id__.unwrap_or_default(),
11922 current_status: current_status__.unwrap_or_default(),
11923 last_trigger_time: last_trigger_time__,
11924 trigger_interval_secs: trigger_interval_secs__,
11925 last_success_time: last_success_time__,
11926 })
11927 }
11928 }
11929 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11930 }
11931}
11932impl serde::Serialize for ListSinkLogStoreTablesRequest {
11933 #[allow(deprecated)]
11934 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11935 where
11936 S: serde::Serializer,
11937 {
11938 use serde::ser::SerializeStruct;
11939 let len = 0;
11940 let struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesRequest", len)?;
11941 struct_ser.end()
11942 }
11943}
11944impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesRequest {
11945 #[allow(deprecated)]
11946 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11947 where
11948 D: serde::Deserializer<'de>,
11949 {
11950 const FIELDS: &[&str] = &[
11951 ];
11952
11953 #[allow(clippy::enum_variant_names)]
11954 enum GeneratedField {
11955 }
11956 impl<'de> serde::Deserialize<'de> for GeneratedField {
11957 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11958 where
11959 D: serde::Deserializer<'de>,
11960 {
11961 struct GeneratedVisitor;
11962
11963 impl serde::de::Visitor<'_> for GeneratedVisitor {
11964 type Value = GeneratedField;
11965
11966 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11967 write!(formatter, "expected one of: {:?}", &FIELDS)
11968 }
11969
11970 #[allow(unused_variables)]
11971 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11972 where
11973 E: serde::de::Error,
11974 {
11975 Err(serde::de::Error::unknown_field(value, FIELDS))
11976 }
11977 }
11978 deserializer.deserialize_identifier(GeneratedVisitor)
11979 }
11980 }
11981 struct GeneratedVisitor;
11982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11983 type Value = ListSinkLogStoreTablesRequest;
11984
11985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11986 formatter.write_str("struct meta.ListSinkLogStoreTablesRequest")
11987 }
11988
11989 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesRequest, V::Error>
11990 where
11991 V: serde::de::MapAccess<'de>,
11992 {
11993 while map_.next_key::<GeneratedField>()?.is_some() {
11994 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11995 }
11996 Ok(ListSinkLogStoreTablesRequest {
11997 })
11998 }
11999 }
12000 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesRequest", FIELDS, GeneratedVisitor)
12001 }
12002}
12003impl serde::Serialize for ListSinkLogStoreTablesResponse {
12004 #[allow(deprecated)]
12005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12006 where
12007 S: serde::Serializer,
12008 {
12009 use serde::ser::SerializeStruct;
12010 let mut len = 0;
12011 if !self.tables.is_empty() {
12012 len += 1;
12013 }
12014 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse", len)?;
12015 if !self.tables.is_empty() {
12016 struct_ser.serialize_field("tables", &self.tables)?;
12017 }
12018 struct_ser.end()
12019 }
12020}
12021impl<'de> serde::Deserialize<'de> for ListSinkLogStoreTablesResponse {
12022 #[allow(deprecated)]
12023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12024 where
12025 D: serde::Deserializer<'de>,
12026 {
12027 const FIELDS: &[&str] = &[
12028 "tables",
12029 ];
12030
12031 #[allow(clippy::enum_variant_names)]
12032 enum GeneratedField {
12033 Tables,
12034 }
12035 impl<'de> serde::Deserialize<'de> for GeneratedField {
12036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12037 where
12038 D: serde::Deserializer<'de>,
12039 {
12040 struct GeneratedVisitor;
12041
12042 impl serde::de::Visitor<'_> for GeneratedVisitor {
12043 type Value = GeneratedField;
12044
12045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12046 write!(formatter, "expected one of: {:?}", &FIELDS)
12047 }
12048
12049 #[allow(unused_variables)]
12050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12051 where
12052 E: serde::de::Error,
12053 {
12054 match value {
12055 "tables" => Ok(GeneratedField::Tables),
12056 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12057 }
12058 }
12059 }
12060 deserializer.deserialize_identifier(GeneratedVisitor)
12061 }
12062 }
12063 struct GeneratedVisitor;
12064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12065 type Value = ListSinkLogStoreTablesResponse;
12066
12067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12068 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse")
12069 }
12070
12071 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSinkLogStoreTablesResponse, V::Error>
12072 where
12073 V: serde::de::MapAccess<'de>,
12074 {
12075 let mut tables__ = None;
12076 while let Some(k) = map_.next_key()? {
12077 match k {
12078 GeneratedField::Tables => {
12079 if tables__.is_some() {
12080 return Err(serde::de::Error::duplicate_field("tables"));
12081 }
12082 tables__ = Some(map_.next_value()?);
12083 }
12084 }
12085 }
12086 Ok(ListSinkLogStoreTablesResponse {
12087 tables: tables__.unwrap_or_default(),
12088 })
12089 }
12090 }
12091 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse", FIELDS, GeneratedVisitor)
12092 }
12093}
12094impl serde::Serialize for list_sink_log_store_tables_response::SinkLogStoreTable {
12095 #[allow(deprecated)]
12096 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12097 where
12098 S: serde::Serializer,
12099 {
12100 use serde::ser::SerializeStruct;
12101 let mut len = 0;
12102 if self.sink_id != 0 {
12103 len += 1;
12104 }
12105 if self.internal_table_id != 0 {
12106 len += 1;
12107 }
12108 let mut struct_ser = serializer.serialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", len)?;
12109 if self.sink_id != 0 {
12110 struct_ser.serialize_field("sinkId", &self.sink_id)?;
12111 }
12112 if self.internal_table_id != 0 {
12113 struct_ser.serialize_field("internalTableId", &self.internal_table_id)?;
12114 }
12115 struct_ser.end()
12116 }
12117}
12118impl<'de> serde::Deserialize<'de> for list_sink_log_store_tables_response::SinkLogStoreTable {
12119 #[allow(deprecated)]
12120 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12121 where
12122 D: serde::Deserializer<'de>,
12123 {
12124 const FIELDS: &[&str] = &[
12125 "sink_id",
12126 "sinkId",
12127 "internal_table_id",
12128 "internalTableId",
12129 ];
12130
12131 #[allow(clippy::enum_variant_names)]
12132 enum GeneratedField {
12133 SinkId,
12134 InternalTableId,
12135 }
12136 impl<'de> serde::Deserialize<'de> for GeneratedField {
12137 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12138 where
12139 D: serde::Deserializer<'de>,
12140 {
12141 struct GeneratedVisitor;
12142
12143 impl serde::de::Visitor<'_> for GeneratedVisitor {
12144 type Value = GeneratedField;
12145
12146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12147 write!(formatter, "expected one of: {:?}", &FIELDS)
12148 }
12149
12150 #[allow(unused_variables)]
12151 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12152 where
12153 E: serde::de::Error,
12154 {
12155 match value {
12156 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
12157 "internalTableId" | "internal_table_id" => Ok(GeneratedField::InternalTableId),
12158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12159 }
12160 }
12161 }
12162 deserializer.deserialize_identifier(GeneratedVisitor)
12163 }
12164 }
12165 struct GeneratedVisitor;
12166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12167 type Value = list_sink_log_store_tables_response::SinkLogStoreTable;
12168
12169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12170 formatter.write_str("struct meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable")
12171 }
12172
12173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_sink_log_store_tables_response::SinkLogStoreTable, V::Error>
12174 where
12175 V: serde::de::MapAccess<'de>,
12176 {
12177 let mut sink_id__ = None;
12178 let mut internal_table_id__ = None;
12179 while let Some(k) = map_.next_key()? {
12180 match k {
12181 GeneratedField::SinkId => {
12182 if sink_id__.is_some() {
12183 return Err(serde::de::Error::duplicate_field("sinkId"));
12184 }
12185 sink_id__ =
12186 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12187 ;
12188 }
12189 GeneratedField::InternalTableId => {
12190 if internal_table_id__.is_some() {
12191 return Err(serde::de::Error::duplicate_field("internalTableId"));
12192 }
12193 internal_table_id__ =
12194 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12195 ;
12196 }
12197 }
12198 }
12199 Ok(list_sink_log_store_tables_response::SinkLogStoreTable {
12200 sink_id: sink_id__.unwrap_or_default(),
12201 internal_table_id: internal_table_id__.unwrap_or_default(),
12202 })
12203 }
12204 }
12205 deserializer.deserialize_struct("meta.ListSinkLogStoreTablesResponse.SinkLogStoreTable", FIELDS, GeneratedVisitor)
12206 }
12207}
12208impl serde::Serialize for ListStreamingJobStatesRequest {
12209 #[allow(deprecated)]
12210 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12211 where
12212 S: serde::Serializer,
12213 {
12214 use serde::ser::SerializeStruct;
12215 let len = 0;
12216 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
12217 struct_ser.end()
12218 }
12219}
12220impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
12221 #[allow(deprecated)]
12222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12223 where
12224 D: serde::Deserializer<'de>,
12225 {
12226 const FIELDS: &[&str] = &[
12227 ];
12228
12229 #[allow(clippy::enum_variant_names)]
12230 enum GeneratedField {
12231 }
12232 impl<'de> serde::Deserialize<'de> for GeneratedField {
12233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12234 where
12235 D: serde::Deserializer<'de>,
12236 {
12237 struct GeneratedVisitor;
12238
12239 impl serde::de::Visitor<'_> for GeneratedVisitor {
12240 type Value = GeneratedField;
12241
12242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12243 write!(formatter, "expected one of: {:?}", &FIELDS)
12244 }
12245
12246 #[allow(unused_variables)]
12247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12248 where
12249 E: serde::de::Error,
12250 {
12251 Err(serde::de::Error::unknown_field(value, FIELDS))
12252 }
12253 }
12254 deserializer.deserialize_identifier(GeneratedVisitor)
12255 }
12256 }
12257 struct GeneratedVisitor;
12258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12259 type Value = ListStreamingJobStatesRequest;
12260
12261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12262 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
12263 }
12264
12265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
12266 where
12267 V: serde::de::MapAccess<'de>,
12268 {
12269 while map_.next_key::<GeneratedField>()?.is_some() {
12270 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12271 }
12272 Ok(ListStreamingJobStatesRequest {
12273 })
12274 }
12275 }
12276 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
12277 }
12278}
12279impl serde::Serialize for ListStreamingJobStatesResponse {
12280 #[allow(deprecated)]
12281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12282 where
12283 S: serde::Serializer,
12284 {
12285 use serde::ser::SerializeStruct;
12286 let mut len = 0;
12287 if !self.states.is_empty() {
12288 len += 1;
12289 }
12290 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
12291 if !self.states.is_empty() {
12292 struct_ser.serialize_field("states", &self.states)?;
12293 }
12294 struct_ser.end()
12295 }
12296}
12297impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
12298 #[allow(deprecated)]
12299 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12300 where
12301 D: serde::Deserializer<'de>,
12302 {
12303 const FIELDS: &[&str] = &[
12304 "states",
12305 ];
12306
12307 #[allow(clippy::enum_variant_names)]
12308 enum GeneratedField {
12309 States,
12310 }
12311 impl<'de> serde::Deserialize<'de> for GeneratedField {
12312 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12313 where
12314 D: serde::Deserializer<'de>,
12315 {
12316 struct GeneratedVisitor;
12317
12318 impl serde::de::Visitor<'_> for GeneratedVisitor {
12319 type Value = GeneratedField;
12320
12321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12322 write!(formatter, "expected one of: {:?}", &FIELDS)
12323 }
12324
12325 #[allow(unused_variables)]
12326 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12327 where
12328 E: serde::de::Error,
12329 {
12330 match value {
12331 "states" => Ok(GeneratedField::States),
12332 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12333 }
12334 }
12335 }
12336 deserializer.deserialize_identifier(GeneratedVisitor)
12337 }
12338 }
12339 struct GeneratedVisitor;
12340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12341 type Value = ListStreamingJobStatesResponse;
12342
12343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12344 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
12345 }
12346
12347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
12348 where
12349 V: serde::de::MapAccess<'de>,
12350 {
12351 let mut states__ = None;
12352 while let Some(k) = map_.next_key()? {
12353 match k {
12354 GeneratedField::States => {
12355 if states__.is_some() {
12356 return Err(serde::de::Error::duplicate_field("states"));
12357 }
12358 states__ = Some(map_.next_value()?);
12359 }
12360 }
12361 }
12362 Ok(ListStreamingJobStatesResponse {
12363 states: states__.unwrap_or_default(),
12364 })
12365 }
12366 }
12367 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
12368 }
12369}
12370impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
12371 #[allow(deprecated)]
12372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12373 where
12374 S: serde::Serializer,
12375 {
12376 use serde::ser::SerializeStruct;
12377 let mut len = 0;
12378 if self.table_id != 0 {
12379 len += 1;
12380 }
12381 if self.state != 0 {
12382 len += 1;
12383 }
12384 if self.parallelism.is_some() {
12385 len += 1;
12386 }
12387 if self.max_parallelism != 0 {
12388 len += 1;
12389 }
12390 if !self.name.is_empty() {
12391 len += 1;
12392 }
12393 if !self.resource_group.is_empty() {
12394 len += 1;
12395 }
12396 if !self.config_override.is_empty() {
12397 len += 1;
12398 }
12399 if self.database_id != 0 {
12400 len += 1;
12401 }
12402 if self.schema_id != 0 {
12403 len += 1;
12404 }
12405 if self.adaptive_parallelism_strategy.is_some() {
12406 len += 1;
12407 }
12408 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
12409 if self.table_id != 0 {
12410 struct_ser.serialize_field("tableId", &self.table_id)?;
12411 }
12412 if self.state != 0 {
12413 let v = table_fragments::State::try_from(self.state)
12414 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
12415 struct_ser.serialize_field("state", &v)?;
12416 }
12417 if let Some(v) = self.parallelism.as_ref() {
12418 struct_ser.serialize_field("parallelism", v)?;
12419 }
12420 if self.max_parallelism != 0 {
12421 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12422 }
12423 if !self.name.is_empty() {
12424 struct_ser.serialize_field("name", &self.name)?;
12425 }
12426 if !self.resource_group.is_empty() {
12427 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
12428 }
12429 if !self.config_override.is_empty() {
12430 struct_ser.serialize_field("configOverride", &self.config_override)?;
12431 }
12432 if self.database_id != 0 {
12433 struct_ser.serialize_field("databaseId", &self.database_id)?;
12434 }
12435 if self.schema_id != 0 {
12436 struct_ser.serialize_field("schemaId", &self.schema_id)?;
12437 }
12438 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
12439 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
12440 }
12441 struct_ser.end()
12442 }
12443}
12444impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
12445 #[allow(deprecated)]
12446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12447 where
12448 D: serde::Deserializer<'de>,
12449 {
12450 const FIELDS: &[&str] = &[
12451 "table_id",
12452 "tableId",
12453 "state",
12454 "parallelism",
12455 "max_parallelism",
12456 "maxParallelism",
12457 "name",
12458 "resource_group",
12459 "resourceGroup",
12460 "config_override",
12461 "configOverride",
12462 "database_id",
12463 "databaseId",
12464 "schema_id",
12465 "schemaId",
12466 "adaptive_parallelism_strategy",
12467 "adaptiveParallelismStrategy",
12468 ];
12469
12470 #[allow(clippy::enum_variant_names)]
12471 enum GeneratedField {
12472 TableId,
12473 State,
12474 Parallelism,
12475 MaxParallelism,
12476 Name,
12477 ResourceGroup,
12478 ConfigOverride,
12479 DatabaseId,
12480 SchemaId,
12481 AdaptiveParallelismStrategy,
12482 }
12483 impl<'de> serde::Deserialize<'de> for GeneratedField {
12484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12485 where
12486 D: serde::Deserializer<'de>,
12487 {
12488 struct GeneratedVisitor;
12489
12490 impl serde::de::Visitor<'_> for GeneratedVisitor {
12491 type Value = GeneratedField;
12492
12493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12494 write!(formatter, "expected one of: {:?}", &FIELDS)
12495 }
12496
12497 #[allow(unused_variables)]
12498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12499 where
12500 E: serde::de::Error,
12501 {
12502 match value {
12503 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12504 "state" => Ok(GeneratedField::State),
12505 "parallelism" => Ok(GeneratedField::Parallelism),
12506 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12507 "name" => Ok(GeneratedField::Name),
12508 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
12509 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12510 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
12511 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
12512 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12514 }
12515 }
12516 }
12517 deserializer.deserialize_identifier(GeneratedVisitor)
12518 }
12519 }
12520 struct GeneratedVisitor;
12521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12522 type Value = list_streaming_job_states_response::StreamingJobState;
12523
12524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12525 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
12526 }
12527
12528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
12529 where
12530 V: serde::de::MapAccess<'de>,
12531 {
12532 let mut table_id__ = None;
12533 let mut state__ = None;
12534 let mut parallelism__ = None;
12535 let mut max_parallelism__ = None;
12536 let mut name__ = None;
12537 let mut resource_group__ = None;
12538 let mut config_override__ = None;
12539 let mut database_id__ = None;
12540 let mut schema_id__ = None;
12541 let mut adaptive_parallelism_strategy__ = None;
12542 while let Some(k) = map_.next_key()? {
12543 match k {
12544 GeneratedField::TableId => {
12545 if table_id__.is_some() {
12546 return Err(serde::de::Error::duplicate_field("tableId"));
12547 }
12548 table_id__ =
12549 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12550 ;
12551 }
12552 GeneratedField::State => {
12553 if state__.is_some() {
12554 return Err(serde::de::Error::duplicate_field("state"));
12555 }
12556 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
12557 }
12558 GeneratedField::Parallelism => {
12559 if parallelism__.is_some() {
12560 return Err(serde::de::Error::duplicate_field("parallelism"));
12561 }
12562 parallelism__ = map_.next_value()?;
12563 }
12564 GeneratedField::MaxParallelism => {
12565 if max_parallelism__.is_some() {
12566 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12567 }
12568 max_parallelism__ =
12569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12570 ;
12571 }
12572 GeneratedField::Name => {
12573 if name__.is_some() {
12574 return Err(serde::de::Error::duplicate_field("name"));
12575 }
12576 name__ = Some(map_.next_value()?);
12577 }
12578 GeneratedField::ResourceGroup => {
12579 if resource_group__.is_some() {
12580 return Err(serde::de::Error::duplicate_field("resourceGroup"));
12581 }
12582 resource_group__ = Some(map_.next_value()?);
12583 }
12584 GeneratedField::ConfigOverride => {
12585 if config_override__.is_some() {
12586 return Err(serde::de::Error::duplicate_field("configOverride"));
12587 }
12588 config_override__ = Some(map_.next_value()?);
12589 }
12590 GeneratedField::DatabaseId => {
12591 if database_id__.is_some() {
12592 return Err(serde::de::Error::duplicate_field("databaseId"));
12593 }
12594 database_id__ =
12595 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12596 ;
12597 }
12598 GeneratedField::SchemaId => {
12599 if schema_id__.is_some() {
12600 return Err(serde::de::Error::duplicate_field("schemaId"));
12601 }
12602 schema_id__ =
12603 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12604 ;
12605 }
12606 GeneratedField::AdaptiveParallelismStrategy => {
12607 if adaptive_parallelism_strategy__.is_some() {
12608 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12609 }
12610 adaptive_parallelism_strategy__ = map_.next_value()?;
12611 }
12612 }
12613 }
12614 Ok(list_streaming_job_states_response::StreamingJobState {
12615 table_id: table_id__.unwrap_or_default(),
12616 state: state__.unwrap_or_default(),
12617 parallelism: parallelism__,
12618 max_parallelism: max_parallelism__.unwrap_or_default(),
12619 name: name__.unwrap_or_default(),
12620 resource_group: resource_group__.unwrap_or_default(),
12621 config_override: config_override__.unwrap_or_default(),
12622 database_id: database_id__.unwrap_or_default(),
12623 schema_id: schema_id__.unwrap_or_default(),
12624 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
12625 })
12626 }
12627 }
12628 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
12629 }
12630}
12631impl serde::Serialize for ListTableFragmentsRequest {
12632 #[allow(deprecated)]
12633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12634 where
12635 S: serde::Serializer,
12636 {
12637 use serde::ser::SerializeStruct;
12638 let mut len = 0;
12639 if !self.table_ids.is_empty() {
12640 len += 1;
12641 }
12642 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
12643 if !self.table_ids.is_empty() {
12644 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12645 }
12646 struct_ser.end()
12647 }
12648}
12649impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
12650 #[allow(deprecated)]
12651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12652 where
12653 D: serde::Deserializer<'de>,
12654 {
12655 const FIELDS: &[&str] = &[
12656 "table_ids",
12657 "tableIds",
12658 ];
12659
12660 #[allow(clippy::enum_variant_names)]
12661 enum GeneratedField {
12662 TableIds,
12663 }
12664 impl<'de> serde::Deserialize<'de> for GeneratedField {
12665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12666 where
12667 D: serde::Deserializer<'de>,
12668 {
12669 struct GeneratedVisitor;
12670
12671 impl serde::de::Visitor<'_> for GeneratedVisitor {
12672 type Value = GeneratedField;
12673
12674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12675 write!(formatter, "expected one of: {:?}", &FIELDS)
12676 }
12677
12678 #[allow(unused_variables)]
12679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12680 where
12681 E: serde::de::Error,
12682 {
12683 match value {
12684 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12685 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12686 }
12687 }
12688 }
12689 deserializer.deserialize_identifier(GeneratedVisitor)
12690 }
12691 }
12692 struct GeneratedVisitor;
12693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12694 type Value = ListTableFragmentsRequest;
12695
12696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12697 formatter.write_str("struct meta.ListTableFragmentsRequest")
12698 }
12699
12700 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
12701 where
12702 V: serde::de::MapAccess<'de>,
12703 {
12704 let mut table_ids__ = None;
12705 while let Some(k) = map_.next_key()? {
12706 match k {
12707 GeneratedField::TableIds => {
12708 if table_ids__.is_some() {
12709 return Err(serde::de::Error::duplicate_field("tableIds"));
12710 }
12711 table_ids__ =
12712 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12713 .into_iter().map(|x| x.0).collect())
12714 ;
12715 }
12716 }
12717 }
12718 Ok(ListTableFragmentsRequest {
12719 table_ids: table_ids__.unwrap_or_default(),
12720 })
12721 }
12722 }
12723 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
12724 }
12725}
12726impl serde::Serialize for ListTableFragmentsResponse {
12727 #[allow(deprecated)]
12728 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12729 where
12730 S: serde::Serializer,
12731 {
12732 use serde::ser::SerializeStruct;
12733 let mut len = 0;
12734 if !self.table_fragments.is_empty() {
12735 len += 1;
12736 }
12737 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
12738 if !self.table_fragments.is_empty() {
12739 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
12740 }
12741 struct_ser.end()
12742 }
12743}
12744impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
12745 #[allow(deprecated)]
12746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12747 where
12748 D: serde::Deserializer<'de>,
12749 {
12750 const FIELDS: &[&str] = &[
12751 "table_fragments",
12752 "tableFragments",
12753 ];
12754
12755 #[allow(clippy::enum_variant_names)]
12756 enum GeneratedField {
12757 TableFragments,
12758 }
12759 impl<'de> serde::Deserialize<'de> for GeneratedField {
12760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12761 where
12762 D: serde::Deserializer<'de>,
12763 {
12764 struct GeneratedVisitor;
12765
12766 impl serde::de::Visitor<'_> for GeneratedVisitor {
12767 type Value = GeneratedField;
12768
12769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12770 write!(formatter, "expected one of: {:?}", &FIELDS)
12771 }
12772
12773 #[allow(unused_variables)]
12774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12775 where
12776 E: serde::de::Error,
12777 {
12778 match value {
12779 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
12780 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12781 }
12782 }
12783 }
12784 deserializer.deserialize_identifier(GeneratedVisitor)
12785 }
12786 }
12787 struct GeneratedVisitor;
12788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12789 type Value = ListTableFragmentsResponse;
12790
12791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12792 formatter.write_str("struct meta.ListTableFragmentsResponse")
12793 }
12794
12795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
12796 where
12797 V: serde::de::MapAccess<'de>,
12798 {
12799 let mut table_fragments__ = None;
12800 while let Some(k) = map_.next_key()? {
12801 match k {
12802 GeneratedField::TableFragments => {
12803 if table_fragments__.is_some() {
12804 return Err(serde::de::Error::duplicate_field("tableFragments"));
12805 }
12806 table_fragments__ = Some(
12807 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12808 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12809 );
12810 }
12811 }
12812 }
12813 Ok(ListTableFragmentsResponse {
12814 table_fragments: table_fragments__.unwrap_or_default(),
12815 })
12816 }
12817 }
12818 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
12819 }
12820}
12821impl serde::Serialize for list_table_fragments_response::ActorInfo {
12822 #[allow(deprecated)]
12823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12824 where
12825 S: serde::Serializer,
12826 {
12827 use serde::ser::SerializeStruct;
12828 let mut len = 0;
12829 if self.id != 0 {
12830 len += 1;
12831 }
12832 if self.node.is_some() {
12833 len += 1;
12834 }
12835 if !self.dispatcher.is_empty() {
12836 len += 1;
12837 }
12838 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
12839 if self.id != 0 {
12840 struct_ser.serialize_field("id", &self.id)?;
12841 }
12842 if let Some(v) = self.node.as_ref() {
12843 struct_ser.serialize_field("node", v)?;
12844 }
12845 if !self.dispatcher.is_empty() {
12846 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12847 }
12848 struct_ser.end()
12849 }
12850}
12851impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
12852 #[allow(deprecated)]
12853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12854 where
12855 D: serde::Deserializer<'de>,
12856 {
12857 const FIELDS: &[&str] = &[
12858 "id",
12859 "node",
12860 "dispatcher",
12861 ];
12862
12863 #[allow(clippy::enum_variant_names)]
12864 enum GeneratedField {
12865 Id,
12866 Node,
12867 Dispatcher,
12868 }
12869 impl<'de> serde::Deserialize<'de> for GeneratedField {
12870 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12871 where
12872 D: serde::Deserializer<'de>,
12873 {
12874 struct GeneratedVisitor;
12875
12876 impl serde::de::Visitor<'_> for GeneratedVisitor {
12877 type Value = GeneratedField;
12878
12879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12880 write!(formatter, "expected one of: {:?}", &FIELDS)
12881 }
12882
12883 #[allow(unused_variables)]
12884 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12885 where
12886 E: serde::de::Error,
12887 {
12888 match value {
12889 "id" => Ok(GeneratedField::Id),
12890 "node" => Ok(GeneratedField::Node),
12891 "dispatcher" => Ok(GeneratedField::Dispatcher),
12892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12893 }
12894 }
12895 }
12896 deserializer.deserialize_identifier(GeneratedVisitor)
12897 }
12898 }
12899 struct GeneratedVisitor;
12900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12901 type Value = list_table_fragments_response::ActorInfo;
12902
12903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12904 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
12905 }
12906
12907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
12908 where
12909 V: serde::de::MapAccess<'de>,
12910 {
12911 let mut id__ = None;
12912 let mut node__ = None;
12913 let mut dispatcher__ = None;
12914 while let Some(k) = map_.next_key()? {
12915 match k {
12916 GeneratedField::Id => {
12917 if id__.is_some() {
12918 return Err(serde::de::Error::duplicate_field("id"));
12919 }
12920 id__ =
12921 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12922 ;
12923 }
12924 GeneratedField::Node => {
12925 if node__.is_some() {
12926 return Err(serde::de::Error::duplicate_field("node"));
12927 }
12928 node__ = map_.next_value()?;
12929 }
12930 GeneratedField::Dispatcher => {
12931 if dispatcher__.is_some() {
12932 return Err(serde::de::Error::duplicate_field("dispatcher"));
12933 }
12934 dispatcher__ = Some(map_.next_value()?);
12935 }
12936 }
12937 }
12938 Ok(list_table_fragments_response::ActorInfo {
12939 id: id__.unwrap_or_default(),
12940 node: node__,
12941 dispatcher: dispatcher__.unwrap_or_default(),
12942 })
12943 }
12944 }
12945 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12946 }
12947}
12948impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12949 #[allow(deprecated)]
12950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12951 where
12952 S: serde::Serializer,
12953 {
12954 use serde::ser::SerializeStruct;
12955 let mut len = 0;
12956 if self.id != 0 {
12957 len += 1;
12958 }
12959 if !self.actors.is_empty() {
12960 len += 1;
12961 }
12962 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12963 if self.id != 0 {
12964 struct_ser.serialize_field("id", &self.id)?;
12965 }
12966 if !self.actors.is_empty() {
12967 struct_ser.serialize_field("actors", &self.actors)?;
12968 }
12969 struct_ser.end()
12970 }
12971}
12972impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12973 #[allow(deprecated)]
12974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12975 where
12976 D: serde::Deserializer<'de>,
12977 {
12978 const FIELDS: &[&str] = &[
12979 "id",
12980 "actors",
12981 ];
12982
12983 #[allow(clippy::enum_variant_names)]
12984 enum GeneratedField {
12985 Id,
12986 Actors,
12987 }
12988 impl<'de> serde::Deserialize<'de> for GeneratedField {
12989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12990 where
12991 D: serde::Deserializer<'de>,
12992 {
12993 struct GeneratedVisitor;
12994
12995 impl serde::de::Visitor<'_> for GeneratedVisitor {
12996 type Value = GeneratedField;
12997
12998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12999 write!(formatter, "expected one of: {:?}", &FIELDS)
13000 }
13001
13002 #[allow(unused_variables)]
13003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13004 where
13005 E: serde::de::Error,
13006 {
13007 match value {
13008 "id" => Ok(GeneratedField::Id),
13009 "actors" => Ok(GeneratedField::Actors),
13010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13011 }
13012 }
13013 }
13014 deserializer.deserialize_identifier(GeneratedVisitor)
13015 }
13016 }
13017 struct GeneratedVisitor;
13018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13019 type Value = list_table_fragments_response::FragmentInfo;
13020
13021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13022 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
13023 }
13024
13025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
13026 where
13027 V: serde::de::MapAccess<'de>,
13028 {
13029 let mut id__ = None;
13030 let mut actors__ = None;
13031 while let Some(k) = map_.next_key()? {
13032 match k {
13033 GeneratedField::Id => {
13034 if id__.is_some() {
13035 return Err(serde::de::Error::duplicate_field("id"));
13036 }
13037 id__ =
13038 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13039 ;
13040 }
13041 GeneratedField::Actors => {
13042 if actors__.is_some() {
13043 return Err(serde::de::Error::duplicate_field("actors"));
13044 }
13045 actors__ = Some(map_.next_value()?);
13046 }
13047 }
13048 }
13049 Ok(list_table_fragments_response::FragmentInfo {
13050 id: id__.unwrap_or_default(),
13051 actors: actors__.unwrap_or_default(),
13052 })
13053 }
13054 }
13055 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
13056 }
13057}
13058impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
13059 #[allow(deprecated)]
13060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13061 where
13062 S: serde::Serializer,
13063 {
13064 use serde::ser::SerializeStruct;
13065 let mut len = 0;
13066 if !self.fragments.is_empty() {
13067 len += 1;
13068 }
13069 if self.ctx.is_some() {
13070 len += 1;
13071 }
13072 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
13073 if !self.fragments.is_empty() {
13074 struct_ser.serialize_field("fragments", &self.fragments)?;
13075 }
13076 if let Some(v) = self.ctx.as_ref() {
13077 struct_ser.serialize_field("ctx", v)?;
13078 }
13079 struct_ser.end()
13080 }
13081}
13082impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
13083 #[allow(deprecated)]
13084 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13085 where
13086 D: serde::Deserializer<'de>,
13087 {
13088 const FIELDS: &[&str] = &[
13089 "fragments",
13090 "ctx",
13091 ];
13092
13093 #[allow(clippy::enum_variant_names)]
13094 enum GeneratedField {
13095 Fragments,
13096 Ctx,
13097 }
13098 impl<'de> serde::Deserialize<'de> for GeneratedField {
13099 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13100 where
13101 D: serde::Deserializer<'de>,
13102 {
13103 struct GeneratedVisitor;
13104
13105 impl serde::de::Visitor<'_> for GeneratedVisitor {
13106 type Value = GeneratedField;
13107
13108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13109 write!(formatter, "expected one of: {:?}", &FIELDS)
13110 }
13111
13112 #[allow(unused_variables)]
13113 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13114 where
13115 E: serde::de::Error,
13116 {
13117 match value {
13118 "fragments" => Ok(GeneratedField::Fragments),
13119 "ctx" => Ok(GeneratedField::Ctx),
13120 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13121 }
13122 }
13123 }
13124 deserializer.deserialize_identifier(GeneratedVisitor)
13125 }
13126 }
13127 struct GeneratedVisitor;
13128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13129 type Value = list_table_fragments_response::TableFragmentInfo;
13130
13131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13132 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
13133 }
13134
13135 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
13136 where
13137 V: serde::de::MapAccess<'de>,
13138 {
13139 let mut fragments__ = None;
13140 let mut ctx__ = None;
13141 while let Some(k) = map_.next_key()? {
13142 match k {
13143 GeneratedField::Fragments => {
13144 if fragments__.is_some() {
13145 return Err(serde::de::Error::duplicate_field("fragments"));
13146 }
13147 fragments__ = Some(map_.next_value()?);
13148 }
13149 GeneratedField::Ctx => {
13150 if ctx__.is_some() {
13151 return Err(serde::de::Error::duplicate_field("ctx"));
13152 }
13153 ctx__ = map_.next_value()?;
13154 }
13155 }
13156 }
13157 Ok(list_table_fragments_response::TableFragmentInfo {
13158 fragments: fragments__.unwrap_or_default(),
13159 ctx: ctx__,
13160 })
13161 }
13162 }
13163 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
13164 }
13165}
13166impl serde::Serialize for ListUnmigratedTablesRequest {
13167 #[allow(deprecated)]
13168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13169 where
13170 S: serde::Serializer,
13171 {
13172 use serde::ser::SerializeStruct;
13173 let len = 0;
13174 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
13175 struct_ser.end()
13176 }
13177}
13178impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
13179 #[allow(deprecated)]
13180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13181 where
13182 D: serde::Deserializer<'de>,
13183 {
13184 const FIELDS: &[&str] = &[
13185 ];
13186
13187 #[allow(clippy::enum_variant_names)]
13188 enum GeneratedField {
13189 }
13190 impl<'de> serde::Deserialize<'de> for GeneratedField {
13191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13192 where
13193 D: serde::Deserializer<'de>,
13194 {
13195 struct GeneratedVisitor;
13196
13197 impl serde::de::Visitor<'_> for GeneratedVisitor {
13198 type Value = GeneratedField;
13199
13200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13201 write!(formatter, "expected one of: {:?}", &FIELDS)
13202 }
13203
13204 #[allow(unused_variables)]
13205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13206 where
13207 E: serde::de::Error,
13208 {
13209 Err(serde::de::Error::unknown_field(value, FIELDS))
13210 }
13211 }
13212 deserializer.deserialize_identifier(GeneratedVisitor)
13213 }
13214 }
13215 struct GeneratedVisitor;
13216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13217 type Value = ListUnmigratedTablesRequest;
13218
13219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13220 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
13221 }
13222
13223 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
13224 where
13225 V: serde::de::MapAccess<'de>,
13226 {
13227 while map_.next_key::<GeneratedField>()?.is_some() {
13228 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13229 }
13230 Ok(ListUnmigratedTablesRequest {
13231 })
13232 }
13233 }
13234 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
13235 }
13236}
13237impl serde::Serialize for ListUnmigratedTablesResponse {
13238 #[allow(deprecated)]
13239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13240 where
13241 S: serde::Serializer,
13242 {
13243 use serde::ser::SerializeStruct;
13244 let mut len = 0;
13245 if !self.tables.is_empty() {
13246 len += 1;
13247 }
13248 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
13249 if !self.tables.is_empty() {
13250 struct_ser.serialize_field("tables", &self.tables)?;
13251 }
13252 struct_ser.end()
13253 }
13254}
13255impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
13256 #[allow(deprecated)]
13257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13258 where
13259 D: serde::Deserializer<'de>,
13260 {
13261 const FIELDS: &[&str] = &[
13262 "tables",
13263 ];
13264
13265 #[allow(clippy::enum_variant_names)]
13266 enum GeneratedField {
13267 Tables,
13268 }
13269 impl<'de> serde::Deserialize<'de> for GeneratedField {
13270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13271 where
13272 D: serde::Deserializer<'de>,
13273 {
13274 struct GeneratedVisitor;
13275
13276 impl serde::de::Visitor<'_> for GeneratedVisitor {
13277 type Value = GeneratedField;
13278
13279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13280 write!(formatter, "expected one of: {:?}", &FIELDS)
13281 }
13282
13283 #[allow(unused_variables)]
13284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13285 where
13286 E: serde::de::Error,
13287 {
13288 match value {
13289 "tables" => Ok(GeneratedField::Tables),
13290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13291 }
13292 }
13293 }
13294 deserializer.deserialize_identifier(GeneratedVisitor)
13295 }
13296 }
13297 struct GeneratedVisitor;
13298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13299 type Value = ListUnmigratedTablesResponse;
13300
13301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13302 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
13303 }
13304
13305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
13306 where
13307 V: serde::de::MapAccess<'de>,
13308 {
13309 let mut tables__ = None;
13310 while let Some(k) = map_.next_key()? {
13311 match k {
13312 GeneratedField::Tables => {
13313 if tables__.is_some() {
13314 return Err(serde::de::Error::duplicate_field("tables"));
13315 }
13316 tables__ = Some(map_.next_value()?);
13317 }
13318 }
13319 }
13320 Ok(ListUnmigratedTablesResponse {
13321 tables: tables__.unwrap_or_default(),
13322 })
13323 }
13324 }
13325 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
13326 }
13327}
13328impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
13329 #[allow(deprecated)]
13330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13331 where
13332 S: serde::Serializer,
13333 {
13334 use serde::ser::SerializeStruct;
13335 let mut len = 0;
13336 if self.table_id != 0 {
13337 len += 1;
13338 }
13339 if !self.table_name.is_empty() {
13340 len += 1;
13341 }
13342 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
13343 if self.table_id != 0 {
13344 struct_ser.serialize_field("tableId", &self.table_id)?;
13345 }
13346 if !self.table_name.is_empty() {
13347 struct_ser.serialize_field("tableName", &self.table_name)?;
13348 }
13349 struct_ser.end()
13350 }
13351}
13352impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
13353 #[allow(deprecated)]
13354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13355 where
13356 D: serde::Deserializer<'de>,
13357 {
13358 const FIELDS: &[&str] = &[
13359 "table_id",
13360 "tableId",
13361 "table_name",
13362 "tableName",
13363 ];
13364
13365 #[allow(clippy::enum_variant_names)]
13366 enum GeneratedField {
13367 TableId,
13368 TableName,
13369 }
13370 impl<'de> serde::Deserialize<'de> for GeneratedField {
13371 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13372 where
13373 D: serde::Deserializer<'de>,
13374 {
13375 struct GeneratedVisitor;
13376
13377 impl serde::de::Visitor<'_> for GeneratedVisitor {
13378 type Value = GeneratedField;
13379
13380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13381 write!(formatter, "expected one of: {:?}", &FIELDS)
13382 }
13383
13384 #[allow(unused_variables)]
13385 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13386 where
13387 E: serde::de::Error,
13388 {
13389 match value {
13390 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13391 "tableName" | "table_name" => Ok(GeneratedField::TableName),
13392 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13393 }
13394 }
13395 }
13396 deserializer.deserialize_identifier(GeneratedVisitor)
13397 }
13398 }
13399 struct GeneratedVisitor;
13400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13401 type Value = list_unmigrated_tables_response::UnmigratedTable;
13402
13403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13404 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
13405 }
13406
13407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
13408 where
13409 V: serde::de::MapAccess<'de>,
13410 {
13411 let mut table_id__ = None;
13412 let mut table_name__ = None;
13413 while let Some(k) = map_.next_key()? {
13414 match k {
13415 GeneratedField::TableId => {
13416 if table_id__.is_some() {
13417 return Err(serde::de::Error::duplicate_field("tableId"));
13418 }
13419 table_id__ =
13420 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13421 ;
13422 }
13423 GeneratedField::TableName => {
13424 if table_name__.is_some() {
13425 return Err(serde::de::Error::duplicate_field("tableName"));
13426 }
13427 table_name__ = Some(map_.next_value()?);
13428 }
13429 }
13430 }
13431 Ok(list_unmigrated_tables_response::UnmigratedTable {
13432 table_id: table_id__.unwrap_or_default(),
13433 table_name: table_name__.unwrap_or_default(),
13434 })
13435 }
13436 }
13437 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
13438 }
13439}
13440impl serde::Serialize for MembersRequest {
13441 #[allow(deprecated)]
13442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13443 where
13444 S: serde::Serializer,
13445 {
13446 use serde::ser::SerializeStruct;
13447 let len = 0;
13448 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
13449 struct_ser.end()
13450 }
13451}
13452impl<'de> serde::Deserialize<'de> for MembersRequest {
13453 #[allow(deprecated)]
13454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13455 where
13456 D: serde::Deserializer<'de>,
13457 {
13458 const FIELDS: &[&str] = &[
13459 ];
13460
13461 #[allow(clippy::enum_variant_names)]
13462 enum GeneratedField {
13463 }
13464 impl<'de> serde::Deserialize<'de> for GeneratedField {
13465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13466 where
13467 D: serde::Deserializer<'de>,
13468 {
13469 struct GeneratedVisitor;
13470
13471 impl serde::de::Visitor<'_> for GeneratedVisitor {
13472 type Value = GeneratedField;
13473
13474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13475 write!(formatter, "expected one of: {:?}", &FIELDS)
13476 }
13477
13478 #[allow(unused_variables)]
13479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13480 where
13481 E: serde::de::Error,
13482 {
13483 Err(serde::de::Error::unknown_field(value, FIELDS))
13484 }
13485 }
13486 deserializer.deserialize_identifier(GeneratedVisitor)
13487 }
13488 }
13489 struct GeneratedVisitor;
13490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13491 type Value = MembersRequest;
13492
13493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13494 formatter.write_str("struct meta.MembersRequest")
13495 }
13496
13497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
13498 where
13499 V: serde::de::MapAccess<'de>,
13500 {
13501 while map_.next_key::<GeneratedField>()?.is_some() {
13502 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13503 }
13504 Ok(MembersRequest {
13505 })
13506 }
13507 }
13508 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
13509 }
13510}
13511impl serde::Serialize for MembersResponse {
13512 #[allow(deprecated)]
13513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13514 where
13515 S: serde::Serializer,
13516 {
13517 use serde::ser::SerializeStruct;
13518 let mut len = 0;
13519 if !self.members.is_empty() {
13520 len += 1;
13521 }
13522 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
13523 if !self.members.is_empty() {
13524 struct_ser.serialize_field("members", &self.members)?;
13525 }
13526 struct_ser.end()
13527 }
13528}
13529impl<'de> serde::Deserialize<'de> for MembersResponse {
13530 #[allow(deprecated)]
13531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13532 where
13533 D: serde::Deserializer<'de>,
13534 {
13535 const FIELDS: &[&str] = &[
13536 "members",
13537 ];
13538
13539 #[allow(clippy::enum_variant_names)]
13540 enum GeneratedField {
13541 Members,
13542 }
13543 impl<'de> serde::Deserialize<'de> for GeneratedField {
13544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13545 where
13546 D: serde::Deserializer<'de>,
13547 {
13548 struct GeneratedVisitor;
13549
13550 impl serde::de::Visitor<'_> for GeneratedVisitor {
13551 type Value = GeneratedField;
13552
13553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13554 write!(formatter, "expected one of: {:?}", &FIELDS)
13555 }
13556
13557 #[allow(unused_variables)]
13558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13559 where
13560 E: serde::de::Error,
13561 {
13562 match value {
13563 "members" => Ok(GeneratedField::Members),
13564 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13565 }
13566 }
13567 }
13568 deserializer.deserialize_identifier(GeneratedVisitor)
13569 }
13570 }
13571 struct GeneratedVisitor;
13572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13573 type Value = MembersResponse;
13574
13575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13576 formatter.write_str("struct meta.MembersResponse")
13577 }
13578
13579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
13580 where
13581 V: serde::de::MapAccess<'de>,
13582 {
13583 let mut members__ = None;
13584 while let Some(k) = map_.next_key()? {
13585 match k {
13586 GeneratedField::Members => {
13587 if members__.is_some() {
13588 return Err(serde::de::Error::duplicate_field("members"));
13589 }
13590 members__ = Some(map_.next_value()?);
13591 }
13592 }
13593 }
13594 Ok(MembersResponse {
13595 members: members__.unwrap_or_default(),
13596 })
13597 }
13598 }
13599 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
13600 }
13601}
13602impl serde::Serialize for MetaMember {
13603 #[allow(deprecated)]
13604 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13605 where
13606 S: serde::Serializer,
13607 {
13608 use serde::ser::SerializeStruct;
13609 let mut len = 0;
13610 if self.address.is_some() {
13611 len += 1;
13612 }
13613 if self.is_leader {
13614 len += 1;
13615 }
13616 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
13617 if let Some(v) = self.address.as_ref() {
13618 struct_ser.serialize_field("address", v)?;
13619 }
13620 if self.is_leader {
13621 struct_ser.serialize_field("isLeader", &self.is_leader)?;
13622 }
13623 struct_ser.end()
13624 }
13625}
13626impl<'de> serde::Deserialize<'de> for MetaMember {
13627 #[allow(deprecated)]
13628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13629 where
13630 D: serde::Deserializer<'de>,
13631 {
13632 const FIELDS: &[&str] = &[
13633 "address",
13634 "is_leader",
13635 "isLeader",
13636 ];
13637
13638 #[allow(clippy::enum_variant_names)]
13639 enum GeneratedField {
13640 Address,
13641 IsLeader,
13642 }
13643 impl<'de> serde::Deserialize<'de> for GeneratedField {
13644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13645 where
13646 D: serde::Deserializer<'de>,
13647 {
13648 struct GeneratedVisitor;
13649
13650 impl serde::de::Visitor<'_> for GeneratedVisitor {
13651 type Value = GeneratedField;
13652
13653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13654 write!(formatter, "expected one of: {:?}", &FIELDS)
13655 }
13656
13657 #[allow(unused_variables)]
13658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13659 where
13660 E: serde::de::Error,
13661 {
13662 match value {
13663 "address" => Ok(GeneratedField::Address),
13664 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
13665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13666 }
13667 }
13668 }
13669 deserializer.deserialize_identifier(GeneratedVisitor)
13670 }
13671 }
13672 struct GeneratedVisitor;
13673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13674 type Value = MetaMember;
13675
13676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13677 formatter.write_str("struct meta.MetaMember")
13678 }
13679
13680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
13681 where
13682 V: serde::de::MapAccess<'de>,
13683 {
13684 let mut address__ = None;
13685 let mut is_leader__ = None;
13686 while let Some(k) = map_.next_key()? {
13687 match k {
13688 GeneratedField::Address => {
13689 if address__.is_some() {
13690 return Err(serde::de::Error::duplicate_field("address"));
13691 }
13692 address__ = map_.next_value()?;
13693 }
13694 GeneratedField::IsLeader => {
13695 if is_leader__.is_some() {
13696 return Err(serde::de::Error::duplicate_field("isLeader"));
13697 }
13698 is_leader__ = Some(map_.next_value()?);
13699 }
13700 }
13701 }
13702 Ok(MetaMember {
13703 address: address__,
13704 is_leader: is_leader__.unwrap_or_default(),
13705 })
13706 }
13707 }
13708 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
13709 }
13710}
13711impl serde::Serialize for MetaSnapshot {
13712 #[allow(deprecated)]
13713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13714 where
13715 S: serde::Serializer,
13716 {
13717 use serde::ser::SerializeStruct;
13718 let mut len = 0;
13719 if !self.databases.is_empty() {
13720 len += 1;
13721 }
13722 if !self.schemas.is_empty() {
13723 len += 1;
13724 }
13725 if !self.sources.is_empty() {
13726 len += 1;
13727 }
13728 if !self.sinks.is_empty() {
13729 len += 1;
13730 }
13731 if !self.tables.is_empty() {
13732 len += 1;
13733 }
13734 if !self.indexes.is_empty() {
13735 len += 1;
13736 }
13737 if !self.views.is_empty() {
13738 len += 1;
13739 }
13740 if !self.functions.is_empty() {
13741 len += 1;
13742 }
13743 if !self.connections.is_empty() {
13744 len += 1;
13745 }
13746 if !self.subscriptions.is_empty() {
13747 len += 1;
13748 }
13749 if !self.users.is_empty() {
13750 len += 1;
13751 }
13752 if self.session_params.is_some() {
13753 len += 1;
13754 }
13755 if !self.secrets.is_empty() {
13756 len += 1;
13757 }
13758 if self.cluster_resource.is_some() {
13759 len += 1;
13760 }
13761 if !self.nodes.is_empty() {
13762 len += 1;
13763 }
13764 if self.hummock_version.is_some() {
13765 len += 1;
13766 }
13767 if self.meta_backup_manifest_id.is_some() {
13768 len += 1;
13769 }
13770 if self.hummock_write_limits.is_some() {
13771 len += 1;
13772 }
13773 if !self.streaming_worker_slot_mappings.is_empty() {
13774 len += 1;
13775 }
13776 if !self.serving_worker_slot_mappings.is_empty() {
13777 len += 1;
13778 }
13779 if !self.object_dependencies.is_empty() {
13780 len += 1;
13781 }
13782 if self.table_refill_runtime_config.is_some() {
13783 len += 1;
13784 }
13785 if self.version.is_some() {
13786 len += 1;
13787 }
13788 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
13789 if !self.databases.is_empty() {
13790 struct_ser.serialize_field("databases", &self.databases)?;
13791 }
13792 if !self.schemas.is_empty() {
13793 struct_ser.serialize_field("schemas", &self.schemas)?;
13794 }
13795 if !self.sources.is_empty() {
13796 struct_ser.serialize_field("sources", &self.sources)?;
13797 }
13798 if !self.sinks.is_empty() {
13799 struct_ser.serialize_field("sinks", &self.sinks)?;
13800 }
13801 if !self.tables.is_empty() {
13802 struct_ser.serialize_field("tables", &self.tables)?;
13803 }
13804 if !self.indexes.is_empty() {
13805 struct_ser.serialize_field("indexes", &self.indexes)?;
13806 }
13807 if !self.views.is_empty() {
13808 struct_ser.serialize_field("views", &self.views)?;
13809 }
13810 if !self.functions.is_empty() {
13811 struct_ser.serialize_field("functions", &self.functions)?;
13812 }
13813 if !self.connections.is_empty() {
13814 struct_ser.serialize_field("connections", &self.connections)?;
13815 }
13816 if !self.subscriptions.is_empty() {
13817 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
13818 }
13819 if !self.users.is_empty() {
13820 struct_ser.serialize_field("users", &self.users)?;
13821 }
13822 if let Some(v) = self.session_params.as_ref() {
13823 struct_ser.serialize_field("sessionParams", v)?;
13824 }
13825 if !self.secrets.is_empty() {
13826 struct_ser.serialize_field("secrets", &self.secrets)?;
13827 }
13828 if let Some(v) = self.cluster_resource.as_ref() {
13829 struct_ser.serialize_field("clusterResource", v)?;
13830 }
13831 if !self.nodes.is_empty() {
13832 struct_ser.serialize_field("nodes", &self.nodes)?;
13833 }
13834 if let Some(v) = self.hummock_version.as_ref() {
13835 struct_ser.serialize_field("hummockVersion", v)?;
13836 }
13837 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
13838 struct_ser.serialize_field("metaBackupManifestId", v)?;
13839 }
13840 if let Some(v) = self.hummock_write_limits.as_ref() {
13841 struct_ser.serialize_field("hummockWriteLimits", v)?;
13842 }
13843 if !self.streaming_worker_slot_mappings.is_empty() {
13844 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
13845 }
13846 if !self.serving_worker_slot_mappings.is_empty() {
13847 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
13848 }
13849 if !self.object_dependencies.is_empty() {
13850 struct_ser.serialize_field("objectDependencies", &self.object_dependencies)?;
13851 }
13852 if let Some(v) = self.table_refill_runtime_config.as_ref() {
13853 struct_ser.serialize_field("tableRefillRuntimeConfig", v)?;
13854 }
13855 if let Some(v) = self.version.as_ref() {
13856 struct_ser.serialize_field("version", v)?;
13857 }
13858 struct_ser.end()
13859 }
13860}
13861impl<'de> serde::Deserialize<'de> for MetaSnapshot {
13862 #[allow(deprecated)]
13863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13864 where
13865 D: serde::Deserializer<'de>,
13866 {
13867 const FIELDS: &[&str] = &[
13868 "databases",
13869 "schemas",
13870 "sources",
13871 "sinks",
13872 "tables",
13873 "indexes",
13874 "views",
13875 "functions",
13876 "connections",
13877 "subscriptions",
13878 "users",
13879 "session_params",
13880 "sessionParams",
13881 "secrets",
13882 "cluster_resource",
13883 "clusterResource",
13884 "nodes",
13885 "hummock_version",
13886 "hummockVersion",
13887 "meta_backup_manifest_id",
13888 "metaBackupManifestId",
13889 "hummock_write_limits",
13890 "hummockWriteLimits",
13891 "streaming_worker_slot_mappings",
13892 "streamingWorkerSlotMappings",
13893 "serving_worker_slot_mappings",
13894 "servingWorkerSlotMappings",
13895 "object_dependencies",
13896 "objectDependencies",
13897 "table_refill_runtime_config",
13898 "tableRefillRuntimeConfig",
13899 "version",
13900 ];
13901
13902 #[allow(clippy::enum_variant_names)]
13903 enum GeneratedField {
13904 Databases,
13905 Schemas,
13906 Sources,
13907 Sinks,
13908 Tables,
13909 Indexes,
13910 Views,
13911 Functions,
13912 Connections,
13913 Subscriptions,
13914 Users,
13915 SessionParams,
13916 Secrets,
13917 ClusterResource,
13918 Nodes,
13919 HummockVersion,
13920 MetaBackupManifestId,
13921 HummockWriteLimits,
13922 StreamingWorkerSlotMappings,
13923 ServingWorkerSlotMappings,
13924 ObjectDependencies,
13925 TableRefillRuntimeConfig,
13926 Version,
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 "databases" => Ok(GeneratedField::Databases),
13949 "schemas" => Ok(GeneratedField::Schemas),
13950 "sources" => Ok(GeneratedField::Sources),
13951 "sinks" => Ok(GeneratedField::Sinks),
13952 "tables" => Ok(GeneratedField::Tables),
13953 "indexes" => Ok(GeneratedField::Indexes),
13954 "views" => Ok(GeneratedField::Views),
13955 "functions" => Ok(GeneratedField::Functions),
13956 "connections" => Ok(GeneratedField::Connections),
13957 "subscriptions" => Ok(GeneratedField::Subscriptions),
13958 "users" => Ok(GeneratedField::Users),
13959 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13960 "secrets" => Ok(GeneratedField::Secrets),
13961 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13962 "nodes" => Ok(GeneratedField::Nodes),
13963 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13964 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13965 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13966 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13967 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13968 "objectDependencies" | "object_dependencies" => Ok(GeneratedField::ObjectDependencies),
13969 "tableRefillRuntimeConfig" | "table_refill_runtime_config" => Ok(GeneratedField::TableRefillRuntimeConfig),
13970 "version" => Ok(GeneratedField::Version),
13971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13972 }
13973 }
13974 }
13975 deserializer.deserialize_identifier(GeneratedVisitor)
13976 }
13977 }
13978 struct GeneratedVisitor;
13979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13980 type Value = MetaSnapshot;
13981
13982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13983 formatter.write_str("struct meta.MetaSnapshot")
13984 }
13985
13986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13987 where
13988 V: serde::de::MapAccess<'de>,
13989 {
13990 let mut databases__ = None;
13991 let mut schemas__ = None;
13992 let mut sources__ = None;
13993 let mut sinks__ = None;
13994 let mut tables__ = None;
13995 let mut indexes__ = None;
13996 let mut views__ = None;
13997 let mut functions__ = None;
13998 let mut connections__ = None;
13999 let mut subscriptions__ = None;
14000 let mut users__ = None;
14001 let mut session_params__ = None;
14002 let mut secrets__ = None;
14003 let mut cluster_resource__ = None;
14004 let mut nodes__ = None;
14005 let mut hummock_version__ = None;
14006 let mut meta_backup_manifest_id__ = None;
14007 let mut hummock_write_limits__ = None;
14008 let mut streaming_worker_slot_mappings__ = None;
14009 let mut serving_worker_slot_mappings__ = None;
14010 let mut object_dependencies__ = None;
14011 let mut table_refill_runtime_config__ = None;
14012 let mut version__ = None;
14013 while let Some(k) = map_.next_key()? {
14014 match k {
14015 GeneratedField::Databases => {
14016 if databases__.is_some() {
14017 return Err(serde::de::Error::duplicate_field("databases"));
14018 }
14019 databases__ = Some(map_.next_value()?);
14020 }
14021 GeneratedField::Schemas => {
14022 if schemas__.is_some() {
14023 return Err(serde::de::Error::duplicate_field("schemas"));
14024 }
14025 schemas__ = Some(map_.next_value()?);
14026 }
14027 GeneratedField::Sources => {
14028 if sources__.is_some() {
14029 return Err(serde::de::Error::duplicate_field("sources"));
14030 }
14031 sources__ = Some(map_.next_value()?);
14032 }
14033 GeneratedField::Sinks => {
14034 if sinks__.is_some() {
14035 return Err(serde::de::Error::duplicate_field("sinks"));
14036 }
14037 sinks__ = Some(map_.next_value()?);
14038 }
14039 GeneratedField::Tables => {
14040 if tables__.is_some() {
14041 return Err(serde::de::Error::duplicate_field("tables"));
14042 }
14043 tables__ = Some(map_.next_value()?);
14044 }
14045 GeneratedField::Indexes => {
14046 if indexes__.is_some() {
14047 return Err(serde::de::Error::duplicate_field("indexes"));
14048 }
14049 indexes__ = Some(map_.next_value()?);
14050 }
14051 GeneratedField::Views => {
14052 if views__.is_some() {
14053 return Err(serde::de::Error::duplicate_field("views"));
14054 }
14055 views__ = Some(map_.next_value()?);
14056 }
14057 GeneratedField::Functions => {
14058 if functions__.is_some() {
14059 return Err(serde::de::Error::duplicate_field("functions"));
14060 }
14061 functions__ = Some(map_.next_value()?);
14062 }
14063 GeneratedField::Connections => {
14064 if connections__.is_some() {
14065 return Err(serde::de::Error::duplicate_field("connections"));
14066 }
14067 connections__ = Some(map_.next_value()?);
14068 }
14069 GeneratedField::Subscriptions => {
14070 if subscriptions__.is_some() {
14071 return Err(serde::de::Error::duplicate_field("subscriptions"));
14072 }
14073 subscriptions__ = Some(map_.next_value()?);
14074 }
14075 GeneratedField::Users => {
14076 if users__.is_some() {
14077 return Err(serde::de::Error::duplicate_field("users"));
14078 }
14079 users__ = Some(map_.next_value()?);
14080 }
14081 GeneratedField::SessionParams => {
14082 if session_params__.is_some() {
14083 return Err(serde::de::Error::duplicate_field("sessionParams"));
14084 }
14085 session_params__ = map_.next_value()?;
14086 }
14087 GeneratedField::Secrets => {
14088 if secrets__.is_some() {
14089 return Err(serde::de::Error::duplicate_field("secrets"));
14090 }
14091 secrets__ = Some(map_.next_value()?);
14092 }
14093 GeneratedField::ClusterResource => {
14094 if cluster_resource__.is_some() {
14095 return Err(serde::de::Error::duplicate_field("clusterResource"));
14096 }
14097 cluster_resource__ = map_.next_value()?;
14098 }
14099 GeneratedField::Nodes => {
14100 if nodes__.is_some() {
14101 return Err(serde::de::Error::duplicate_field("nodes"));
14102 }
14103 nodes__ = Some(map_.next_value()?);
14104 }
14105 GeneratedField::HummockVersion => {
14106 if hummock_version__.is_some() {
14107 return Err(serde::de::Error::duplicate_field("hummockVersion"));
14108 }
14109 hummock_version__ = map_.next_value()?;
14110 }
14111 GeneratedField::MetaBackupManifestId => {
14112 if meta_backup_manifest_id__.is_some() {
14113 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14114 }
14115 meta_backup_manifest_id__ = map_.next_value()?;
14116 }
14117 GeneratedField::HummockWriteLimits => {
14118 if hummock_write_limits__.is_some() {
14119 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14120 }
14121 hummock_write_limits__ = map_.next_value()?;
14122 }
14123 GeneratedField::StreamingWorkerSlotMappings => {
14124 if streaming_worker_slot_mappings__.is_some() {
14125 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
14126 }
14127 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
14128 }
14129 GeneratedField::ServingWorkerSlotMappings => {
14130 if serving_worker_slot_mappings__.is_some() {
14131 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14132 }
14133 serving_worker_slot_mappings__ = Some(map_.next_value()?);
14134 }
14135 GeneratedField::ObjectDependencies => {
14136 if object_dependencies__.is_some() {
14137 return Err(serde::de::Error::duplicate_field("objectDependencies"));
14138 }
14139 object_dependencies__ = Some(map_.next_value()?);
14140 }
14141 GeneratedField::TableRefillRuntimeConfig => {
14142 if table_refill_runtime_config__.is_some() {
14143 return Err(serde::de::Error::duplicate_field("tableRefillRuntimeConfig"));
14144 }
14145 table_refill_runtime_config__ = map_.next_value()?;
14146 }
14147 GeneratedField::Version => {
14148 if version__.is_some() {
14149 return Err(serde::de::Error::duplicate_field("version"));
14150 }
14151 version__ = map_.next_value()?;
14152 }
14153 }
14154 }
14155 Ok(MetaSnapshot {
14156 databases: databases__.unwrap_or_default(),
14157 schemas: schemas__.unwrap_or_default(),
14158 sources: sources__.unwrap_or_default(),
14159 sinks: sinks__.unwrap_or_default(),
14160 tables: tables__.unwrap_or_default(),
14161 indexes: indexes__.unwrap_or_default(),
14162 views: views__.unwrap_or_default(),
14163 functions: functions__.unwrap_or_default(),
14164 connections: connections__.unwrap_or_default(),
14165 subscriptions: subscriptions__.unwrap_or_default(),
14166 users: users__.unwrap_or_default(),
14167 session_params: session_params__,
14168 secrets: secrets__.unwrap_or_default(),
14169 cluster_resource: cluster_resource__,
14170 nodes: nodes__.unwrap_or_default(),
14171 hummock_version: hummock_version__,
14172 meta_backup_manifest_id: meta_backup_manifest_id__,
14173 hummock_write_limits: hummock_write_limits__,
14174 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
14175 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
14176 object_dependencies: object_dependencies__.unwrap_or_default(),
14177 table_refill_runtime_config: table_refill_runtime_config__,
14178 version: version__,
14179 })
14180 }
14181 }
14182 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
14183 }
14184}
14185impl serde::Serialize for meta_snapshot::SnapshotVersion {
14186 #[allow(deprecated)]
14187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14188 where
14189 S: serde::Serializer,
14190 {
14191 use serde::ser::SerializeStruct;
14192 let mut len = 0;
14193 if self.catalog_version != 0 {
14194 len += 1;
14195 }
14196 if self.worker_node_version != 0 {
14197 len += 1;
14198 }
14199 if self.streaming_worker_slot_mapping_version != 0 {
14200 len += 1;
14201 }
14202 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
14203 if self.catalog_version != 0 {
14204 #[allow(clippy::needless_borrow)]
14205 #[allow(clippy::needless_borrows_for_generic_args)]
14206 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
14207 }
14208 if self.worker_node_version != 0 {
14209 #[allow(clippy::needless_borrow)]
14210 #[allow(clippy::needless_borrows_for_generic_args)]
14211 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
14212 }
14213 if self.streaming_worker_slot_mapping_version != 0 {
14214 #[allow(clippy::needless_borrow)]
14215 #[allow(clippy::needless_borrows_for_generic_args)]
14216 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
14217 }
14218 struct_ser.end()
14219 }
14220}
14221impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
14222 #[allow(deprecated)]
14223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14224 where
14225 D: serde::Deserializer<'de>,
14226 {
14227 const FIELDS: &[&str] = &[
14228 "catalog_version",
14229 "catalogVersion",
14230 "worker_node_version",
14231 "workerNodeVersion",
14232 "streaming_worker_slot_mapping_version",
14233 "streamingWorkerSlotMappingVersion",
14234 ];
14235
14236 #[allow(clippy::enum_variant_names)]
14237 enum GeneratedField {
14238 CatalogVersion,
14239 WorkerNodeVersion,
14240 StreamingWorkerSlotMappingVersion,
14241 }
14242 impl<'de> serde::Deserialize<'de> for GeneratedField {
14243 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14244 where
14245 D: serde::Deserializer<'de>,
14246 {
14247 struct GeneratedVisitor;
14248
14249 impl serde::de::Visitor<'_> for GeneratedVisitor {
14250 type Value = GeneratedField;
14251
14252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14253 write!(formatter, "expected one of: {:?}", &FIELDS)
14254 }
14255
14256 #[allow(unused_variables)]
14257 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14258 where
14259 E: serde::de::Error,
14260 {
14261 match value {
14262 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
14263 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
14264 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
14265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14266 }
14267 }
14268 }
14269 deserializer.deserialize_identifier(GeneratedVisitor)
14270 }
14271 }
14272 struct GeneratedVisitor;
14273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14274 type Value = meta_snapshot::SnapshotVersion;
14275
14276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14277 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
14278 }
14279
14280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
14281 where
14282 V: serde::de::MapAccess<'de>,
14283 {
14284 let mut catalog_version__ = None;
14285 let mut worker_node_version__ = None;
14286 let mut streaming_worker_slot_mapping_version__ = None;
14287 while let Some(k) = map_.next_key()? {
14288 match k {
14289 GeneratedField::CatalogVersion => {
14290 if catalog_version__.is_some() {
14291 return Err(serde::de::Error::duplicate_field("catalogVersion"));
14292 }
14293 catalog_version__ =
14294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14295 ;
14296 }
14297 GeneratedField::WorkerNodeVersion => {
14298 if worker_node_version__.is_some() {
14299 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
14300 }
14301 worker_node_version__ =
14302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14303 ;
14304 }
14305 GeneratedField::StreamingWorkerSlotMappingVersion => {
14306 if streaming_worker_slot_mapping_version__.is_some() {
14307 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
14308 }
14309 streaming_worker_slot_mapping_version__ =
14310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14311 ;
14312 }
14313 }
14314 }
14315 Ok(meta_snapshot::SnapshotVersion {
14316 catalog_version: catalog_version__.unwrap_or_default(),
14317 worker_node_version: worker_node_version__.unwrap_or_default(),
14318 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
14319 })
14320 }
14321 }
14322 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
14323 }
14324}
14325impl serde::Serialize for MigrationPlan {
14326 #[allow(deprecated)]
14327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14328 where
14329 S: serde::Serializer,
14330 {
14331 use serde::ser::SerializeStruct;
14332 let mut len = 0;
14333 if !self.worker_slot_migration_plan.is_empty() {
14334 len += 1;
14335 }
14336 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
14337 if !self.worker_slot_migration_plan.is_empty() {
14338 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
14339 .map(|(k, v)| (k, v.to_string())).collect();
14340 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
14341 }
14342 struct_ser.end()
14343 }
14344}
14345impl<'de> serde::Deserialize<'de> for MigrationPlan {
14346 #[allow(deprecated)]
14347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14348 where
14349 D: serde::Deserializer<'de>,
14350 {
14351 const FIELDS: &[&str] = &[
14352 "worker_slot_migration_plan",
14353 "workerSlotMigrationPlan",
14354 ];
14355
14356 #[allow(clippy::enum_variant_names)]
14357 enum GeneratedField {
14358 WorkerSlotMigrationPlan,
14359 }
14360 impl<'de> serde::Deserialize<'de> for GeneratedField {
14361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14362 where
14363 D: serde::Deserializer<'de>,
14364 {
14365 struct GeneratedVisitor;
14366
14367 impl serde::de::Visitor<'_> for GeneratedVisitor {
14368 type Value = GeneratedField;
14369
14370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14371 write!(formatter, "expected one of: {:?}", &FIELDS)
14372 }
14373
14374 #[allow(unused_variables)]
14375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14376 where
14377 E: serde::de::Error,
14378 {
14379 match value {
14380 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
14381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14382 }
14383 }
14384 }
14385 deserializer.deserialize_identifier(GeneratedVisitor)
14386 }
14387 }
14388 struct GeneratedVisitor;
14389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14390 type Value = MigrationPlan;
14391
14392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14393 formatter.write_str("struct meta.MigrationPlan")
14394 }
14395
14396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
14397 where
14398 V: serde::de::MapAccess<'de>,
14399 {
14400 let mut worker_slot_migration_plan__ = None;
14401 while let Some(k) = map_.next_key()? {
14402 match k {
14403 GeneratedField::WorkerSlotMigrationPlan => {
14404 if worker_slot_migration_plan__.is_some() {
14405 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
14406 }
14407 worker_slot_migration_plan__ = Some(
14408 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14409 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
14410 );
14411 }
14412 }
14413 }
14414 Ok(MigrationPlan {
14415 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
14416 })
14417 }
14418 }
14419 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
14420 }
14421}
14422impl serde::Serialize for Object {
14423 #[allow(deprecated)]
14424 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14425 where
14426 S: serde::Serializer,
14427 {
14428 use serde::ser::SerializeStruct;
14429 let mut len = 0;
14430 if self.object_info.is_some() {
14431 len += 1;
14432 }
14433 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
14434 if let Some(v) = self.object_info.as_ref() {
14435 match v {
14436 object::ObjectInfo::Database(v) => {
14437 struct_ser.serialize_field("database", v)?;
14438 }
14439 object::ObjectInfo::Schema(v) => {
14440 struct_ser.serialize_field("schema", v)?;
14441 }
14442 object::ObjectInfo::Table(v) => {
14443 struct_ser.serialize_field("table", v)?;
14444 }
14445 object::ObjectInfo::Index(v) => {
14446 struct_ser.serialize_field("index", v)?;
14447 }
14448 object::ObjectInfo::Source(v) => {
14449 struct_ser.serialize_field("source", v)?;
14450 }
14451 object::ObjectInfo::Sink(v) => {
14452 struct_ser.serialize_field("sink", v)?;
14453 }
14454 object::ObjectInfo::View(v) => {
14455 struct_ser.serialize_field("view", v)?;
14456 }
14457 object::ObjectInfo::Function(v) => {
14458 struct_ser.serialize_field("function", v)?;
14459 }
14460 object::ObjectInfo::Connection(v) => {
14461 struct_ser.serialize_field("connection", v)?;
14462 }
14463 object::ObjectInfo::Subscription(v) => {
14464 struct_ser.serialize_field("subscription", v)?;
14465 }
14466 object::ObjectInfo::Secret(v) => {
14467 struct_ser.serialize_field("secret", v)?;
14468 }
14469 }
14470 }
14471 struct_ser.end()
14472 }
14473}
14474impl<'de> serde::Deserialize<'de> for Object {
14475 #[allow(deprecated)]
14476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14477 where
14478 D: serde::Deserializer<'de>,
14479 {
14480 const FIELDS: &[&str] = &[
14481 "database",
14482 "schema",
14483 "table",
14484 "index",
14485 "source",
14486 "sink",
14487 "view",
14488 "function",
14489 "connection",
14490 "subscription",
14491 "secret",
14492 ];
14493
14494 #[allow(clippy::enum_variant_names)]
14495 enum GeneratedField {
14496 Database,
14497 Schema,
14498 Table,
14499 Index,
14500 Source,
14501 Sink,
14502 View,
14503 Function,
14504 Connection,
14505 Subscription,
14506 Secret,
14507 }
14508 impl<'de> serde::Deserialize<'de> for GeneratedField {
14509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14510 where
14511 D: serde::Deserializer<'de>,
14512 {
14513 struct GeneratedVisitor;
14514
14515 impl serde::de::Visitor<'_> for GeneratedVisitor {
14516 type Value = GeneratedField;
14517
14518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14519 write!(formatter, "expected one of: {:?}", &FIELDS)
14520 }
14521
14522 #[allow(unused_variables)]
14523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14524 where
14525 E: serde::de::Error,
14526 {
14527 match value {
14528 "database" => Ok(GeneratedField::Database),
14529 "schema" => Ok(GeneratedField::Schema),
14530 "table" => Ok(GeneratedField::Table),
14531 "index" => Ok(GeneratedField::Index),
14532 "source" => Ok(GeneratedField::Source),
14533 "sink" => Ok(GeneratedField::Sink),
14534 "view" => Ok(GeneratedField::View),
14535 "function" => Ok(GeneratedField::Function),
14536 "connection" => Ok(GeneratedField::Connection),
14537 "subscription" => Ok(GeneratedField::Subscription),
14538 "secret" => Ok(GeneratedField::Secret),
14539 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14540 }
14541 }
14542 }
14543 deserializer.deserialize_identifier(GeneratedVisitor)
14544 }
14545 }
14546 struct GeneratedVisitor;
14547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14548 type Value = Object;
14549
14550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14551 formatter.write_str("struct meta.Object")
14552 }
14553
14554 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
14555 where
14556 V: serde::de::MapAccess<'de>,
14557 {
14558 let mut object_info__ = None;
14559 while let Some(k) = map_.next_key()? {
14560 match k {
14561 GeneratedField::Database => {
14562 if object_info__.is_some() {
14563 return Err(serde::de::Error::duplicate_field("database"));
14564 }
14565 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
14566;
14567 }
14568 GeneratedField::Schema => {
14569 if object_info__.is_some() {
14570 return Err(serde::de::Error::duplicate_field("schema"));
14571 }
14572 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
14573;
14574 }
14575 GeneratedField::Table => {
14576 if object_info__.is_some() {
14577 return Err(serde::de::Error::duplicate_field("table"));
14578 }
14579 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
14580;
14581 }
14582 GeneratedField::Index => {
14583 if object_info__.is_some() {
14584 return Err(serde::de::Error::duplicate_field("index"));
14585 }
14586 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
14587;
14588 }
14589 GeneratedField::Source => {
14590 if object_info__.is_some() {
14591 return Err(serde::de::Error::duplicate_field("source"));
14592 }
14593 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
14594;
14595 }
14596 GeneratedField::Sink => {
14597 if object_info__.is_some() {
14598 return Err(serde::de::Error::duplicate_field("sink"));
14599 }
14600 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
14601;
14602 }
14603 GeneratedField::View => {
14604 if object_info__.is_some() {
14605 return Err(serde::de::Error::duplicate_field("view"));
14606 }
14607 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
14608;
14609 }
14610 GeneratedField::Function => {
14611 if object_info__.is_some() {
14612 return Err(serde::de::Error::duplicate_field("function"));
14613 }
14614 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
14615;
14616 }
14617 GeneratedField::Connection => {
14618 if object_info__.is_some() {
14619 return Err(serde::de::Error::duplicate_field("connection"));
14620 }
14621 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
14622;
14623 }
14624 GeneratedField::Subscription => {
14625 if object_info__.is_some() {
14626 return Err(serde::de::Error::duplicate_field("subscription"));
14627 }
14628 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
14629;
14630 }
14631 GeneratedField::Secret => {
14632 if object_info__.is_some() {
14633 return Err(serde::de::Error::duplicate_field("secret"));
14634 }
14635 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
14636;
14637 }
14638 }
14639 }
14640 Ok(Object {
14641 object_info: object_info__,
14642 })
14643 }
14644 }
14645 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
14646 }
14647}
14648impl serde::Serialize for ObjectDependency {
14649 #[allow(deprecated)]
14650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14651 where
14652 S: serde::Serializer,
14653 {
14654 use serde::ser::SerializeStruct;
14655 let mut len = 0;
14656 if self.object_id != 0 {
14657 len += 1;
14658 }
14659 if self.referenced_object_id != 0 {
14660 len += 1;
14661 }
14662 if self.referenced_object_type != 0 {
14663 len += 1;
14664 }
14665 let mut struct_ser = serializer.serialize_struct("meta.ObjectDependency", len)?;
14666 if self.object_id != 0 {
14667 struct_ser.serialize_field("objectId", &self.object_id)?;
14668 }
14669 if self.referenced_object_id != 0 {
14670 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
14671 }
14672 if self.referenced_object_type != 0 {
14673 let v = super::common::ObjectType::try_from(self.referenced_object_type)
14674 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.referenced_object_type)))?;
14675 struct_ser.serialize_field("referencedObjectType", &v)?;
14676 }
14677 struct_ser.end()
14678 }
14679}
14680impl<'de> serde::Deserialize<'de> for ObjectDependency {
14681 #[allow(deprecated)]
14682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14683 where
14684 D: serde::Deserializer<'de>,
14685 {
14686 const FIELDS: &[&str] = &[
14687 "object_id",
14688 "objectId",
14689 "referenced_object_id",
14690 "referencedObjectId",
14691 "referenced_object_type",
14692 "referencedObjectType",
14693 ];
14694
14695 #[allow(clippy::enum_variant_names)]
14696 enum GeneratedField {
14697 ObjectId,
14698 ReferencedObjectId,
14699 ReferencedObjectType,
14700 }
14701 impl<'de> serde::Deserialize<'de> for GeneratedField {
14702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14703 where
14704 D: serde::Deserializer<'de>,
14705 {
14706 struct GeneratedVisitor;
14707
14708 impl serde::de::Visitor<'_> for GeneratedVisitor {
14709 type Value = GeneratedField;
14710
14711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14712 write!(formatter, "expected one of: {:?}", &FIELDS)
14713 }
14714
14715 #[allow(unused_variables)]
14716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14717 where
14718 E: serde::de::Error,
14719 {
14720 match value {
14721 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14722 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
14723 "referencedObjectType" | "referenced_object_type" => Ok(GeneratedField::ReferencedObjectType),
14724 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14725 }
14726 }
14727 }
14728 deserializer.deserialize_identifier(GeneratedVisitor)
14729 }
14730 }
14731 struct GeneratedVisitor;
14732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14733 type Value = ObjectDependency;
14734
14735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14736 formatter.write_str("struct meta.ObjectDependency")
14737 }
14738
14739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectDependency, V::Error>
14740 where
14741 V: serde::de::MapAccess<'de>,
14742 {
14743 let mut object_id__ = None;
14744 let mut referenced_object_id__ = None;
14745 let mut referenced_object_type__ = None;
14746 while let Some(k) = map_.next_key()? {
14747 match k {
14748 GeneratedField::ObjectId => {
14749 if object_id__.is_some() {
14750 return Err(serde::de::Error::duplicate_field("objectId"));
14751 }
14752 object_id__ =
14753 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14754 ;
14755 }
14756 GeneratedField::ReferencedObjectId => {
14757 if referenced_object_id__.is_some() {
14758 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
14759 }
14760 referenced_object_id__ =
14761 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14762 ;
14763 }
14764 GeneratedField::ReferencedObjectType => {
14765 if referenced_object_type__.is_some() {
14766 return Err(serde::de::Error::duplicate_field("referencedObjectType"));
14767 }
14768 referenced_object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
14769 }
14770 }
14771 }
14772 Ok(ObjectDependency {
14773 object_id: object_id__.unwrap_or_default(),
14774 referenced_object_id: referenced_object_id__.unwrap_or_default(),
14775 referenced_object_type: referenced_object_type__.unwrap_or_default(),
14776 })
14777 }
14778 }
14779 deserializer.deserialize_struct("meta.ObjectDependency", FIELDS, GeneratedVisitor)
14780 }
14781}
14782impl serde::Serialize for ObjectGroup {
14783 #[allow(deprecated)]
14784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14785 where
14786 S: serde::Serializer,
14787 {
14788 use serde::ser::SerializeStruct;
14789 let mut len = 0;
14790 if !self.objects.is_empty() {
14791 len += 1;
14792 }
14793 if !self.dependencies.is_empty() {
14794 len += 1;
14795 }
14796 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
14797 if !self.objects.is_empty() {
14798 struct_ser.serialize_field("objects", &self.objects)?;
14799 }
14800 if !self.dependencies.is_empty() {
14801 struct_ser.serialize_field("dependencies", &self.dependencies)?;
14802 }
14803 struct_ser.end()
14804 }
14805}
14806impl<'de> serde::Deserialize<'de> for ObjectGroup {
14807 #[allow(deprecated)]
14808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14809 where
14810 D: serde::Deserializer<'de>,
14811 {
14812 const FIELDS: &[&str] = &[
14813 "objects",
14814 "dependencies",
14815 ];
14816
14817 #[allow(clippy::enum_variant_names)]
14818 enum GeneratedField {
14819 Objects,
14820 Dependencies,
14821 }
14822 impl<'de> serde::Deserialize<'de> for GeneratedField {
14823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14824 where
14825 D: serde::Deserializer<'de>,
14826 {
14827 struct GeneratedVisitor;
14828
14829 impl serde::de::Visitor<'_> for GeneratedVisitor {
14830 type Value = GeneratedField;
14831
14832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14833 write!(formatter, "expected one of: {:?}", &FIELDS)
14834 }
14835
14836 #[allow(unused_variables)]
14837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14838 where
14839 E: serde::de::Error,
14840 {
14841 match value {
14842 "objects" => Ok(GeneratedField::Objects),
14843 "dependencies" => Ok(GeneratedField::Dependencies),
14844 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14845 }
14846 }
14847 }
14848 deserializer.deserialize_identifier(GeneratedVisitor)
14849 }
14850 }
14851 struct GeneratedVisitor;
14852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14853 type Value = ObjectGroup;
14854
14855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14856 formatter.write_str("struct meta.ObjectGroup")
14857 }
14858
14859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
14860 where
14861 V: serde::de::MapAccess<'de>,
14862 {
14863 let mut objects__ = None;
14864 let mut dependencies__ = None;
14865 while let Some(k) = map_.next_key()? {
14866 match k {
14867 GeneratedField::Objects => {
14868 if objects__.is_some() {
14869 return Err(serde::de::Error::duplicate_field("objects"));
14870 }
14871 objects__ = Some(map_.next_value()?);
14872 }
14873 GeneratedField::Dependencies => {
14874 if dependencies__.is_some() {
14875 return Err(serde::de::Error::duplicate_field("dependencies"));
14876 }
14877 dependencies__ = Some(map_.next_value()?);
14878 }
14879 }
14880 }
14881 Ok(ObjectGroup {
14882 objects: objects__.unwrap_or_default(),
14883 dependencies: dependencies__.unwrap_or_default(),
14884 })
14885 }
14886 }
14887 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
14888 }
14889}
14890impl serde::Serialize for PauseRequest {
14891 #[allow(deprecated)]
14892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14893 where
14894 S: serde::Serializer,
14895 {
14896 use serde::ser::SerializeStruct;
14897 let len = 0;
14898 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
14899 struct_ser.end()
14900 }
14901}
14902impl<'de> serde::Deserialize<'de> for PauseRequest {
14903 #[allow(deprecated)]
14904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14905 where
14906 D: serde::Deserializer<'de>,
14907 {
14908 const FIELDS: &[&str] = &[
14909 ];
14910
14911 #[allow(clippy::enum_variant_names)]
14912 enum GeneratedField {
14913 }
14914 impl<'de> serde::Deserialize<'de> for GeneratedField {
14915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14916 where
14917 D: serde::Deserializer<'de>,
14918 {
14919 struct GeneratedVisitor;
14920
14921 impl serde::de::Visitor<'_> for GeneratedVisitor {
14922 type Value = GeneratedField;
14923
14924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14925 write!(formatter, "expected one of: {:?}", &FIELDS)
14926 }
14927
14928 #[allow(unused_variables)]
14929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14930 where
14931 E: serde::de::Error,
14932 {
14933 Err(serde::de::Error::unknown_field(value, FIELDS))
14934 }
14935 }
14936 deserializer.deserialize_identifier(GeneratedVisitor)
14937 }
14938 }
14939 struct GeneratedVisitor;
14940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14941 type Value = PauseRequest;
14942
14943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14944 formatter.write_str("struct meta.PauseRequest")
14945 }
14946
14947 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
14948 where
14949 V: serde::de::MapAccess<'de>,
14950 {
14951 while map_.next_key::<GeneratedField>()?.is_some() {
14952 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14953 }
14954 Ok(PauseRequest {
14955 })
14956 }
14957 }
14958 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
14959 }
14960}
14961impl serde::Serialize for PauseResponse {
14962 #[allow(deprecated)]
14963 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14964 where
14965 S: serde::Serializer,
14966 {
14967 use serde::ser::SerializeStruct;
14968 let len = 0;
14969 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
14970 struct_ser.end()
14971 }
14972}
14973impl<'de> serde::Deserialize<'de> for PauseResponse {
14974 #[allow(deprecated)]
14975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14976 where
14977 D: serde::Deserializer<'de>,
14978 {
14979 const FIELDS: &[&str] = &[
14980 ];
14981
14982 #[allow(clippy::enum_variant_names)]
14983 enum GeneratedField {
14984 }
14985 impl<'de> serde::Deserialize<'de> for GeneratedField {
14986 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14987 where
14988 D: serde::Deserializer<'de>,
14989 {
14990 struct GeneratedVisitor;
14991
14992 impl serde::de::Visitor<'_> for GeneratedVisitor {
14993 type Value = GeneratedField;
14994
14995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14996 write!(formatter, "expected one of: {:?}", &FIELDS)
14997 }
14998
14999 #[allow(unused_variables)]
15000 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15001 where
15002 E: serde::de::Error,
15003 {
15004 Err(serde::de::Error::unknown_field(value, FIELDS))
15005 }
15006 }
15007 deserializer.deserialize_identifier(GeneratedVisitor)
15008 }
15009 }
15010 struct GeneratedVisitor;
15011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15012 type Value = PauseResponse;
15013
15014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15015 formatter.write_str("struct meta.PauseResponse")
15016 }
15017
15018 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
15019 where
15020 V: serde::de::MapAccess<'de>,
15021 {
15022 while map_.next_key::<GeneratedField>()?.is_some() {
15023 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15024 }
15025 Ok(PauseResponse {
15026 })
15027 }
15028 }
15029 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
15030 }
15031}
15032impl serde::Serialize for PropertyUpdateOptions {
15033 #[allow(deprecated)]
15034 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15035 where
15036 S: serde::Serializer,
15037 {
15038 use serde::ser::SerializeStruct;
15039 let mut len = 0;
15040 if self.reset_splits {
15041 len += 1;
15042 }
15043 let mut struct_ser = serializer.serialize_struct("meta.PropertyUpdateOptions", len)?;
15044 if self.reset_splits {
15045 struct_ser.serialize_field("resetSplits", &self.reset_splits)?;
15046 }
15047 struct_ser.end()
15048 }
15049}
15050impl<'de> serde::Deserialize<'de> for PropertyUpdateOptions {
15051 #[allow(deprecated)]
15052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15053 where
15054 D: serde::Deserializer<'de>,
15055 {
15056 const FIELDS: &[&str] = &[
15057 "reset_splits",
15058 "resetSplits",
15059 ];
15060
15061 #[allow(clippy::enum_variant_names)]
15062 enum GeneratedField {
15063 ResetSplits,
15064 }
15065 impl<'de> serde::Deserialize<'de> for GeneratedField {
15066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15067 where
15068 D: serde::Deserializer<'de>,
15069 {
15070 struct GeneratedVisitor;
15071
15072 impl serde::de::Visitor<'_> for GeneratedVisitor {
15073 type Value = GeneratedField;
15074
15075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15076 write!(formatter, "expected one of: {:?}", &FIELDS)
15077 }
15078
15079 #[allow(unused_variables)]
15080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15081 where
15082 E: serde::de::Error,
15083 {
15084 match value {
15085 "resetSplits" | "reset_splits" => Ok(GeneratedField::ResetSplits),
15086 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15087 }
15088 }
15089 }
15090 deserializer.deserialize_identifier(GeneratedVisitor)
15091 }
15092 }
15093 struct GeneratedVisitor;
15094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15095 type Value = PropertyUpdateOptions;
15096
15097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15098 formatter.write_str("struct meta.PropertyUpdateOptions")
15099 }
15100
15101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PropertyUpdateOptions, V::Error>
15102 where
15103 V: serde::de::MapAccess<'de>,
15104 {
15105 let mut reset_splits__ = None;
15106 while let Some(k) = map_.next_key()? {
15107 match k {
15108 GeneratedField::ResetSplits => {
15109 if reset_splits__.is_some() {
15110 return Err(serde::de::Error::duplicate_field("resetSplits"));
15111 }
15112 reset_splits__ = Some(map_.next_value()?);
15113 }
15114 }
15115 }
15116 Ok(PropertyUpdateOptions {
15117 reset_splits: reset_splits__.unwrap_or_default(),
15118 })
15119 }
15120 }
15121 deserializer.deserialize_struct("meta.PropertyUpdateOptions", FIELDS, GeneratedVisitor)
15122 }
15123}
15124impl serde::Serialize for RecoverRequest {
15125 #[allow(deprecated)]
15126 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15127 where
15128 S: serde::Serializer,
15129 {
15130 use serde::ser::SerializeStruct;
15131 let len = 0;
15132 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
15133 struct_ser.end()
15134 }
15135}
15136impl<'de> serde::Deserialize<'de> for RecoverRequest {
15137 #[allow(deprecated)]
15138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15139 where
15140 D: serde::Deserializer<'de>,
15141 {
15142 const FIELDS: &[&str] = &[
15143 ];
15144
15145 #[allow(clippy::enum_variant_names)]
15146 enum GeneratedField {
15147 }
15148 impl<'de> serde::Deserialize<'de> for GeneratedField {
15149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15150 where
15151 D: serde::Deserializer<'de>,
15152 {
15153 struct GeneratedVisitor;
15154
15155 impl serde::de::Visitor<'_> for GeneratedVisitor {
15156 type Value = GeneratedField;
15157
15158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15159 write!(formatter, "expected one of: {:?}", &FIELDS)
15160 }
15161
15162 #[allow(unused_variables)]
15163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15164 where
15165 E: serde::de::Error,
15166 {
15167 Err(serde::de::Error::unknown_field(value, FIELDS))
15168 }
15169 }
15170 deserializer.deserialize_identifier(GeneratedVisitor)
15171 }
15172 }
15173 struct GeneratedVisitor;
15174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15175 type Value = RecoverRequest;
15176
15177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15178 formatter.write_str("struct meta.RecoverRequest")
15179 }
15180
15181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
15182 where
15183 V: serde::de::MapAccess<'de>,
15184 {
15185 while map_.next_key::<GeneratedField>()?.is_some() {
15186 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15187 }
15188 Ok(RecoverRequest {
15189 })
15190 }
15191 }
15192 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
15193 }
15194}
15195impl serde::Serialize for RecoverResponse {
15196 #[allow(deprecated)]
15197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15198 where
15199 S: serde::Serializer,
15200 {
15201 use serde::ser::SerializeStruct;
15202 let len = 0;
15203 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
15204 struct_ser.end()
15205 }
15206}
15207impl<'de> serde::Deserialize<'de> for RecoverResponse {
15208 #[allow(deprecated)]
15209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15210 where
15211 D: serde::Deserializer<'de>,
15212 {
15213 const FIELDS: &[&str] = &[
15214 ];
15215
15216 #[allow(clippy::enum_variant_names)]
15217 enum GeneratedField {
15218 }
15219 impl<'de> serde::Deserialize<'de> for GeneratedField {
15220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15221 where
15222 D: serde::Deserializer<'de>,
15223 {
15224 struct GeneratedVisitor;
15225
15226 impl serde::de::Visitor<'_> for GeneratedVisitor {
15227 type Value = GeneratedField;
15228
15229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15230 write!(formatter, "expected one of: {:?}", &FIELDS)
15231 }
15232
15233 #[allow(unused_variables)]
15234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15235 where
15236 E: serde::de::Error,
15237 {
15238 Err(serde::de::Error::unknown_field(value, FIELDS))
15239 }
15240 }
15241 deserializer.deserialize_identifier(GeneratedVisitor)
15242 }
15243 }
15244 struct GeneratedVisitor;
15245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15246 type Value = RecoverResponse;
15247
15248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15249 formatter.write_str("struct meta.RecoverResponse")
15250 }
15251
15252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
15253 where
15254 V: serde::de::MapAccess<'de>,
15255 {
15256 while map_.next_key::<GeneratedField>()?.is_some() {
15257 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15258 }
15259 Ok(RecoverResponse {
15260 })
15261 }
15262 }
15263 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
15264 }
15265}
15266impl serde::Serialize for Recovery {
15267 #[allow(deprecated)]
15268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15269 where
15270 S: serde::Serializer,
15271 {
15272 use serde::ser::SerializeStruct;
15273 let len = 0;
15274 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
15275 struct_ser.end()
15276 }
15277}
15278impl<'de> serde::Deserialize<'de> for Recovery {
15279 #[allow(deprecated)]
15280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15281 where
15282 D: serde::Deserializer<'de>,
15283 {
15284 const FIELDS: &[&str] = &[
15285 ];
15286
15287 #[allow(clippy::enum_variant_names)]
15288 enum GeneratedField {
15289 }
15290 impl<'de> serde::Deserialize<'de> for GeneratedField {
15291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15292 where
15293 D: serde::Deserializer<'de>,
15294 {
15295 struct GeneratedVisitor;
15296
15297 impl serde::de::Visitor<'_> for GeneratedVisitor {
15298 type Value = GeneratedField;
15299
15300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15301 write!(formatter, "expected one of: {:?}", &FIELDS)
15302 }
15303
15304 #[allow(unused_variables)]
15305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15306 where
15307 E: serde::de::Error,
15308 {
15309 Err(serde::de::Error::unknown_field(value, FIELDS))
15310 }
15311 }
15312 deserializer.deserialize_identifier(GeneratedVisitor)
15313 }
15314 }
15315 struct GeneratedVisitor;
15316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15317 type Value = Recovery;
15318
15319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15320 formatter.write_str("struct meta.Recovery")
15321 }
15322
15323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
15324 where
15325 V: serde::de::MapAccess<'de>,
15326 {
15327 while map_.next_key::<GeneratedField>()?.is_some() {
15328 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15329 }
15330 Ok(Recovery {
15331 })
15332 }
15333 }
15334 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
15335 }
15336}
15337impl serde::Serialize for RecoveryStatus {
15338 #[allow(deprecated)]
15339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15340 where
15341 S: serde::Serializer,
15342 {
15343 let variant = match self {
15344 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
15345 Self::StatusStarting => "STATUS_STARTING",
15346 Self::StatusRecovering => "STATUS_RECOVERING",
15347 Self::StatusRunning => "STATUS_RUNNING",
15348 };
15349 serializer.serialize_str(variant)
15350 }
15351}
15352impl<'de> serde::Deserialize<'de> for RecoveryStatus {
15353 #[allow(deprecated)]
15354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15355 where
15356 D: serde::Deserializer<'de>,
15357 {
15358 const FIELDS: &[&str] = &[
15359 "STATUS_UNSPECIFIED",
15360 "STATUS_STARTING",
15361 "STATUS_RECOVERING",
15362 "STATUS_RUNNING",
15363 ];
15364
15365 struct GeneratedVisitor;
15366
15367 impl serde::de::Visitor<'_> for GeneratedVisitor {
15368 type Value = RecoveryStatus;
15369
15370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15371 write!(formatter, "expected one of: {:?}", &FIELDS)
15372 }
15373
15374 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15375 where
15376 E: serde::de::Error,
15377 {
15378 i32::try_from(v)
15379 .ok()
15380 .and_then(|x| x.try_into().ok())
15381 .ok_or_else(|| {
15382 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15383 })
15384 }
15385
15386 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15387 where
15388 E: serde::de::Error,
15389 {
15390 i32::try_from(v)
15391 .ok()
15392 .and_then(|x| x.try_into().ok())
15393 .ok_or_else(|| {
15394 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15395 })
15396 }
15397
15398 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15399 where
15400 E: serde::de::Error,
15401 {
15402 match value {
15403 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
15404 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
15405 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
15406 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
15407 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15408 }
15409 }
15410 }
15411 deserializer.deserialize_any(GeneratedVisitor)
15412 }
15413}
15414impl serde::Serialize for RefreshRequest {
15415 #[allow(deprecated)]
15416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15417 where
15418 S: serde::Serializer,
15419 {
15420 use serde::ser::SerializeStruct;
15421 let mut len = 0;
15422 if self.table_id != 0 {
15423 len += 1;
15424 }
15425 if self.associated_source_id != 0 {
15426 len += 1;
15427 }
15428 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
15429 if self.table_id != 0 {
15430 struct_ser.serialize_field("tableId", &self.table_id)?;
15431 }
15432 if self.associated_source_id != 0 {
15433 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
15434 }
15435 struct_ser.end()
15436 }
15437}
15438impl<'de> serde::Deserialize<'de> for RefreshRequest {
15439 #[allow(deprecated)]
15440 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15441 where
15442 D: serde::Deserializer<'de>,
15443 {
15444 const FIELDS: &[&str] = &[
15445 "table_id",
15446 "tableId",
15447 "associated_source_id",
15448 "associatedSourceId",
15449 ];
15450
15451 #[allow(clippy::enum_variant_names)]
15452 enum GeneratedField {
15453 TableId,
15454 AssociatedSourceId,
15455 }
15456 impl<'de> serde::Deserialize<'de> for GeneratedField {
15457 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15458 where
15459 D: serde::Deserializer<'de>,
15460 {
15461 struct GeneratedVisitor;
15462
15463 impl serde::de::Visitor<'_> for GeneratedVisitor {
15464 type Value = GeneratedField;
15465
15466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15467 write!(formatter, "expected one of: {:?}", &FIELDS)
15468 }
15469
15470 #[allow(unused_variables)]
15471 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15472 where
15473 E: serde::de::Error,
15474 {
15475 match value {
15476 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15477 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
15478 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15479 }
15480 }
15481 }
15482 deserializer.deserialize_identifier(GeneratedVisitor)
15483 }
15484 }
15485 struct GeneratedVisitor;
15486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15487 type Value = RefreshRequest;
15488
15489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15490 formatter.write_str("struct meta.RefreshRequest")
15491 }
15492
15493 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
15494 where
15495 V: serde::de::MapAccess<'de>,
15496 {
15497 let mut table_id__ = None;
15498 let mut associated_source_id__ = None;
15499 while let Some(k) = map_.next_key()? {
15500 match k {
15501 GeneratedField::TableId => {
15502 if table_id__.is_some() {
15503 return Err(serde::de::Error::duplicate_field("tableId"));
15504 }
15505 table_id__ =
15506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15507 ;
15508 }
15509 GeneratedField::AssociatedSourceId => {
15510 if associated_source_id__.is_some() {
15511 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
15512 }
15513 associated_source_id__ =
15514 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15515 ;
15516 }
15517 }
15518 }
15519 Ok(RefreshRequest {
15520 table_id: table_id__.unwrap_or_default(),
15521 associated_source_id: associated_source_id__.unwrap_or_default(),
15522 })
15523 }
15524 }
15525 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
15526 }
15527}
15528impl serde::Serialize for RefreshResponse {
15529 #[allow(deprecated)]
15530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15531 where
15532 S: serde::Serializer,
15533 {
15534 use serde::ser::SerializeStruct;
15535 let mut len = 0;
15536 if self.status.is_some() {
15537 len += 1;
15538 }
15539 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
15540 if let Some(v) = self.status.as_ref() {
15541 struct_ser.serialize_field("status", v)?;
15542 }
15543 struct_ser.end()
15544 }
15545}
15546impl<'de> serde::Deserialize<'de> for RefreshResponse {
15547 #[allow(deprecated)]
15548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15549 where
15550 D: serde::Deserializer<'de>,
15551 {
15552 const FIELDS: &[&str] = &[
15553 "status",
15554 ];
15555
15556 #[allow(clippy::enum_variant_names)]
15557 enum GeneratedField {
15558 Status,
15559 }
15560 impl<'de> serde::Deserialize<'de> for GeneratedField {
15561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15562 where
15563 D: serde::Deserializer<'de>,
15564 {
15565 struct GeneratedVisitor;
15566
15567 impl serde::de::Visitor<'_> for GeneratedVisitor {
15568 type Value = GeneratedField;
15569
15570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15571 write!(formatter, "expected one of: {:?}", &FIELDS)
15572 }
15573
15574 #[allow(unused_variables)]
15575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15576 where
15577 E: serde::de::Error,
15578 {
15579 match value {
15580 "status" => Ok(GeneratedField::Status),
15581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15582 }
15583 }
15584 }
15585 deserializer.deserialize_identifier(GeneratedVisitor)
15586 }
15587 }
15588 struct GeneratedVisitor;
15589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15590 type Value = RefreshResponse;
15591
15592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15593 formatter.write_str("struct meta.RefreshResponse")
15594 }
15595
15596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
15597 where
15598 V: serde::de::MapAccess<'de>,
15599 {
15600 let mut status__ = None;
15601 while let Some(k) = map_.next_key()? {
15602 match k {
15603 GeneratedField::Status => {
15604 if status__.is_some() {
15605 return Err(serde::de::Error::duplicate_field("status"));
15606 }
15607 status__ = map_.next_value()?;
15608 }
15609 }
15610 }
15611 Ok(RefreshResponse {
15612 status: status__,
15613 })
15614 }
15615 }
15616 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
15617 }
15618}
15619impl serde::Serialize for RelationIdInfos {
15620 #[allow(deprecated)]
15621 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15622 where
15623 S: serde::Serializer,
15624 {
15625 use serde::ser::SerializeStruct;
15626 let mut len = 0;
15627 if !self.map.is_empty() {
15628 len += 1;
15629 }
15630 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
15631 if !self.map.is_empty() {
15632 struct_ser.serialize_field("map", &self.map)?;
15633 }
15634 struct_ser.end()
15635 }
15636}
15637impl<'de> serde::Deserialize<'de> for RelationIdInfos {
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 "map",
15645 ];
15646
15647 #[allow(clippy::enum_variant_names)]
15648 enum GeneratedField {
15649 Map,
15650 }
15651 impl<'de> serde::Deserialize<'de> for GeneratedField {
15652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15653 where
15654 D: serde::Deserializer<'de>,
15655 {
15656 struct GeneratedVisitor;
15657
15658 impl serde::de::Visitor<'_> for GeneratedVisitor {
15659 type Value = GeneratedField;
15660
15661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15662 write!(formatter, "expected one of: {:?}", &FIELDS)
15663 }
15664
15665 #[allow(unused_variables)]
15666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15667 where
15668 E: serde::de::Error,
15669 {
15670 match value {
15671 "map" => Ok(GeneratedField::Map),
15672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15673 }
15674 }
15675 }
15676 deserializer.deserialize_identifier(GeneratedVisitor)
15677 }
15678 }
15679 struct GeneratedVisitor;
15680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15681 type Value = RelationIdInfos;
15682
15683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15684 formatter.write_str("struct meta.RelationIdInfos")
15685 }
15686
15687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
15688 where
15689 V: serde::de::MapAccess<'de>,
15690 {
15691 let mut map__ = None;
15692 while let Some(k) = map_.next_key()? {
15693 match k {
15694 GeneratedField::Map => {
15695 if map__.is_some() {
15696 return Err(serde::de::Error::duplicate_field("map"));
15697 }
15698 map__ = Some(
15699 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15700 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15701 );
15702 }
15703 }
15704 }
15705 Ok(RelationIdInfos {
15706 map: map__.unwrap_or_default(),
15707 })
15708 }
15709 }
15710 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
15711 }
15712}
15713impl serde::Serialize for RescheduleRequest {
15714 #[allow(deprecated)]
15715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15716 where
15717 S: serde::Serializer,
15718 {
15719 use serde::ser::SerializeStruct;
15720 let mut len = 0;
15721 if self.revision != 0 {
15722 len += 1;
15723 }
15724 if self.resolve_no_shuffle_upstream {
15725 len += 1;
15726 }
15727 if !self.worker_reschedules.is_empty() {
15728 len += 1;
15729 }
15730 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
15731 if self.revision != 0 {
15732 #[allow(clippy::needless_borrow)]
15733 #[allow(clippy::needless_borrows_for_generic_args)]
15734 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15735 }
15736 if self.resolve_no_shuffle_upstream {
15737 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
15738 }
15739 if !self.worker_reschedules.is_empty() {
15740 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
15741 }
15742 struct_ser.end()
15743 }
15744}
15745impl<'de> serde::Deserialize<'de> for RescheduleRequest {
15746 #[allow(deprecated)]
15747 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15748 where
15749 D: serde::Deserializer<'de>,
15750 {
15751 const FIELDS: &[&str] = &[
15752 "revision",
15753 "resolve_no_shuffle_upstream",
15754 "resolveNoShuffleUpstream",
15755 "worker_reschedules",
15756 "workerReschedules",
15757 ];
15758
15759 #[allow(clippy::enum_variant_names)]
15760 enum GeneratedField {
15761 Revision,
15762 ResolveNoShuffleUpstream,
15763 WorkerReschedules,
15764 }
15765 impl<'de> serde::Deserialize<'de> for GeneratedField {
15766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15767 where
15768 D: serde::Deserializer<'de>,
15769 {
15770 struct GeneratedVisitor;
15771
15772 impl serde::de::Visitor<'_> for GeneratedVisitor {
15773 type Value = GeneratedField;
15774
15775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15776 write!(formatter, "expected one of: {:?}", &FIELDS)
15777 }
15778
15779 #[allow(unused_variables)]
15780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15781 where
15782 E: serde::de::Error,
15783 {
15784 match value {
15785 "revision" => Ok(GeneratedField::Revision),
15786 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
15787 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
15788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15789 }
15790 }
15791 }
15792 deserializer.deserialize_identifier(GeneratedVisitor)
15793 }
15794 }
15795 struct GeneratedVisitor;
15796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15797 type Value = RescheduleRequest;
15798
15799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15800 formatter.write_str("struct meta.RescheduleRequest")
15801 }
15802
15803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
15804 where
15805 V: serde::de::MapAccess<'de>,
15806 {
15807 let mut revision__ = None;
15808 let mut resolve_no_shuffle_upstream__ = None;
15809 let mut worker_reschedules__ = None;
15810 while let Some(k) = map_.next_key()? {
15811 match k {
15812 GeneratedField::Revision => {
15813 if revision__.is_some() {
15814 return Err(serde::de::Error::duplicate_field("revision"));
15815 }
15816 revision__ =
15817 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15818 ;
15819 }
15820 GeneratedField::ResolveNoShuffleUpstream => {
15821 if resolve_no_shuffle_upstream__.is_some() {
15822 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
15823 }
15824 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
15825 }
15826 GeneratedField::WorkerReschedules => {
15827 if worker_reschedules__.is_some() {
15828 return Err(serde::de::Error::duplicate_field("workerReschedules"));
15829 }
15830 worker_reschedules__ = Some(
15831 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15832 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15833 );
15834 }
15835 }
15836 }
15837 Ok(RescheduleRequest {
15838 revision: revision__.unwrap_or_default(),
15839 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
15840 worker_reschedules: worker_reschedules__.unwrap_or_default(),
15841 })
15842 }
15843 }
15844 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
15845 }
15846}
15847impl serde::Serialize for RescheduleResponse {
15848 #[allow(deprecated)]
15849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15850 where
15851 S: serde::Serializer,
15852 {
15853 use serde::ser::SerializeStruct;
15854 let mut len = 0;
15855 if self.success {
15856 len += 1;
15857 }
15858 if self.revision != 0 {
15859 len += 1;
15860 }
15861 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
15862 if self.success {
15863 struct_ser.serialize_field("success", &self.success)?;
15864 }
15865 if self.revision != 0 {
15866 #[allow(clippy::needless_borrow)]
15867 #[allow(clippy::needless_borrows_for_generic_args)]
15868 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
15869 }
15870 struct_ser.end()
15871 }
15872}
15873impl<'de> serde::Deserialize<'de> for RescheduleResponse {
15874 #[allow(deprecated)]
15875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15876 where
15877 D: serde::Deserializer<'de>,
15878 {
15879 const FIELDS: &[&str] = &[
15880 "success",
15881 "revision",
15882 ];
15883
15884 #[allow(clippy::enum_variant_names)]
15885 enum GeneratedField {
15886 Success,
15887 Revision,
15888 }
15889 impl<'de> serde::Deserialize<'de> for GeneratedField {
15890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15891 where
15892 D: serde::Deserializer<'de>,
15893 {
15894 struct GeneratedVisitor;
15895
15896 impl serde::de::Visitor<'_> for GeneratedVisitor {
15897 type Value = GeneratedField;
15898
15899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15900 write!(formatter, "expected one of: {:?}", &FIELDS)
15901 }
15902
15903 #[allow(unused_variables)]
15904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15905 where
15906 E: serde::de::Error,
15907 {
15908 match value {
15909 "success" => Ok(GeneratedField::Success),
15910 "revision" => Ok(GeneratedField::Revision),
15911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15912 }
15913 }
15914 }
15915 deserializer.deserialize_identifier(GeneratedVisitor)
15916 }
15917 }
15918 struct GeneratedVisitor;
15919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15920 type Value = RescheduleResponse;
15921
15922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15923 formatter.write_str("struct meta.RescheduleResponse")
15924 }
15925
15926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
15927 where
15928 V: serde::de::MapAccess<'de>,
15929 {
15930 let mut success__ = None;
15931 let mut revision__ = None;
15932 while let Some(k) = map_.next_key()? {
15933 match k {
15934 GeneratedField::Success => {
15935 if success__.is_some() {
15936 return Err(serde::de::Error::duplicate_field("success"));
15937 }
15938 success__ = Some(map_.next_value()?);
15939 }
15940 GeneratedField::Revision => {
15941 if revision__.is_some() {
15942 return Err(serde::de::Error::duplicate_field("revision"));
15943 }
15944 revision__ =
15945 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15946 ;
15947 }
15948 }
15949 }
15950 Ok(RescheduleResponse {
15951 success: success__.unwrap_or_default(),
15952 revision: revision__.unwrap_or_default(),
15953 })
15954 }
15955 }
15956 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
15957 }
15958}
15959impl serde::Serialize for ResetSourceSplitsRequest {
15960 #[allow(deprecated)]
15961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15962 where
15963 S: serde::Serializer,
15964 {
15965 use serde::ser::SerializeStruct;
15966 let mut len = 0;
15967 if self.source_id != 0 {
15968 len += 1;
15969 }
15970 let mut struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsRequest", len)?;
15971 if self.source_id != 0 {
15972 struct_ser.serialize_field("sourceId", &self.source_id)?;
15973 }
15974 struct_ser.end()
15975 }
15976}
15977impl<'de> serde::Deserialize<'de> for ResetSourceSplitsRequest {
15978 #[allow(deprecated)]
15979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15980 where
15981 D: serde::Deserializer<'de>,
15982 {
15983 const FIELDS: &[&str] = &[
15984 "source_id",
15985 "sourceId",
15986 ];
15987
15988 #[allow(clippy::enum_variant_names)]
15989 enum GeneratedField {
15990 SourceId,
15991 }
15992 impl<'de> serde::Deserialize<'de> for GeneratedField {
15993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15994 where
15995 D: serde::Deserializer<'de>,
15996 {
15997 struct GeneratedVisitor;
15998
15999 impl serde::de::Visitor<'_> for GeneratedVisitor {
16000 type Value = GeneratedField;
16001
16002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16003 write!(formatter, "expected one of: {:?}", &FIELDS)
16004 }
16005
16006 #[allow(unused_variables)]
16007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16008 where
16009 E: serde::de::Error,
16010 {
16011 match value {
16012 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16013 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16014 }
16015 }
16016 }
16017 deserializer.deserialize_identifier(GeneratedVisitor)
16018 }
16019 }
16020 struct GeneratedVisitor;
16021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16022 type Value = ResetSourceSplitsRequest;
16023
16024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16025 formatter.write_str("struct meta.ResetSourceSplitsRequest")
16026 }
16027
16028 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsRequest, V::Error>
16029 where
16030 V: serde::de::MapAccess<'de>,
16031 {
16032 let mut source_id__ = None;
16033 while let Some(k) = map_.next_key()? {
16034 match k {
16035 GeneratedField::SourceId => {
16036 if source_id__.is_some() {
16037 return Err(serde::de::Error::duplicate_field("sourceId"));
16038 }
16039 source_id__ =
16040 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16041 ;
16042 }
16043 }
16044 }
16045 Ok(ResetSourceSplitsRequest {
16046 source_id: source_id__.unwrap_or_default(),
16047 })
16048 }
16049 }
16050 deserializer.deserialize_struct("meta.ResetSourceSplitsRequest", FIELDS, GeneratedVisitor)
16051 }
16052}
16053impl serde::Serialize for ResetSourceSplitsResponse {
16054 #[allow(deprecated)]
16055 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16056 where
16057 S: serde::Serializer,
16058 {
16059 use serde::ser::SerializeStruct;
16060 let len = 0;
16061 let struct_ser = serializer.serialize_struct("meta.ResetSourceSplitsResponse", len)?;
16062 struct_ser.end()
16063 }
16064}
16065impl<'de> serde::Deserialize<'de> for ResetSourceSplitsResponse {
16066 #[allow(deprecated)]
16067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16068 where
16069 D: serde::Deserializer<'de>,
16070 {
16071 const FIELDS: &[&str] = &[
16072 ];
16073
16074 #[allow(clippy::enum_variant_names)]
16075 enum GeneratedField {
16076 }
16077 impl<'de> serde::Deserialize<'de> for GeneratedField {
16078 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16079 where
16080 D: serde::Deserializer<'de>,
16081 {
16082 struct GeneratedVisitor;
16083
16084 impl serde::de::Visitor<'_> for GeneratedVisitor {
16085 type Value = GeneratedField;
16086
16087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16088 write!(formatter, "expected one of: {:?}", &FIELDS)
16089 }
16090
16091 #[allow(unused_variables)]
16092 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16093 where
16094 E: serde::de::Error,
16095 {
16096 Err(serde::de::Error::unknown_field(value, FIELDS))
16097 }
16098 }
16099 deserializer.deserialize_identifier(GeneratedVisitor)
16100 }
16101 }
16102 struct GeneratedVisitor;
16103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16104 type Value = ResetSourceSplitsResponse;
16105
16106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16107 formatter.write_str("struct meta.ResetSourceSplitsResponse")
16108 }
16109
16110 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceSplitsResponse, V::Error>
16111 where
16112 V: serde::de::MapAccess<'de>,
16113 {
16114 while map_.next_key::<GeneratedField>()?.is_some() {
16115 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16116 }
16117 Ok(ResetSourceSplitsResponse {
16118 })
16119 }
16120 }
16121 deserializer.deserialize_struct("meta.ResetSourceSplitsResponse", FIELDS, GeneratedVisitor)
16122 }
16123}
16124impl serde::Serialize for ResumeRequest {
16125 #[allow(deprecated)]
16126 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16127 where
16128 S: serde::Serializer,
16129 {
16130 use serde::ser::SerializeStruct;
16131 let len = 0;
16132 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
16133 struct_ser.end()
16134 }
16135}
16136impl<'de> serde::Deserialize<'de> for ResumeRequest {
16137 #[allow(deprecated)]
16138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16139 where
16140 D: serde::Deserializer<'de>,
16141 {
16142 const FIELDS: &[&str] = &[
16143 ];
16144
16145 #[allow(clippy::enum_variant_names)]
16146 enum GeneratedField {
16147 }
16148 impl<'de> serde::Deserialize<'de> for GeneratedField {
16149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16150 where
16151 D: serde::Deserializer<'de>,
16152 {
16153 struct GeneratedVisitor;
16154
16155 impl serde::de::Visitor<'_> for GeneratedVisitor {
16156 type Value = GeneratedField;
16157
16158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16159 write!(formatter, "expected one of: {:?}", &FIELDS)
16160 }
16161
16162 #[allow(unused_variables)]
16163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16164 where
16165 E: serde::de::Error,
16166 {
16167 Err(serde::de::Error::unknown_field(value, FIELDS))
16168 }
16169 }
16170 deserializer.deserialize_identifier(GeneratedVisitor)
16171 }
16172 }
16173 struct GeneratedVisitor;
16174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16175 type Value = ResumeRequest;
16176
16177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16178 formatter.write_str("struct meta.ResumeRequest")
16179 }
16180
16181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
16182 where
16183 V: serde::de::MapAccess<'de>,
16184 {
16185 while map_.next_key::<GeneratedField>()?.is_some() {
16186 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16187 }
16188 Ok(ResumeRequest {
16189 })
16190 }
16191 }
16192 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
16193 }
16194}
16195impl serde::Serialize for ResumeResponse {
16196 #[allow(deprecated)]
16197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16198 where
16199 S: serde::Serializer,
16200 {
16201 use serde::ser::SerializeStruct;
16202 let len = 0;
16203 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
16204 struct_ser.end()
16205 }
16206}
16207impl<'de> serde::Deserialize<'de> for ResumeResponse {
16208 #[allow(deprecated)]
16209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16210 where
16211 D: serde::Deserializer<'de>,
16212 {
16213 const FIELDS: &[&str] = &[
16214 ];
16215
16216 #[allow(clippy::enum_variant_names)]
16217 enum GeneratedField {
16218 }
16219 impl<'de> serde::Deserialize<'de> for GeneratedField {
16220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16221 where
16222 D: serde::Deserializer<'de>,
16223 {
16224 struct GeneratedVisitor;
16225
16226 impl serde::de::Visitor<'_> for GeneratedVisitor {
16227 type Value = GeneratedField;
16228
16229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16230 write!(formatter, "expected one of: {:?}", &FIELDS)
16231 }
16232
16233 #[allow(unused_variables)]
16234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16235 where
16236 E: serde::de::Error,
16237 {
16238 Err(serde::de::Error::unknown_field(value, FIELDS))
16239 }
16240 }
16241 deserializer.deserialize_identifier(GeneratedVisitor)
16242 }
16243 }
16244 struct GeneratedVisitor;
16245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16246 type Value = ResumeResponse;
16247
16248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16249 formatter.write_str("struct meta.ResumeResponse")
16250 }
16251
16252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
16253 where
16254 V: serde::de::MapAccess<'de>,
16255 {
16256 while map_.next_key::<GeneratedField>()?.is_some() {
16257 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16258 }
16259 Ok(ResumeResponse {
16260 })
16261 }
16262 }
16263 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
16264 }
16265}
16266impl serde::Serialize for ServingTableVnodeMappings {
16267 #[allow(deprecated)]
16268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16269 where
16270 S: serde::Serializer,
16271 {
16272 use serde::ser::SerializeStruct;
16273 let mut len = 0;
16274 if !self.mappings.is_empty() {
16275 len += 1;
16276 }
16277 let mut struct_ser = serializer.serialize_struct("meta.ServingTableVnodeMappings", len)?;
16278 if !self.mappings.is_empty() {
16279 struct_ser.serialize_field("mappings", &self.mappings)?;
16280 }
16281 struct_ser.end()
16282 }
16283}
16284impl<'de> serde::Deserialize<'de> for ServingTableVnodeMappings {
16285 #[allow(deprecated)]
16286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16287 where
16288 D: serde::Deserializer<'de>,
16289 {
16290 const FIELDS: &[&str] = &[
16291 "mappings",
16292 ];
16293
16294 #[allow(clippy::enum_variant_names)]
16295 enum GeneratedField {
16296 Mappings,
16297 }
16298 impl<'de> serde::Deserialize<'de> for GeneratedField {
16299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16300 where
16301 D: serde::Deserializer<'de>,
16302 {
16303 struct GeneratedVisitor;
16304
16305 impl serde::de::Visitor<'_> for GeneratedVisitor {
16306 type Value = GeneratedField;
16307
16308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16309 write!(formatter, "expected one of: {:?}", &FIELDS)
16310 }
16311
16312 #[allow(unused_variables)]
16313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16314 where
16315 E: serde::de::Error,
16316 {
16317 match value {
16318 "mappings" => Ok(GeneratedField::Mappings),
16319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16320 }
16321 }
16322 }
16323 deserializer.deserialize_identifier(GeneratedVisitor)
16324 }
16325 }
16326 struct GeneratedVisitor;
16327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16328 type Value = ServingTableVnodeMappings;
16329
16330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16331 formatter.write_str("struct meta.ServingTableVnodeMappings")
16332 }
16333
16334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ServingTableVnodeMappings, V::Error>
16335 where
16336 V: serde::de::MapAccess<'de>,
16337 {
16338 let mut mappings__ = None;
16339 while let Some(k) = map_.next_key()? {
16340 match k {
16341 GeneratedField::Mappings => {
16342 if mappings__.is_some() {
16343 return Err(serde::de::Error::duplicate_field("mappings"));
16344 }
16345 mappings__ = Some(map_.next_value()?);
16346 }
16347 }
16348 }
16349 Ok(ServingTableVnodeMappings {
16350 mappings: mappings__.unwrap_or_default(),
16351 })
16352 }
16353 }
16354 deserializer.deserialize_struct("meta.ServingTableVnodeMappings", FIELDS, GeneratedVisitor)
16355 }
16356}
16357impl serde::Serialize for serving_table_vnode_mappings::ServingTableVnodeMapping {
16358 #[allow(deprecated)]
16359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16360 where
16361 S: serde::Serializer,
16362 {
16363 use serde::ser::SerializeStruct;
16364 let mut len = 0;
16365 if self.table_id != 0 {
16366 len += 1;
16367 }
16368 if self.bitmap.is_some() {
16369 len += 1;
16370 }
16371 let mut struct_ser = serializer.serialize_struct("meta.ServingTableVnodeMappings.ServingTableVnodeMapping", len)?;
16372 if self.table_id != 0 {
16373 struct_ser.serialize_field("tableId", &self.table_id)?;
16374 }
16375 if let Some(v) = self.bitmap.as_ref() {
16376 struct_ser.serialize_field("bitmap", v)?;
16377 }
16378 struct_ser.end()
16379 }
16380}
16381impl<'de> serde::Deserialize<'de> for serving_table_vnode_mappings::ServingTableVnodeMapping {
16382 #[allow(deprecated)]
16383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16384 where
16385 D: serde::Deserializer<'de>,
16386 {
16387 const FIELDS: &[&str] = &[
16388 "table_id",
16389 "tableId",
16390 "bitmap",
16391 ];
16392
16393 #[allow(clippy::enum_variant_names)]
16394 enum GeneratedField {
16395 TableId,
16396 Bitmap,
16397 }
16398 impl<'de> serde::Deserialize<'de> for GeneratedField {
16399 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16400 where
16401 D: serde::Deserializer<'de>,
16402 {
16403 struct GeneratedVisitor;
16404
16405 impl serde::de::Visitor<'_> for GeneratedVisitor {
16406 type Value = GeneratedField;
16407
16408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16409 write!(formatter, "expected one of: {:?}", &FIELDS)
16410 }
16411
16412 #[allow(unused_variables)]
16413 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16414 where
16415 E: serde::de::Error,
16416 {
16417 match value {
16418 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16419 "bitmap" => Ok(GeneratedField::Bitmap),
16420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16421 }
16422 }
16423 }
16424 deserializer.deserialize_identifier(GeneratedVisitor)
16425 }
16426 }
16427 struct GeneratedVisitor;
16428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16429 type Value = serving_table_vnode_mappings::ServingTableVnodeMapping;
16430
16431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16432 formatter.write_str("struct meta.ServingTableVnodeMappings.ServingTableVnodeMapping")
16433 }
16434
16435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<serving_table_vnode_mappings::ServingTableVnodeMapping, V::Error>
16436 where
16437 V: serde::de::MapAccess<'de>,
16438 {
16439 let mut table_id__ = None;
16440 let mut bitmap__ = None;
16441 while let Some(k) = map_.next_key()? {
16442 match k {
16443 GeneratedField::TableId => {
16444 if table_id__.is_some() {
16445 return Err(serde::de::Error::duplicate_field("tableId"));
16446 }
16447 table_id__ =
16448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16449 ;
16450 }
16451 GeneratedField::Bitmap => {
16452 if bitmap__.is_some() {
16453 return Err(serde::de::Error::duplicate_field("bitmap"));
16454 }
16455 bitmap__ = map_.next_value()?;
16456 }
16457 }
16458 }
16459 Ok(serving_table_vnode_mappings::ServingTableVnodeMapping {
16460 table_id: table_id__.unwrap_or_default(),
16461 bitmap: bitmap__,
16462 })
16463 }
16464 }
16465 deserializer.deserialize_struct("meta.ServingTableVnodeMappings.ServingTableVnodeMapping", FIELDS, GeneratedVisitor)
16466 }
16467}
16468impl serde::Serialize for SetSessionParamRequest {
16469 #[allow(deprecated)]
16470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16471 where
16472 S: serde::Serializer,
16473 {
16474 use serde::ser::SerializeStruct;
16475 let mut len = 0;
16476 if !self.param.is_empty() {
16477 len += 1;
16478 }
16479 if self.value.is_some() {
16480 len += 1;
16481 }
16482 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
16483 if !self.param.is_empty() {
16484 struct_ser.serialize_field("param", &self.param)?;
16485 }
16486 if let Some(v) = self.value.as_ref() {
16487 struct_ser.serialize_field("value", v)?;
16488 }
16489 struct_ser.end()
16490 }
16491}
16492impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
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 "param",
16500 "value",
16501 ];
16502
16503 #[allow(clippy::enum_variant_names)]
16504 enum GeneratedField {
16505 Param,
16506 Value,
16507 }
16508 impl<'de> serde::Deserialize<'de> for GeneratedField {
16509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16510 where
16511 D: serde::Deserializer<'de>,
16512 {
16513 struct GeneratedVisitor;
16514
16515 impl serde::de::Visitor<'_> for GeneratedVisitor {
16516 type Value = GeneratedField;
16517
16518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16519 write!(formatter, "expected one of: {:?}", &FIELDS)
16520 }
16521
16522 #[allow(unused_variables)]
16523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16524 where
16525 E: serde::de::Error,
16526 {
16527 match value {
16528 "param" => Ok(GeneratedField::Param),
16529 "value" => Ok(GeneratedField::Value),
16530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16531 }
16532 }
16533 }
16534 deserializer.deserialize_identifier(GeneratedVisitor)
16535 }
16536 }
16537 struct GeneratedVisitor;
16538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16539 type Value = SetSessionParamRequest;
16540
16541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16542 formatter.write_str("struct meta.SetSessionParamRequest")
16543 }
16544
16545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
16546 where
16547 V: serde::de::MapAccess<'de>,
16548 {
16549 let mut param__ = None;
16550 let mut value__ = None;
16551 while let Some(k) = map_.next_key()? {
16552 match k {
16553 GeneratedField::Param => {
16554 if param__.is_some() {
16555 return Err(serde::de::Error::duplicate_field("param"));
16556 }
16557 param__ = Some(map_.next_value()?);
16558 }
16559 GeneratedField::Value => {
16560 if value__.is_some() {
16561 return Err(serde::de::Error::duplicate_field("value"));
16562 }
16563 value__ = map_.next_value()?;
16564 }
16565 }
16566 }
16567 Ok(SetSessionParamRequest {
16568 param: param__.unwrap_or_default(),
16569 value: value__,
16570 })
16571 }
16572 }
16573 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
16574 }
16575}
16576impl serde::Serialize for SetSessionParamResponse {
16577 #[allow(deprecated)]
16578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16579 where
16580 S: serde::Serializer,
16581 {
16582 use serde::ser::SerializeStruct;
16583 let mut len = 0;
16584 if !self.param.is_empty() {
16585 len += 1;
16586 }
16587 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
16588 if !self.param.is_empty() {
16589 struct_ser.serialize_field("param", &self.param)?;
16590 }
16591 struct_ser.end()
16592 }
16593}
16594impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
16595 #[allow(deprecated)]
16596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16597 where
16598 D: serde::Deserializer<'de>,
16599 {
16600 const FIELDS: &[&str] = &[
16601 "param",
16602 ];
16603
16604 #[allow(clippy::enum_variant_names)]
16605 enum GeneratedField {
16606 Param,
16607 }
16608 impl<'de> serde::Deserialize<'de> for GeneratedField {
16609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16610 where
16611 D: serde::Deserializer<'de>,
16612 {
16613 struct GeneratedVisitor;
16614
16615 impl serde::de::Visitor<'_> for GeneratedVisitor {
16616 type Value = GeneratedField;
16617
16618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16619 write!(formatter, "expected one of: {:?}", &FIELDS)
16620 }
16621
16622 #[allow(unused_variables)]
16623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16624 where
16625 E: serde::de::Error,
16626 {
16627 match value {
16628 "param" => Ok(GeneratedField::Param),
16629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16630 }
16631 }
16632 }
16633 deserializer.deserialize_identifier(GeneratedVisitor)
16634 }
16635 }
16636 struct GeneratedVisitor;
16637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16638 type Value = SetSessionParamResponse;
16639
16640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16641 formatter.write_str("struct meta.SetSessionParamResponse")
16642 }
16643
16644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
16645 where
16646 V: serde::de::MapAccess<'de>,
16647 {
16648 let mut param__ = None;
16649 while let Some(k) = map_.next_key()? {
16650 match k {
16651 GeneratedField::Param => {
16652 if param__.is_some() {
16653 return Err(serde::de::Error::duplicate_field("param"));
16654 }
16655 param__ = Some(map_.next_value()?);
16656 }
16657 }
16658 }
16659 Ok(SetSessionParamResponse {
16660 param: param__.unwrap_or_default(),
16661 })
16662 }
16663 }
16664 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
16665 }
16666}
16667impl serde::Serialize for SetSyncLogStoreAlignedRequest {
16668 #[allow(deprecated)]
16669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16670 where
16671 S: serde::Serializer,
16672 {
16673 use serde::ser::SerializeStruct;
16674 let mut len = 0;
16675 if self.job_id != 0 {
16676 len += 1;
16677 }
16678 if self.aligned {
16679 len += 1;
16680 }
16681 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
16682 if self.job_id != 0 {
16683 struct_ser.serialize_field("jobId", &self.job_id)?;
16684 }
16685 if self.aligned {
16686 struct_ser.serialize_field("aligned", &self.aligned)?;
16687 }
16688 struct_ser.end()
16689 }
16690}
16691impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
16692 #[allow(deprecated)]
16693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16694 where
16695 D: serde::Deserializer<'de>,
16696 {
16697 const FIELDS: &[&str] = &[
16698 "job_id",
16699 "jobId",
16700 "aligned",
16701 ];
16702
16703 #[allow(clippy::enum_variant_names)]
16704 enum GeneratedField {
16705 JobId,
16706 Aligned,
16707 }
16708 impl<'de> serde::Deserialize<'de> for GeneratedField {
16709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16710 where
16711 D: serde::Deserializer<'de>,
16712 {
16713 struct GeneratedVisitor;
16714
16715 impl serde::de::Visitor<'_> for GeneratedVisitor {
16716 type Value = GeneratedField;
16717
16718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16719 write!(formatter, "expected one of: {:?}", &FIELDS)
16720 }
16721
16722 #[allow(unused_variables)]
16723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16724 where
16725 E: serde::de::Error,
16726 {
16727 match value {
16728 "jobId" | "job_id" => Ok(GeneratedField::JobId),
16729 "aligned" => Ok(GeneratedField::Aligned),
16730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16731 }
16732 }
16733 }
16734 deserializer.deserialize_identifier(GeneratedVisitor)
16735 }
16736 }
16737 struct GeneratedVisitor;
16738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16739 type Value = SetSyncLogStoreAlignedRequest;
16740
16741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16742 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
16743 }
16744
16745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
16746 where
16747 V: serde::de::MapAccess<'de>,
16748 {
16749 let mut job_id__ = None;
16750 let mut aligned__ = None;
16751 while let Some(k) = map_.next_key()? {
16752 match k {
16753 GeneratedField::JobId => {
16754 if job_id__.is_some() {
16755 return Err(serde::de::Error::duplicate_field("jobId"));
16756 }
16757 job_id__ =
16758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16759 ;
16760 }
16761 GeneratedField::Aligned => {
16762 if aligned__.is_some() {
16763 return Err(serde::de::Error::duplicate_field("aligned"));
16764 }
16765 aligned__ = Some(map_.next_value()?);
16766 }
16767 }
16768 }
16769 Ok(SetSyncLogStoreAlignedRequest {
16770 job_id: job_id__.unwrap_or_default(),
16771 aligned: aligned__.unwrap_or_default(),
16772 })
16773 }
16774 }
16775 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
16776 }
16777}
16778impl serde::Serialize for SetSyncLogStoreAlignedResponse {
16779 #[allow(deprecated)]
16780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16781 where
16782 S: serde::Serializer,
16783 {
16784 use serde::ser::SerializeStruct;
16785 let len = 0;
16786 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
16787 struct_ser.end()
16788 }
16789}
16790impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
16791 #[allow(deprecated)]
16792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16793 where
16794 D: serde::Deserializer<'de>,
16795 {
16796 const FIELDS: &[&str] = &[
16797 ];
16798
16799 #[allow(clippy::enum_variant_names)]
16800 enum GeneratedField {
16801 }
16802 impl<'de> serde::Deserialize<'de> for GeneratedField {
16803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16804 where
16805 D: serde::Deserializer<'de>,
16806 {
16807 struct GeneratedVisitor;
16808
16809 impl serde::de::Visitor<'_> for GeneratedVisitor {
16810 type Value = GeneratedField;
16811
16812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16813 write!(formatter, "expected one of: {:?}", &FIELDS)
16814 }
16815
16816 #[allow(unused_variables)]
16817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16818 where
16819 E: serde::de::Error,
16820 {
16821 Err(serde::de::Error::unknown_field(value, FIELDS))
16822 }
16823 }
16824 deserializer.deserialize_identifier(GeneratedVisitor)
16825 }
16826 }
16827 struct GeneratedVisitor;
16828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16829 type Value = SetSyncLogStoreAlignedResponse;
16830
16831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16832 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
16833 }
16834
16835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
16836 where
16837 V: serde::de::MapAccess<'de>,
16838 {
16839 while map_.next_key::<GeneratedField>()?.is_some() {
16840 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16841 }
16842 Ok(SetSyncLogStoreAlignedResponse {
16843 })
16844 }
16845 }
16846 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
16847 }
16848}
16849impl serde::Serialize for SetSystemParamRequest {
16850 #[allow(deprecated)]
16851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16852 where
16853 S: serde::Serializer,
16854 {
16855 use serde::ser::SerializeStruct;
16856 let mut len = 0;
16857 if !self.param.is_empty() {
16858 len += 1;
16859 }
16860 if self.value.is_some() {
16861 len += 1;
16862 }
16863 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
16864 if !self.param.is_empty() {
16865 struct_ser.serialize_field("param", &self.param)?;
16866 }
16867 if let Some(v) = self.value.as_ref() {
16868 struct_ser.serialize_field("value", v)?;
16869 }
16870 struct_ser.end()
16871 }
16872}
16873impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
16874 #[allow(deprecated)]
16875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16876 where
16877 D: serde::Deserializer<'de>,
16878 {
16879 const FIELDS: &[&str] = &[
16880 "param",
16881 "value",
16882 ];
16883
16884 #[allow(clippy::enum_variant_names)]
16885 enum GeneratedField {
16886 Param,
16887 Value,
16888 }
16889 impl<'de> serde::Deserialize<'de> for GeneratedField {
16890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16891 where
16892 D: serde::Deserializer<'de>,
16893 {
16894 struct GeneratedVisitor;
16895
16896 impl serde::de::Visitor<'_> for GeneratedVisitor {
16897 type Value = GeneratedField;
16898
16899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16900 write!(formatter, "expected one of: {:?}", &FIELDS)
16901 }
16902
16903 #[allow(unused_variables)]
16904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16905 where
16906 E: serde::de::Error,
16907 {
16908 match value {
16909 "param" => Ok(GeneratedField::Param),
16910 "value" => Ok(GeneratedField::Value),
16911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16912 }
16913 }
16914 }
16915 deserializer.deserialize_identifier(GeneratedVisitor)
16916 }
16917 }
16918 struct GeneratedVisitor;
16919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16920 type Value = SetSystemParamRequest;
16921
16922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16923 formatter.write_str("struct meta.SetSystemParamRequest")
16924 }
16925
16926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
16927 where
16928 V: serde::de::MapAccess<'de>,
16929 {
16930 let mut param__ = None;
16931 let mut value__ = None;
16932 while let Some(k) = map_.next_key()? {
16933 match k {
16934 GeneratedField::Param => {
16935 if param__.is_some() {
16936 return Err(serde::de::Error::duplicate_field("param"));
16937 }
16938 param__ = Some(map_.next_value()?);
16939 }
16940 GeneratedField::Value => {
16941 if value__.is_some() {
16942 return Err(serde::de::Error::duplicate_field("value"));
16943 }
16944 value__ = map_.next_value()?;
16945 }
16946 }
16947 }
16948 Ok(SetSystemParamRequest {
16949 param: param__.unwrap_or_default(),
16950 value: value__,
16951 })
16952 }
16953 }
16954 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
16955 }
16956}
16957impl serde::Serialize for SetSystemParamResponse {
16958 #[allow(deprecated)]
16959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16960 where
16961 S: serde::Serializer,
16962 {
16963 use serde::ser::SerializeStruct;
16964 let mut len = 0;
16965 if self.params.is_some() {
16966 len += 1;
16967 }
16968 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
16969 if let Some(v) = self.params.as_ref() {
16970 struct_ser.serialize_field("params", v)?;
16971 }
16972 struct_ser.end()
16973 }
16974}
16975impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
16976 #[allow(deprecated)]
16977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16978 where
16979 D: serde::Deserializer<'de>,
16980 {
16981 const FIELDS: &[&str] = &[
16982 "params",
16983 ];
16984
16985 #[allow(clippy::enum_variant_names)]
16986 enum GeneratedField {
16987 Params,
16988 }
16989 impl<'de> serde::Deserialize<'de> for GeneratedField {
16990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16991 where
16992 D: serde::Deserializer<'de>,
16993 {
16994 struct GeneratedVisitor;
16995
16996 impl serde::de::Visitor<'_> for GeneratedVisitor {
16997 type Value = GeneratedField;
16998
16999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17000 write!(formatter, "expected one of: {:?}", &FIELDS)
17001 }
17002
17003 #[allow(unused_variables)]
17004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17005 where
17006 E: serde::de::Error,
17007 {
17008 match value {
17009 "params" => Ok(GeneratedField::Params),
17010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17011 }
17012 }
17013 }
17014 deserializer.deserialize_identifier(GeneratedVisitor)
17015 }
17016 }
17017 struct GeneratedVisitor;
17018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17019 type Value = SetSystemParamResponse;
17020
17021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17022 formatter.write_str("struct meta.SetSystemParamResponse")
17023 }
17024
17025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
17026 where
17027 V: serde::de::MapAccess<'de>,
17028 {
17029 let mut params__ = None;
17030 while let Some(k) = map_.next_key()? {
17031 match k {
17032 GeneratedField::Params => {
17033 if params__.is_some() {
17034 return Err(serde::de::Error::duplicate_field("params"));
17035 }
17036 params__ = map_.next_value()?;
17037 }
17038 }
17039 }
17040 Ok(SetSystemParamResponse {
17041 params: params__,
17042 })
17043 }
17044 }
17045 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
17046 }
17047}
17048impl serde::Serialize for SubscribeRequest {
17049 #[allow(deprecated)]
17050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17051 where
17052 S: serde::Serializer,
17053 {
17054 use serde::ser::SerializeStruct;
17055 let mut len = 0;
17056 if self.subscribe_type != 0 {
17057 len += 1;
17058 }
17059 if self.host.is_some() {
17060 len += 1;
17061 }
17062 if self.worker_id != 0 {
17063 len += 1;
17064 }
17065 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
17066 if self.subscribe_type != 0 {
17067 let v = SubscribeType::try_from(self.subscribe_type)
17068 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
17069 struct_ser.serialize_field("subscribeType", &v)?;
17070 }
17071 if let Some(v) = self.host.as_ref() {
17072 struct_ser.serialize_field("host", v)?;
17073 }
17074 if self.worker_id != 0 {
17075 struct_ser.serialize_field("workerId", &self.worker_id)?;
17076 }
17077 struct_ser.end()
17078 }
17079}
17080impl<'de> serde::Deserialize<'de> for SubscribeRequest {
17081 #[allow(deprecated)]
17082 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17083 where
17084 D: serde::Deserializer<'de>,
17085 {
17086 const FIELDS: &[&str] = &[
17087 "subscribe_type",
17088 "subscribeType",
17089 "host",
17090 "worker_id",
17091 "workerId",
17092 ];
17093
17094 #[allow(clippy::enum_variant_names)]
17095 enum GeneratedField {
17096 SubscribeType,
17097 Host,
17098 WorkerId,
17099 }
17100 impl<'de> serde::Deserialize<'de> for GeneratedField {
17101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17102 where
17103 D: serde::Deserializer<'de>,
17104 {
17105 struct GeneratedVisitor;
17106
17107 impl serde::de::Visitor<'_> for GeneratedVisitor {
17108 type Value = GeneratedField;
17109
17110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17111 write!(formatter, "expected one of: {:?}", &FIELDS)
17112 }
17113
17114 #[allow(unused_variables)]
17115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17116 where
17117 E: serde::de::Error,
17118 {
17119 match value {
17120 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
17121 "host" => Ok(GeneratedField::Host),
17122 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
17123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17124 }
17125 }
17126 }
17127 deserializer.deserialize_identifier(GeneratedVisitor)
17128 }
17129 }
17130 struct GeneratedVisitor;
17131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17132 type Value = SubscribeRequest;
17133
17134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17135 formatter.write_str("struct meta.SubscribeRequest")
17136 }
17137
17138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
17139 where
17140 V: serde::de::MapAccess<'de>,
17141 {
17142 let mut subscribe_type__ = None;
17143 let mut host__ = None;
17144 let mut worker_id__ = None;
17145 while let Some(k) = map_.next_key()? {
17146 match k {
17147 GeneratedField::SubscribeType => {
17148 if subscribe_type__.is_some() {
17149 return Err(serde::de::Error::duplicate_field("subscribeType"));
17150 }
17151 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
17152 }
17153 GeneratedField::Host => {
17154 if host__.is_some() {
17155 return Err(serde::de::Error::duplicate_field("host"));
17156 }
17157 host__ = map_.next_value()?;
17158 }
17159 GeneratedField::WorkerId => {
17160 if worker_id__.is_some() {
17161 return Err(serde::de::Error::duplicate_field("workerId"));
17162 }
17163 worker_id__ =
17164 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17165 ;
17166 }
17167 }
17168 }
17169 Ok(SubscribeRequest {
17170 subscribe_type: subscribe_type__.unwrap_or_default(),
17171 host: host__,
17172 worker_id: worker_id__.unwrap_or_default(),
17173 })
17174 }
17175 }
17176 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
17177 }
17178}
17179impl serde::Serialize for SubscribeResponse {
17180 #[allow(deprecated)]
17181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17182 where
17183 S: serde::Serializer,
17184 {
17185 use serde::ser::SerializeStruct;
17186 let mut len = 0;
17187 if self.status.is_some() {
17188 len += 1;
17189 }
17190 if self.operation != 0 {
17191 len += 1;
17192 }
17193 if self.version != 0 {
17194 len += 1;
17195 }
17196 if self.info.is_some() {
17197 len += 1;
17198 }
17199 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
17200 if let Some(v) = self.status.as_ref() {
17201 struct_ser.serialize_field("status", v)?;
17202 }
17203 if self.operation != 0 {
17204 let v = subscribe_response::Operation::try_from(self.operation)
17205 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
17206 struct_ser.serialize_field("operation", &v)?;
17207 }
17208 if self.version != 0 {
17209 #[allow(clippy::needless_borrow)]
17210 #[allow(clippy::needless_borrows_for_generic_args)]
17211 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
17212 }
17213 if let Some(v) = self.info.as_ref() {
17214 match v {
17215 subscribe_response::Info::Database(v) => {
17216 struct_ser.serialize_field("database", v)?;
17217 }
17218 subscribe_response::Info::Schema(v) => {
17219 struct_ser.serialize_field("schema", v)?;
17220 }
17221 subscribe_response::Info::Function(v) => {
17222 struct_ser.serialize_field("function", v)?;
17223 }
17224 subscribe_response::Info::User(v) => {
17225 struct_ser.serialize_field("user", v)?;
17226 }
17227 subscribe_response::Info::SessionParam(v) => {
17228 struct_ser.serialize_field("sessionParam", v)?;
17229 }
17230 subscribe_response::Info::Node(v) => {
17231 struct_ser.serialize_field("node", v)?;
17232 }
17233 subscribe_response::Info::HummockVersionDeltas(v) => {
17234 struct_ser.serialize_field("hummockVersionDeltas", v)?;
17235 }
17236 subscribe_response::Info::Snapshot(v) => {
17237 struct_ser.serialize_field("snapshot", v)?;
17238 }
17239 subscribe_response::Info::MetaBackupManifestId(v) => {
17240 struct_ser.serialize_field("metaBackupManifestId", v)?;
17241 }
17242 subscribe_response::Info::SystemParams(v) => {
17243 struct_ser.serialize_field("systemParams", v)?;
17244 }
17245 subscribe_response::Info::HummockWriteLimits(v) => {
17246 struct_ser.serialize_field("hummockWriteLimits", v)?;
17247 }
17248 subscribe_response::Info::ObjectGroup(v) => {
17249 struct_ser.serialize_field("objectGroup", v)?;
17250 }
17251 subscribe_response::Info::Connection(v) => {
17252 struct_ser.serialize_field("connection", v)?;
17253 }
17254 subscribe_response::Info::HummockStats(v) => {
17255 struct_ser.serialize_field("hummockStats", v)?;
17256 }
17257 subscribe_response::Info::Recovery(v) => {
17258 struct_ser.serialize_field("recovery", v)?;
17259 }
17260 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
17261 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
17262 }
17263 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
17264 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
17265 }
17266 subscribe_response::Info::Secret(v) => {
17267 struct_ser.serialize_field("secret", v)?;
17268 }
17269 subscribe_response::Info::ClusterResource(v) => {
17270 struct_ser.serialize_field("clusterResource", v)?;
17271 }
17272 subscribe_response::Info::TableRefillRuntimeConfig(v) => {
17273 struct_ser.serialize_field("tableRefillRuntimeConfig", v)?;
17274 }
17275 }
17276 }
17277 struct_ser.end()
17278 }
17279}
17280impl<'de> serde::Deserialize<'de> for SubscribeResponse {
17281 #[allow(deprecated)]
17282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17283 where
17284 D: serde::Deserializer<'de>,
17285 {
17286 const FIELDS: &[&str] = &[
17287 "status",
17288 "operation",
17289 "version",
17290 "database",
17291 "schema",
17292 "function",
17293 "user",
17294 "session_param",
17295 "sessionParam",
17296 "node",
17297 "hummock_version_deltas",
17298 "hummockVersionDeltas",
17299 "snapshot",
17300 "meta_backup_manifest_id",
17301 "metaBackupManifestId",
17302 "system_params",
17303 "systemParams",
17304 "hummock_write_limits",
17305 "hummockWriteLimits",
17306 "object_group",
17307 "objectGroup",
17308 "connection",
17309 "hummock_stats",
17310 "hummockStats",
17311 "recovery",
17312 "streaming_worker_slot_mapping",
17313 "streamingWorkerSlotMapping",
17314 "serving_worker_slot_mappings",
17315 "servingWorkerSlotMappings",
17316 "secret",
17317 "cluster_resource",
17318 "clusterResource",
17319 "table_refill_runtime_config",
17320 "tableRefillRuntimeConfig",
17321 ];
17322
17323 #[allow(clippy::enum_variant_names)]
17324 enum GeneratedField {
17325 Status,
17326 Operation,
17327 Version,
17328 Database,
17329 Schema,
17330 Function,
17331 User,
17332 SessionParam,
17333 Node,
17334 HummockVersionDeltas,
17335 Snapshot,
17336 MetaBackupManifestId,
17337 SystemParams,
17338 HummockWriteLimits,
17339 ObjectGroup,
17340 Connection,
17341 HummockStats,
17342 Recovery,
17343 StreamingWorkerSlotMapping,
17344 ServingWorkerSlotMappings,
17345 Secret,
17346 ClusterResource,
17347 TableRefillRuntimeConfig,
17348 }
17349 impl<'de> serde::Deserialize<'de> for GeneratedField {
17350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17351 where
17352 D: serde::Deserializer<'de>,
17353 {
17354 struct GeneratedVisitor;
17355
17356 impl serde::de::Visitor<'_> for GeneratedVisitor {
17357 type Value = GeneratedField;
17358
17359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17360 write!(formatter, "expected one of: {:?}", &FIELDS)
17361 }
17362
17363 #[allow(unused_variables)]
17364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17365 where
17366 E: serde::de::Error,
17367 {
17368 match value {
17369 "status" => Ok(GeneratedField::Status),
17370 "operation" => Ok(GeneratedField::Operation),
17371 "version" => Ok(GeneratedField::Version),
17372 "database" => Ok(GeneratedField::Database),
17373 "schema" => Ok(GeneratedField::Schema),
17374 "function" => Ok(GeneratedField::Function),
17375 "user" => Ok(GeneratedField::User),
17376 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
17377 "node" => Ok(GeneratedField::Node),
17378 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
17379 "snapshot" => Ok(GeneratedField::Snapshot),
17380 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
17381 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
17382 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
17383 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
17384 "connection" => Ok(GeneratedField::Connection),
17385 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
17386 "recovery" => Ok(GeneratedField::Recovery),
17387 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
17388 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
17389 "secret" => Ok(GeneratedField::Secret),
17390 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
17391 "tableRefillRuntimeConfig" | "table_refill_runtime_config" => Ok(GeneratedField::TableRefillRuntimeConfig),
17392 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17393 }
17394 }
17395 }
17396 deserializer.deserialize_identifier(GeneratedVisitor)
17397 }
17398 }
17399 struct GeneratedVisitor;
17400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17401 type Value = SubscribeResponse;
17402
17403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17404 formatter.write_str("struct meta.SubscribeResponse")
17405 }
17406
17407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
17408 where
17409 V: serde::de::MapAccess<'de>,
17410 {
17411 let mut status__ = None;
17412 let mut operation__ = None;
17413 let mut version__ = None;
17414 let mut info__ = None;
17415 while let Some(k) = map_.next_key()? {
17416 match k {
17417 GeneratedField::Status => {
17418 if status__.is_some() {
17419 return Err(serde::de::Error::duplicate_field("status"));
17420 }
17421 status__ = map_.next_value()?;
17422 }
17423 GeneratedField::Operation => {
17424 if operation__.is_some() {
17425 return Err(serde::de::Error::duplicate_field("operation"));
17426 }
17427 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
17428 }
17429 GeneratedField::Version => {
17430 if version__.is_some() {
17431 return Err(serde::de::Error::duplicate_field("version"));
17432 }
17433 version__ =
17434 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17435 ;
17436 }
17437 GeneratedField::Database => {
17438 if info__.is_some() {
17439 return Err(serde::de::Error::duplicate_field("database"));
17440 }
17441 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
17442;
17443 }
17444 GeneratedField::Schema => {
17445 if info__.is_some() {
17446 return Err(serde::de::Error::duplicate_field("schema"));
17447 }
17448 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
17449;
17450 }
17451 GeneratedField::Function => {
17452 if info__.is_some() {
17453 return Err(serde::de::Error::duplicate_field("function"));
17454 }
17455 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
17456;
17457 }
17458 GeneratedField::User => {
17459 if info__.is_some() {
17460 return Err(serde::de::Error::duplicate_field("user"));
17461 }
17462 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
17463;
17464 }
17465 GeneratedField::SessionParam => {
17466 if info__.is_some() {
17467 return Err(serde::de::Error::duplicate_field("sessionParam"));
17468 }
17469 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
17470;
17471 }
17472 GeneratedField::Node => {
17473 if info__.is_some() {
17474 return Err(serde::de::Error::duplicate_field("node"));
17475 }
17476 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
17477;
17478 }
17479 GeneratedField::HummockVersionDeltas => {
17480 if info__.is_some() {
17481 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
17482 }
17483 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
17484;
17485 }
17486 GeneratedField::Snapshot => {
17487 if info__.is_some() {
17488 return Err(serde::de::Error::duplicate_field("snapshot"));
17489 }
17490 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
17491;
17492 }
17493 GeneratedField::MetaBackupManifestId => {
17494 if info__.is_some() {
17495 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
17496 }
17497 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
17498;
17499 }
17500 GeneratedField::SystemParams => {
17501 if info__.is_some() {
17502 return Err(serde::de::Error::duplicate_field("systemParams"));
17503 }
17504 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
17505;
17506 }
17507 GeneratedField::HummockWriteLimits => {
17508 if info__.is_some() {
17509 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
17510 }
17511 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
17512;
17513 }
17514 GeneratedField::ObjectGroup => {
17515 if info__.is_some() {
17516 return Err(serde::de::Error::duplicate_field("objectGroup"));
17517 }
17518 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
17519;
17520 }
17521 GeneratedField::Connection => {
17522 if info__.is_some() {
17523 return Err(serde::de::Error::duplicate_field("connection"));
17524 }
17525 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
17526;
17527 }
17528 GeneratedField::HummockStats => {
17529 if info__.is_some() {
17530 return Err(serde::de::Error::duplicate_field("hummockStats"));
17531 }
17532 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
17533;
17534 }
17535 GeneratedField::Recovery => {
17536 if info__.is_some() {
17537 return Err(serde::de::Error::duplicate_field("recovery"));
17538 }
17539 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
17540;
17541 }
17542 GeneratedField::StreamingWorkerSlotMapping => {
17543 if info__.is_some() {
17544 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
17545 }
17546 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
17547;
17548 }
17549 GeneratedField::ServingWorkerSlotMappings => {
17550 if info__.is_some() {
17551 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
17552 }
17553 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
17554;
17555 }
17556 GeneratedField::Secret => {
17557 if info__.is_some() {
17558 return Err(serde::de::Error::duplicate_field("secret"));
17559 }
17560 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
17561;
17562 }
17563 GeneratedField::ClusterResource => {
17564 if info__.is_some() {
17565 return Err(serde::de::Error::duplicate_field("clusterResource"));
17566 }
17567 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
17568;
17569 }
17570 GeneratedField::TableRefillRuntimeConfig => {
17571 if info__.is_some() {
17572 return Err(serde::de::Error::duplicate_field("tableRefillRuntimeConfig"));
17573 }
17574 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::TableRefillRuntimeConfig)
17575;
17576 }
17577 }
17578 }
17579 Ok(SubscribeResponse {
17580 status: status__,
17581 operation: operation__.unwrap_or_default(),
17582 version: version__.unwrap_or_default(),
17583 info: info__,
17584 })
17585 }
17586 }
17587 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
17588 }
17589}
17590impl serde::Serialize for subscribe_response::Operation {
17591 #[allow(deprecated)]
17592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17593 where
17594 S: serde::Serializer,
17595 {
17596 let variant = match self {
17597 Self::Unspecified => "UNSPECIFIED",
17598 Self::Add => "ADD",
17599 Self::Delete => "DELETE",
17600 Self::Update => "UPDATE",
17601 Self::Snapshot => "SNAPSHOT",
17602 };
17603 serializer.serialize_str(variant)
17604 }
17605}
17606impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
17607 #[allow(deprecated)]
17608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17609 where
17610 D: serde::Deserializer<'de>,
17611 {
17612 const FIELDS: &[&str] = &[
17613 "UNSPECIFIED",
17614 "ADD",
17615 "DELETE",
17616 "UPDATE",
17617 "SNAPSHOT",
17618 ];
17619
17620 struct GeneratedVisitor;
17621
17622 impl serde::de::Visitor<'_> for GeneratedVisitor {
17623 type Value = subscribe_response::Operation;
17624
17625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17626 write!(formatter, "expected one of: {:?}", &FIELDS)
17627 }
17628
17629 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17630 where
17631 E: serde::de::Error,
17632 {
17633 i32::try_from(v)
17634 .ok()
17635 .and_then(|x| x.try_into().ok())
17636 .ok_or_else(|| {
17637 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17638 })
17639 }
17640
17641 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17642 where
17643 E: serde::de::Error,
17644 {
17645 i32::try_from(v)
17646 .ok()
17647 .and_then(|x| x.try_into().ok())
17648 .ok_or_else(|| {
17649 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17650 })
17651 }
17652
17653 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17654 where
17655 E: serde::de::Error,
17656 {
17657 match value {
17658 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
17659 "ADD" => Ok(subscribe_response::Operation::Add),
17660 "DELETE" => Ok(subscribe_response::Operation::Delete),
17661 "UPDATE" => Ok(subscribe_response::Operation::Update),
17662 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
17663 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17664 }
17665 }
17666 }
17667 deserializer.deserialize_any(GeneratedVisitor)
17668 }
17669}
17670impl serde::Serialize for SubscribeType {
17671 #[allow(deprecated)]
17672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17673 where
17674 S: serde::Serializer,
17675 {
17676 let variant = match self {
17677 Self::Unspecified => "UNSPECIFIED",
17678 Self::Frontend => "FRONTEND",
17679 Self::Hummock => "HUMMOCK",
17680 Self::Compactor => "COMPACTOR",
17681 Self::Compute => "COMPUTE",
17682 };
17683 serializer.serialize_str(variant)
17684 }
17685}
17686impl<'de> serde::Deserialize<'de> for SubscribeType {
17687 #[allow(deprecated)]
17688 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17689 where
17690 D: serde::Deserializer<'de>,
17691 {
17692 const FIELDS: &[&str] = &[
17693 "UNSPECIFIED",
17694 "FRONTEND",
17695 "HUMMOCK",
17696 "COMPACTOR",
17697 "COMPUTE",
17698 ];
17699
17700 struct GeneratedVisitor;
17701
17702 impl serde::de::Visitor<'_> for GeneratedVisitor {
17703 type Value = SubscribeType;
17704
17705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17706 write!(formatter, "expected one of: {:?}", &FIELDS)
17707 }
17708
17709 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17710 where
17711 E: serde::de::Error,
17712 {
17713 i32::try_from(v)
17714 .ok()
17715 .and_then(|x| x.try_into().ok())
17716 .ok_or_else(|| {
17717 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17718 })
17719 }
17720
17721 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17722 where
17723 E: serde::de::Error,
17724 {
17725 i32::try_from(v)
17726 .ok()
17727 .and_then(|x| x.try_into().ok())
17728 .ok_or_else(|| {
17729 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17730 })
17731 }
17732
17733 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17734 where
17735 E: serde::de::Error,
17736 {
17737 match value {
17738 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
17739 "FRONTEND" => Ok(SubscribeType::Frontend),
17740 "HUMMOCK" => Ok(SubscribeType::Hummock),
17741 "COMPACTOR" => Ok(SubscribeType::Compactor),
17742 "COMPUTE" => Ok(SubscribeType::Compute),
17743 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17744 }
17745 }
17746 }
17747 deserializer.deserialize_any(GeneratedVisitor)
17748 }
17749}
17750impl serde::Serialize for SystemParams {
17751 #[allow(deprecated)]
17752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17753 where
17754 S: serde::Serializer,
17755 {
17756 use serde::ser::SerializeStruct;
17757 let mut len = 0;
17758 if self.barrier_interval_ms.is_some() {
17759 len += 1;
17760 }
17761 if self.checkpoint_frequency.is_some() {
17762 len += 1;
17763 }
17764 if self.sstable_size_mb.is_some() {
17765 len += 1;
17766 }
17767 if self.block_size_kb.is_some() {
17768 len += 1;
17769 }
17770 if self.bloom_false_positive.is_some() {
17771 len += 1;
17772 }
17773 if self.state_store.is_some() {
17774 len += 1;
17775 }
17776 if self.data_directory.is_some() {
17777 len += 1;
17778 }
17779 if self.backup_storage_url.is_some() {
17780 len += 1;
17781 }
17782 if self.backup_storage_directory.is_some() {
17783 len += 1;
17784 }
17785 if self.telemetry_enabled.is_some() {
17786 len += 1;
17787 }
17788 if self.parallel_compact_size_mb.is_some() {
17789 len += 1;
17790 }
17791 if self.max_concurrent_creating_streaming_jobs.is_some() {
17792 len += 1;
17793 }
17794 if self.pause_on_next_bootstrap.is_some() {
17795 len += 1;
17796 }
17797 if self.wasm_storage_url.is_some() {
17798 len += 1;
17799 }
17800 if self.enable_tracing.is_some() {
17801 len += 1;
17802 }
17803 if self.use_new_object_prefix_strategy.is_some() {
17804 len += 1;
17805 }
17806 if self.license_key.is_some() {
17807 len += 1;
17808 }
17809 if self.time_travel_retention_ms.is_some() {
17810 len += 1;
17811 }
17812 if self.adaptive_parallelism_strategy.is_some() {
17813 len += 1;
17814 }
17815 if self.per_database_isolation.is_some() {
17816 len += 1;
17817 }
17818 if self.enforce_secret.is_some() {
17819 len += 1;
17820 }
17821 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
17822 if let Some(v) = self.barrier_interval_ms.as_ref() {
17823 struct_ser.serialize_field("barrierIntervalMs", v)?;
17824 }
17825 if let Some(v) = self.checkpoint_frequency.as_ref() {
17826 #[allow(clippy::needless_borrow)]
17827 #[allow(clippy::needless_borrows_for_generic_args)]
17828 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
17829 }
17830 if let Some(v) = self.sstable_size_mb.as_ref() {
17831 struct_ser.serialize_field("sstableSizeMb", v)?;
17832 }
17833 if let Some(v) = self.block_size_kb.as_ref() {
17834 struct_ser.serialize_field("blockSizeKb", v)?;
17835 }
17836 if let Some(v) = self.bloom_false_positive.as_ref() {
17837 struct_ser.serialize_field("bloomFalsePositive", v)?;
17838 }
17839 if let Some(v) = self.state_store.as_ref() {
17840 struct_ser.serialize_field("stateStore", v)?;
17841 }
17842 if let Some(v) = self.data_directory.as_ref() {
17843 struct_ser.serialize_field("dataDirectory", v)?;
17844 }
17845 if let Some(v) = self.backup_storage_url.as_ref() {
17846 struct_ser.serialize_field("backupStorageUrl", v)?;
17847 }
17848 if let Some(v) = self.backup_storage_directory.as_ref() {
17849 struct_ser.serialize_field("backupStorageDirectory", v)?;
17850 }
17851 if let Some(v) = self.telemetry_enabled.as_ref() {
17852 struct_ser.serialize_field("telemetryEnabled", v)?;
17853 }
17854 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
17855 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
17856 }
17857 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
17858 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
17859 }
17860 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
17861 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
17862 }
17863 if let Some(v) = self.wasm_storage_url.as_ref() {
17864 struct_ser.serialize_field("wasmStorageUrl", v)?;
17865 }
17866 if let Some(v) = self.enable_tracing.as_ref() {
17867 struct_ser.serialize_field("enableTracing", v)?;
17868 }
17869 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
17870 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
17871 }
17872 if let Some(v) = self.license_key.as_ref() {
17873 struct_ser.serialize_field("licenseKey", v)?;
17874 }
17875 if let Some(v) = self.time_travel_retention_ms.as_ref() {
17876 #[allow(clippy::needless_borrow)]
17877 #[allow(clippy::needless_borrows_for_generic_args)]
17878 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
17879 }
17880 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
17881 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
17882 }
17883 if let Some(v) = self.per_database_isolation.as_ref() {
17884 struct_ser.serialize_field("perDatabaseIsolation", v)?;
17885 }
17886 if let Some(v) = self.enforce_secret.as_ref() {
17887 struct_ser.serialize_field("enforceSecret", v)?;
17888 }
17889 struct_ser.end()
17890 }
17891}
17892impl<'de> serde::Deserialize<'de> for SystemParams {
17893 #[allow(deprecated)]
17894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17895 where
17896 D: serde::Deserializer<'de>,
17897 {
17898 const FIELDS: &[&str] = &[
17899 "barrier_interval_ms",
17900 "barrierIntervalMs",
17901 "checkpoint_frequency",
17902 "checkpointFrequency",
17903 "sstable_size_mb",
17904 "sstableSizeMb",
17905 "block_size_kb",
17906 "blockSizeKb",
17907 "bloom_false_positive",
17908 "bloomFalsePositive",
17909 "state_store",
17910 "stateStore",
17911 "data_directory",
17912 "dataDirectory",
17913 "backup_storage_url",
17914 "backupStorageUrl",
17915 "backup_storage_directory",
17916 "backupStorageDirectory",
17917 "telemetry_enabled",
17918 "telemetryEnabled",
17919 "parallel_compact_size_mb",
17920 "parallelCompactSizeMb",
17921 "max_concurrent_creating_streaming_jobs",
17922 "maxConcurrentCreatingStreamingJobs",
17923 "pause_on_next_bootstrap",
17924 "pauseOnNextBootstrap",
17925 "wasm_storage_url",
17926 "wasmStorageUrl",
17927 "enable_tracing",
17928 "enableTracing",
17929 "use_new_object_prefix_strategy",
17930 "useNewObjectPrefixStrategy",
17931 "license_key",
17932 "licenseKey",
17933 "time_travel_retention_ms",
17934 "timeTravelRetentionMs",
17935 "adaptive_parallelism_strategy",
17936 "adaptiveParallelismStrategy",
17937 "per_database_isolation",
17938 "perDatabaseIsolation",
17939 "enforce_secret",
17940 "enforceSecret",
17941 ];
17942
17943 #[allow(clippy::enum_variant_names)]
17944 enum GeneratedField {
17945 BarrierIntervalMs,
17946 CheckpointFrequency,
17947 SstableSizeMb,
17948 BlockSizeKb,
17949 BloomFalsePositive,
17950 StateStore,
17951 DataDirectory,
17952 BackupStorageUrl,
17953 BackupStorageDirectory,
17954 TelemetryEnabled,
17955 ParallelCompactSizeMb,
17956 MaxConcurrentCreatingStreamingJobs,
17957 PauseOnNextBootstrap,
17958 WasmStorageUrl,
17959 EnableTracing,
17960 UseNewObjectPrefixStrategy,
17961 LicenseKey,
17962 TimeTravelRetentionMs,
17963 AdaptiveParallelismStrategy,
17964 PerDatabaseIsolation,
17965 EnforceSecret,
17966 }
17967 impl<'de> serde::Deserialize<'de> for GeneratedField {
17968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17969 where
17970 D: serde::Deserializer<'de>,
17971 {
17972 struct GeneratedVisitor;
17973
17974 impl serde::de::Visitor<'_> for GeneratedVisitor {
17975 type Value = GeneratedField;
17976
17977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17978 write!(formatter, "expected one of: {:?}", &FIELDS)
17979 }
17980
17981 #[allow(unused_variables)]
17982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17983 where
17984 E: serde::de::Error,
17985 {
17986 match value {
17987 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
17988 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
17989 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
17990 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
17991 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
17992 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
17993 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
17994 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
17995 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
17996 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
17997 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
17998 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
17999 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
18000 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
18001 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
18002 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
18003 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
18004 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
18005 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
18006 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
18007 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
18008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18009 }
18010 }
18011 }
18012 deserializer.deserialize_identifier(GeneratedVisitor)
18013 }
18014 }
18015 struct GeneratedVisitor;
18016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18017 type Value = SystemParams;
18018
18019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18020 formatter.write_str("struct meta.SystemParams")
18021 }
18022
18023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
18024 where
18025 V: serde::de::MapAccess<'de>,
18026 {
18027 let mut barrier_interval_ms__ = None;
18028 let mut checkpoint_frequency__ = None;
18029 let mut sstable_size_mb__ = None;
18030 let mut block_size_kb__ = None;
18031 let mut bloom_false_positive__ = None;
18032 let mut state_store__ = None;
18033 let mut data_directory__ = None;
18034 let mut backup_storage_url__ = None;
18035 let mut backup_storage_directory__ = None;
18036 let mut telemetry_enabled__ = None;
18037 let mut parallel_compact_size_mb__ = None;
18038 let mut max_concurrent_creating_streaming_jobs__ = None;
18039 let mut pause_on_next_bootstrap__ = None;
18040 let mut wasm_storage_url__ = None;
18041 let mut enable_tracing__ = None;
18042 let mut use_new_object_prefix_strategy__ = None;
18043 let mut license_key__ = None;
18044 let mut time_travel_retention_ms__ = None;
18045 let mut adaptive_parallelism_strategy__ = None;
18046 let mut per_database_isolation__ = None;
18047 let mut enforce_secret__ = None;
18048 while let Some(k) = map_.next_key()? {
18049 match k {
18050 GeneratedField::BarrierIntervalMs => {
18051 if barrier_interval_ms__.is_some() {
18052 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
18053 }
18054 barrier_interval_ms__ =
18055 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18056 ;
18057 }
18058 GeneratedField::CheckpointFrequency => {
18059 if checkpoint_frequency__.is_some() {
18060 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
18061 }
18062 checkpoint_frequency__ =
18063 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18064 ;
18065 }
18066 GeneratedField::SstableSizeMb => {
18067 if sstable_size_mb__.is_some() {
18068 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
18069 }
18070 sstable_size_mb__ =
18071 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18072 ;
18073 }
18074 GeneratedField::BlockSizeKb => {
18075 if block_size_kb__.is_some() {
18076 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
18077 }
18078 block_size_kb__ =
18079 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18080 ;
18081 }
18082 GeneratedField::BloomFalsePositive => {
18083 if bloom_false_positive__.is_some() {
18084 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
18085 }
18086 bloom_false_positive__ =
18087 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18088 ;
18089 }
18090 GeneratedField::StateStore => {
18091 if state_store__.is_some() {
18092 return Err(serde::de::Error::duplicate_field("stateStore"));
18093 }
18094 state_store__ = map_.next_value()?;
18095 }
18096 GeneratedField::DataDirectory => {
18097 if data_directory__.is_some() {
18098 return Err(serde::de::Error::duplicate_field("dataDirectory"));
18099 }
18100 data_directory__ = map_.next_value()?;
18101 }
18102 GeneratedField::BackupStorageUrl => {
18103 if backup_storage_url__.is_some() {
18104 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
18105 }
18106 backup_storage_url__ = map_.next_value()?;
18107 }
18108 GeneratedField::BackupStorageDirectory => {
18109 if backup_storage_directory__.is_some() {
18110 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
18111 }
18112 backup_storage_directory__ = map_.next_value()?;
18113 }
18114 GeneratedField::TelemetryEnabled => {
18115 if telemetry_enabled__.is_some() {
18116 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
18117 }
18118 telemetry_enabled__ = map_.next_value()?;
18119 }
18120 GeneratedField::ParallelCompactSizeMb => {
18121 if parallel_compact_size_mb__.is_some() {
18122 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
18123 }
18124 parallel_compact_size_mb__ =
18125 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18126 ;
18127 }
18128 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
18129 if max_concurrent_creating_streaming_jobs__.is_some() {
18130 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
18131 }
18132 max_concurrent_creating_streaming_jobs__ =
18133 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18134 ;
18135 }
18136 GeneratedField::PauseOnNextBootstrap => {
18137 if pause_on_next_bootstrap__.is_some() {
18138 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
18139 }
18140 pause_on_next_bootstrap__ = map_.next_value()?;
18141 }
18142 GeneratedField::WasmStorageUrl => {
18143 if wasm_storage_url__.is_some() {
18144 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
18145 }
18146 wasm_storage_url__ = map_.next_value()?;
18147 }
18148 GeneratedField::EnableTracing => {
18149 if enable_tracing__.is_some() {
18150 return Err(serde::de::Error::duplicate_field("enableTracing"));
18151 }
18152 enable_tracing__ = map_.next_value()?;
18153 }
18154 GeneratedField::UseNewObjectPrefixStrategy => {
18155 if use_new_object_prefix_strategy__.is_some() {
18156 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
18157 }
18158 use_new_object_prefix_strategy__ = map_.next_value()?;
18159 }
18160 GeneratedField::LicenseKey => {
18161 if license_key__.is_some() {
18162 return Err(serde::de::Error::duplicate_field("licenseKey"));
18163 }
18164 license_key__ = map_.next_value()?;
18165 }
18166 GeneratedField::TimeTravelRetentionMs => {
18167 if time_travel_retention_ms__.is_some() {
18168 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
18169 }
18170 time_travel_retention_ms__ =
18171 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18172 ;
18173 }
18174 GeneratedField::AdaptiveParallelismStrategy => {
18175 if adaptive_parallelism_strategy__.is_some() {
18176 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
18177 }
18178 adaptive_parallelism_strategy__ = map_.next_value()?;
18179 }
18180 GeneratedField::PerDatabaseIsolation => {
18181 if per_database_isolation__.is_some() {
18182 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
18183 }
18184 per_database_isolation__ = map_.next_value()?;
18185 }
18186 GeneratedField::EnforceSecret => {
18187 if enforce_secret__.is_some() {
18188 return Err(serde::de::Error::duplicate_field("enforceSecret"));
18189 }
18190 enforce_secret__ = map_.next_value()?;
18191 }
18192 }
18193 }
18194 Ok(SystemParams {
18195 barrier_interval_ms: barrier_interval_ms__,
18196 checkpoint_frequency: checkpoint_frequency__,
18197 sstable_size_mb: sstable_size_mb__,
18198 block_size_kb: block_size_kb__,
18199 bloom_false_positive: bloom_false_positive__,
18200 state_store: state_store__,
18201 data_directory: data_directory__,
18202 backup_storage_url: backup_storage_url__,
18203 backup_storage_directory: backup_storage_directory__,
18204 telemetry_enabled: telemetry_enabled__,
18205 parallel_compact_size_mb: parallel_compact_size_mb__,
18206 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
18207 pause_on_next_bootstrap: pause_on_next_bootstrap__,
18208 wasm_storage_url: wasm_storage_url__,
18209 enable_tracing: enable_tracing__,
18210 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
18211 license_key: license_key__,
18212 time_travel_retention_ms: time_travel_retention_ms__,
18213 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
18214 per_database_isolation: per_database_isolation__,
18215 enforce_secret: enforce_secret__,
18216 })
18217 }
18218 }
18219 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
18220 }
18221}
18222impl serde::Serialize for TableCacheRefillPolicies {
18223 #[allow(deprecated)]
18224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18225 where
18226 S: serde::Serializer,
18227 {
18228 use serde::ser::SerializeStruct;
18229 let mut len = 0;
18230 if !self.table_policies.is_empty() {
18231 len += 1;
18232 }
18233 if !self.internal_table_policies.is_empty() {
18234 len += 1;
18235 }
18236 let mut struct_ser = serializer.serialize_struct("meta.TableCacheRefillPolicies", len)?;
18237 if !self.table_policies.is_empty() {
18238 struct_ser.serialize_field("tablePolicies", &self.table_policies)?;
18239 }
18240 if !self.internal_table_policies.is_empty() {
18241 struct_ser.serialize_field("internalTablePolicies", &self.internal_table_policies)?;
18242 }
18243 struct_ser.end()
18244 }
18245}
18246impl<'de> serde::Deserialize<'de> for TableCacheRefillPolicies {
18247 #[allow(deprecated)]
18248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18249 where
18250 D: serde::Deserializer<'de>,
18251 {
18252 const FIELDS: &[&str] = &[
18253 "table_policies",
18254 "tablePolicies",
18255 "internal_table_policies",
18256 "internalTablePolicies",
18257 ];
18258
18259 #[allow(clippy::enum_variant_names)]
18260 enum GeneratedField {
18261 TablePolicies,
18262 InternalTablePolicies,
18263 }
18264 impl<'de> serde::Deserialize<'de> for GeneratedField {
18265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18266 where
18267 D: serde::Deserializer<'de>,
18268 {
18269 struct GeneratedVisitor;
18270
18271 impl serde::de::Visitor<'_> for GeneratedVisitor {
18272 type Value = GeneratedField;
18273
18274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18275 write!(formatter, "expected one of: {:?}", &FIELDS)
18276 }
18277
18278 #[allow(unused_variables)]
18279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18280 where
18281 E: serde::de::Error,
18282 {
18283 match value {
18284 "tablePolicies" | "table_policies" => Ok(GeneratedField::TablePolicies),
18285 "internalTablePolicies" | "internal_table_policies" => Ok(GeneratedField::InternalTablePolicies),
18286 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18287 }
18288 }
18289 }
18290 deserializer.deserialize_identifier(GeneratedVisitor)
18291 }
18292 }
18293 struct GeneratedVisitor;
18294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18295 type Value = TableCacheRefillPolicies;
18296
18297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18298 formatter.write_str("struct meta.TableCacheRefillPolicies")
18299 }
18300
18301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableCacheRefillPolicies, V::Error>
18302 where
18303 V: serde::de::MapAccess<'de>,
18304 {
18305 let mut table_policies__ = None;
18306 let mut internal_table_policies__ = None;
18307 while let Some(k) = map_.next_key()? {
18308 match k {
18309 GeneratedField::TablePolicies => {
18310 if table_policies__.is_some() {
18311 return Err(serde::de::Error::duplicate_field("tablePolicies"));
18312 }
18313 table_policies__ = Some(map_.next_value()?);
18314 }
18315 GeneratedField::InternalTablePolicies => {
18316 if internal_table_policies__.is_some() {
18317 return Err(serde::de::Error::duplicate_field("internalTablePolicies"));
18318 }
18319 internal_table_policies__ = Some(map_.next_value()?);
18320 }
18321 }
18322 }
18323 Ok(TableCacheRefillPolicies {
18324 table_policies: table_policies__.unwrap_or_default(),
18325 internal_table_policies: internal_table_policies__.unwrap_or_default(),
18326 })
18327 }
18328 }
18329 deserializer.deserialize_struct("meta.TableCacheRefillPolicies", FIELDS, GeneratedVisitor)
18330 }
18331}
18332impl serde::Serialize for table_cache_refill_policies::TableCacheRefillPolicy {
18333 #[allow(deprecated)]
18334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18335 where
18336 S: serde::Serializer,
18337 {
18338 use serde::ser::SerializeStruct;
18339 let mut len = 0;
18340 if self.table_id != 0 {
18341 len += 1;
18342 }
18343 if self.policy != 0 {
18344 len += 1;
18345 }
18346 let mut struct_ser = serializer.serialize_struct("meta.TableCacheRefillPolicies.TableCacheRefillPolicy", len)?;
18347 if self.table_id != 0 {
18348 struct_ser.serialize_field("tableId", &self.table_id)?;
18349 }
18350 if self.policy != 0 {
18351 let v = table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::try_from(self.policy)
18352 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.policy)))?;
18353 struct_ser.serialize_field("policy", &v)?;
18354 }
18355 struct_ser.end()
18356 }
18357}
18358impl<'de> serde::Deserialize<'de> for table_cache_refill_policies::TableCacheRefillPolicy {
18359 #[allow(deprecated)]
18360 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18361 where
18362 D: serde::Deserializer<'de>,
18363 {
18364 const FIELDS: &[&str] = &[
18365 "table_id",
18366 "tableId",
18367 "policy",
18368 ];
18369
18370 #[allow(clippy::enum_variant_names)]
18371 enum GeneratedField {
18372 TableId,
18373 Policy,
18374 }
18375 impl<'de> serde::Deserialize<'de> for GeneratedField {
18376 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18377 where
18378 D: serde::Deserializer<'de>,
18379 {
18380 struct GeneratedVisitor;
18381
18382 impl serde::de::Visitor<'_> for GeneratedVisitor {
18383 type Value = GeneratedField;
18384
18385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18386 write!(formatter, "expected one of: {:?}", &FIELDS)
18387 }
18388
18389 #[allow(unused_variables)]
18390 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18391 where
18392 E: serde::de::Error,
18393 {
18394 match value {
18395 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18396 "policy" => Ok(GeneratedField::Policy),
18397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18398 }
18399 }
18400 }
18401 deserializer.deserialize_identifier(GeneratedVisitor)
18402 }
18403 }
18404 struct GeneratedVisitor;
18405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18406 type Value = table_cache_refill_policies::TableCacheRefillPolicy;
18407
18408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18409 formatter.write_str("struct meta.TableCacheRefillPolicies.TableCacheRefillPolicy")
18410 }
18411
18412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_cache_refill_policies::TableCacheRefillPolicy, V::Error>
18413 where
18414 V: serde::de::MapAccess<'de>,
18415 {
18416 let mut table_id__ = None;
18417 let mut policy__ = None;
18418 while let Some(k) = map_.next_key()? {
18419 match k {
18420 GeneratedField::TableId => {
18421 if table_id__.is_some() {
18422 return Err(serde::de::Error::duplicate_field("tableId"));
18423 }
18424 table_id__ =
18425 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18426 ;
18427 }
18428 GeneratedField::Policy => {
18429 if policy__.is_some() {
18430 return Err(serde::de::Error::duplicate_field("policy"));
18431 }
18432 policy__ = Some(map_.next_value::<table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy>()? as i32);
18433 }
18434 }
18435 }
18436 Ok(table_cache_refill_policies::TableCacheRefillPolicy {
18437 table_id: table_id__.unwrap_or_default(),
18438 policy: policy__.unwrap_or_default(),
18439 })
18440 }
18441 }
18442 deserializer.deserialize_struct("meta.TableCacheRefillPolicies.TableCacheRefillPolicy", FIELDS, GeneratedVisitor)
18443 }
18444}
18445impl serde::Serialize for table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy {
18446 #[allow(deprecated)]
18447 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18448 where
18449 S: serde::Serializer,
18450 {
18451 let variant = match self {
18452 Self::Unspecified => "UNSPECIFIED",
18453 Self::Enabled => "ENABLED",
18454 Self::Disabled => "DISABLED",
18455 Self::Streaming => "STREAMING",
18456 Self::Serving => "SERVING",
18457 Self::Both => "BOTH",
18458 };
18459 serializer.serialize_str(variant)
18460 }
18461}
18462impl<'de> serde::Deserialize<'de> for table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy {
18463 #[allow(deprecated)]
18464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18465 where
18466 D: serde::Deserializer<'de>,
18467 {
18468 const FIELDS: &[&str] = &[
18469 "UNSPECIFIED",
18470 "ENABLED",
18471 "DISABLED",
18472 "STREAMING",
18473 "SERVING",
18474 "BOTH",
18475 ];
18476
18477 struct GeneratedVisitor;
18478
18479 impl serde::de::Visitor<'_> for GeneratedVisitor {
18480 type Value = table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy;
18481
18482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18483 write!(formatter, "expected one of: {:?}", &FIELDS)
18484 }
18485
18486 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18487 where
18488 E: serde::de::Error,
18489 {
18490 i32::try_from(v)
18491 .ok()
18492 .and_then(|x| x.try_into().ok())
18493 .ok_or_else(|| {
18494 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18495 })
18496 }
18497
18498 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18499 where
18500 E: serde::de::Error,
18501 {
18502 i32::try_from(v)
18503 .ok()
18504 .and_then(|x| x.try_into().ok())
18505 .ok_or_else(|| {
18506 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18507 })
18508 }
18509
18510 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18511 where
18512 E: serde::de::Error,
18513 {
18514 match value {
18515 "UNSPECIFIED" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Unspecified),
18516 "ENABLED" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Enabled),
18517 "DISABLED" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Disabled),
18518 "STREAMING" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Streaming),
18519 "SERVING" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Serving),
18520 "BOTH" => Ok(table_cache_refill_policies::table_cache_refill_policy::CacheRefillPolicy::Both),
18521 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18522 }
18523 }
18524 }
18525 deserializer.deserialize_any(GeneratedVisitor)
18526 }
18527}
18528impl serde::Serialize for TableFragments {
18529 #[allow(deprecated)]
18530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18531 where
18532 S: serde::Serializer,
18533 {
18534 use serde::ser::SerializeStruct;
18535 let mut len = 0;
18536 if self.table_id != 0 {
18537 len += 1;
18538 }
18539 if self.state != 0 {
18540 len += 1;
18541 }
18542 if !self.fragments.is_empty() {
18543 len += 1;
18544 }
18545 if !self.actor_status.is_empty() {
18546 len += 1;
18547 }
18548 if self.ctx.is_some() {
18549 len += 1;
18550 }
18551 if self.max_parallelism.is_some() {
18552 len += 1;
18553 }
18554 if !self.node_label.is_empty() {
18555 len += 1;
18556 }
18557 if self.backfill_done {
18558 len += 1;
18559 }
18560 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
18561 if self.table_id != 0 {
18562 struct_ser.serialize_field("tableId", &self.table_id)?;
18563 }
18564 if self.state != 0 {
18565 let v = table_fragments::State::try_from(self.state)
18566 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
18567 struct_ser.serialize_field("state", &v)?;
18568 }
18569 if !self.fragments.is_empty() {
18570 struct_ser.serialize_field("fragments", &self.fragments)?;
18571 }
18572 if !self.actor_status.is_empty() {
18573 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
18574 }
18575 if let Some(v) = self.ctx.as_ref() {
18576 struct_ser.serialize_field("ctx", v)?;
18577 }
18578 if let Some(v) = self.max_parallelism.as_ref() {
18579 struct_ser.serialize_field("maxParallelism", v)?;
18580 }
18581 if !self.node_label.is_empty() {
18582 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
18583 }
18584 if self.backfill_done {
18585 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
18586 }
18587 struct_ser.end()
18588 }
18589}
18590impl<'de> serde::Deserialize<'de> for TableFragments {
18591 #[allow(deprecated)]
18592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18593 where
18594 D: serde::Deserializer<'de>,
18595 {
18596 const FIELDS: &[&str] = &[
18597 "table_id",
18598 "tableId",
18599 "state",
18600 "fragments",
18601 "actor_status",
18602 "actorStatus",
18603 "ctx",
18604 "max_parallelism",
18605 "maxParallelism",
18606 "node_label",
18607 "nodeLabel",
18608 "backfill_done",
18609 "backfillDone",
18610 ];
18611
18612 #[allow(clippy::enum_variant_names)]
18613 enum GeneratedField {
18614 TableId,
18615 State,
18616 Fragments,
18617 ActorStatus,
18618 Ctx,
18619 MaxParallelism,
18620 NodeLabel,
18621 BackfillDone,
18622 }
18623 impl<'de> serde::Deserialize<'de> for GeneratedField {
18624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18625 where
18626 D: serde::Deserializer<'de>,
18627 {
18628 struct GeneratedVisitor;
18629
18630 impl serde::de::Visitor<'_> for GeneratedVisitor {
18631 type Value = GeneratedField;
18632
18633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18634 write!(formatter, "expected one of: {:?}", &FIELDS)
18635 }
18636
18637 #[allow(unused_variables)]
18638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18639 where
18640 E: serde::de::Error,
18641 {
18642 match value {
18643 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18644 "state" => Ok(GeneratedField::State),
18645 "fragments" => Ok(GeneratedField::Fragments),
18646 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
18647 "ctx" => Ok(GeneratedField::Ctx),
18648 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
18649 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18650 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
18651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18652 }
18653 }
18654 }
18655 deserializer.deserialize_identifier(GeneratedVisitor)
18656 }
18657 }
18658 struct GeneratedVisitor;
18659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18660 type Value = TableFragments;
18661
18662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18663 formatter.write_str("struct meta.TableFragments")
18664 }
18665
18666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
18667 where
18668 V: serde::de::MapAccess<'de>,
18669 {
18670 let mut table_id__ = None;
18671 let mut state__ = None;
18672 let mut fragments__ = None;
18673 let mut actor_status__ = None;
18674 let mut ctx__ = None;
18675 let mut max_parallelism__ = None;
18676 let mut node_label__ = None;
18677 let mut backfill_done__ = None;
18678 while let Some(k) = map_.next_key()? {
18679 match k {
18680 GeneratedField::TableId => {
18681 if table_id__.is_some() {
18682 return Err(serde::de::Error::duplicate_field("tableId"));
18683 }
18684 table_id__ =
18685 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18686 ;
18687 }
18688 GeneratedField::State => {
18689 if state__.is_some() {
18690 return Err(serde::de::Error::duplicate_field("state"));
18691 }
18692 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
18693 }
18694 GeneratedField::Fragments => {
18695 if fragments__.is_some() {
18696 return Err(serde::de::Error::duplicate_field("fragments"));
18697 }
18698 fragments__ = Some(
18699 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18700 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18701 );
18702 }
18703 GeneratedField::ActorStatus => {
18704 if actor_status__.is_some() {
18705 return Err(serde::de::Error::duplicate_field("actorStatus"));
18706 }
18707 actor_status__ = Some(
18708 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18709 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18710 );
18711 }
18712 GeneratedField::Ctx => {
18713 if ctx__.is_some() {
18714 return Err(serde::de::Error::duplicate_field("ctx"));
18715 }
18716 ctx__ = map_.next_value()?;
18717 }
18718 GeneratedField::MaxParallelism => {
18719 if max_parallelism__.is_some() {
18720 return Err(serde::de::Error::duplicate_field("maxParallelism"));
18721 }
18722 max_parallelism__ =
18723 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18724 ;
18725 }
18726 GeneratedField::NodeLabel => {
18727 if node_label__.is_some() {
18728 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18729 }
18730 node_label__ = Some(map_.next_value()?);
18731 }
18732 GeneratedField::BackfillDone => {
18733 if backfill_done__.is_some() {
18734 return Err(serde::de::Error::duplicate_field("backfillDone"));
18735 }
18736 backfill_done__ = Some(map_.next_value()?);
18737 }
18738 }
18739 }
18740 Ok(TableFragments {
18741 table_id: table_id__.unwrap_or_default(),
18742 state: state__.unwrap_or_default(),
18743 fragments: fragments__.unwrap_or_default(),
18744 actor_status: actor_status__.unwrap_or_default(),
18745 ctx: ctx__,
18746 max_parallelism: max_parallelism__,
18747 node_label: node_label__.unwrap_or_default(),
18748 backfill_done: backfill_done__.unwrap_or_default(),
18749 })
18750 }
18751 }
18752 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
18753 }
18754}
18755impl serde::Serialize for table_fragments::ActorStatus {
18756 #[allow(deprecated)]
18757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18758 where
18759 S: serde::Serializer,
18760 {
18761 use serde::ser::SerializeStruct;
18762 let mut len = 0;
18763 if self.location.is_some() {
18764 len += 1;
18765 }
18766 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
18767 if let Some(v) = self.location.as_ref() {
18768 struct_ser.serialize_field("location", v)?;
18769 }
18770 struct_ser.end()
18771 }
18772}
18773impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
18774 #[allow(deprecated)]
18775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18776 where
18777 D: serde::Deserializer<'de>,
18778 {
18779 const FIELDS: &[&str] = &[
18780 "location",
18781 ];
18782
18783 #[allow(clippy::enum_variant_names)]
18784 enum GeneratedField {
18785 Location,
18786 }
18787 impl<'de> serde::Deserialize<'de> for GeneratedField {
18788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18789 where
18790 D: serde::Deserializer<'de>,
18791 {
18792 struct GeneratedVisitor;
18793
18794 impl serde::de::Visitor<'_> for GeneratedVisitor {
18795 type Value = GeneratedField;
18796
18797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18798 write!(formatter, "expected one of: {:?}", &FIELDS)
18799 }
18800
18801 #[allow(unused_variables)]
18802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18803 where
18804 E: serde::de::Error,
18805 {
18806 match value {
18807 "location" => Ok(GeneratedField::Location),
18808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18809 }
18810 }
18811 }
18812 deserializer.deserialize_identifier(GeneratedVisitor)
18813 }
18814 }
18815 struct GeneratedVisitor;
18816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18817 type Value = table_fragments::ActorStatus;
18818
18819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18820 formatter.write_str("struct meta.TableFragments.ActorStatus")
18821 }
18822
18823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
18824 where
18825 V: serde::de::MapAccess<'de>,
18826 {
18827 let mut location__ = None;
18828 while let Some(k) = map_.next_key()? {
18829 match k {
18830 GeneratedField::Location => {
18831 if location__.is_some() {
18832 return Err(serde::de::Error::duplicate_field("location"));
18833 }
18834 location__ = map_.next_value()?;
18835 }
18836 }
18837 }
18838 Ok(table_fragments::ActorStatus {
18839 location: location__,
18840 })
18841 }
18842 }
18843 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
18844 }
18845}
18846impl serde::Serialize for table_fragments::Fragment {
18847 #[allow(deprecated)]
18848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18849 where
18850 S: serde::Serializer,
18851 {
18852 use serde::ser::SerializeStruct;
18853 let mut len = 0;
18854 if self.fragment_id != 0 {
18855 len += 1;
18856 }
18857 if self.fragment_type_mask != 0 {
18858 len += 1;
18859 }
18860 if self.distribution_type != 0 {
18861 len += 1;
18862 }
18863 if !self.actors.is_empty() {
18864 len += 1;
18865 }
18866 if !self.state_table_ids.is_empty() {
18867 len += 1;
18868 }
18869 if !self.upstream_fragment_ids.is_empty() {
18870 len += 1;
18871 }
18872 if self.maybe_vnode_count.is_some() {
18873 len += 1;
18874 }
18875 if self.nodes.is_some() {
18876 len += 1;
18877 }
18878 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
18879 if self.fragment_id != 0 {
18880 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
18881 }
18882 if self.fragment_type_mask != 0 {
18883 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
18884 }
18885 if self.distribution_type != 0 {
18886 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
18887 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
18888 struct_ser.serialize_field("distributionType", &v)?;
18889 }
18890 if !self.actors.is_empty() {
18891 struct_ser.serialize_field("actors", &self.actors)?;
18892 }
18893 if !self.state_table_ids.is_empty() {
18894 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
18895 }
18896 if !self.upstream_fragment_ids.is_empty() {
18897 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
18898 }
18899 if let Some(v) = self.maybe_vnode_count.as_ref() {
18900 struct_ser.serialize_field("maybeVnodeCount", v)?;
18901 }
18902 if let Some(v) = self.nodes.as_ref() {
18903 struct_ser.serialize_field("nodes", v)?;
18904 }
18905 struct_ser.end()
18906 }
18907}
18908impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
18909 #[allow(deprecated)]
18910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18911 where
18912 D: serde::Deserializer<'de>,
18913 {
18914 const FIELDS: &[&str] = &[
18915 "fragment_id",
18916 "fragmentId",
18917 "fragment_type_mask",
18918 "fragmentTypeMask",
18919 "distribution_type",
18920 "distributionType",
18921 "actors",
18922 "state_table_ids",
18923 "stateTableIds",
18924 "upstream_fragment_ids",
18925 "upstreamFragmentIds",
18926 "maybe_vnode_count",
18927 "maybeVnodeCount",
18928 "nodes",
18929 ];
18930
18931 #[allow(clippy::enum_variant_names)]
18932 enum GeneratedField {
18933 FragmentId,
18934 FragmentTypeMask,
18935 DistributionType,
18936 Actors,
18937 StateTableIds,
18938 UpstreamFragmentIds,
18939 MaybeVnodeCount,
18940 Nodes,
18941 }
18942 impl<'de> serde::Deserialize<'de> for GeneratedField {
18943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18944 where
18945 D: serde::Deserializer<'de>,
18946 {
18947 struct GeneratedVisitor;
18948
18949 impl serde::de::Visitor<'_> for GeneratedVisitor {
18950 type Value = GeneratedField;
18951
18952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18953 write!(formatter, "expected one of: {:?}", &FIELDS)
18954 }
18955
18956 #[allow(unused_variables)]
18957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18958 where
18959 E: serde::de::Error,
18960 {
18961 match value {
18962 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
18963 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
18964 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
18965 "actors" => Ok(GeneratedField::Actors),
18966 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
18967 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
18968 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
18969 "nodes" => Ok(GeneratedField::Nodes),
18970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18971 }
18972 }
18973 }
18974 deserializer.deserialize_identifier(GeneratedVisitor)
18975 }
18976 }
18977 struct GeneratedVisitor;
18978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18979 type Value = table_fragments::Fragment;
18980
18981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18982 formatter.write_str("struct meta.TableFragments.Fragment")
18983 }
18984
18985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
18986 where
18987 V: serde::de::MapAccess<'de>,
18988 {
18989 let mut fragment_id__ = None;
18990 let mut fragment_type_mask__ = None;
18991 let mut distribution_type__ = None;
18992 let mut actors__ = None;
18993 let mut state_table_ids__ = None;
18994 let mut upstream_fragment_ids__ = None;
18995 let mut maybe_vnode_count__ = None;
18996 let mut nodes__ = None;
18997 while let Some(k) = map_.next_key()? {
18998 match k {
18999 GeneratedField::FragmentId => {
19000 if fragment_id__.is_some() {
19001 return Err(serde::de::Error::duplicate_field("fragmentId"));
19002 }
19003 fragment_id__ =
19004 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19005 ;
19006 }
19007 GeneratedField::FragmentTypeMask => {
19008 if fragment_type_mask__.is_some() {
19009 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
19010 }
19011 fragment_type_mask__ =
19012 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19013 ;
19014 }
19015 GeneratedField::DistributionType => {
19016 if distribution_type__.is_some() {
19017 return Err(serde::de::Error::duplicate_field("distributionType"));
19018 }
19019 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
19020 }
19021 GeneratedField::Actors => {
19022 if actors__.is_some() {
19023 return Err(serde::de::Error::duplicate_field("actors"));
19024 }
19025 actors__ = Some(map_.next_value()?);
19026 }
19027 GeneratedField::StateTableIds => {
19028 if state_table_ids__.is_some() {
19029 return Err(serde::de::Error::duplicate_field("stateTableIds"));
19030 }
19031 state_table_ids__ =
19032 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19033 .into_iter().map(|x| x.0).collect())
19034 ;
19035 }
19036 GeneratedField::UpstreamFragmentIds => {
19037 if upstream_fragment_ids__.is_some() {
19038 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
19039 }
19040 upstream_fragment_ids__ =
19041 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19042 .into_iter().map(|x| x.0).collect())
19043 ;
19044 }
19045 GeneratedField::MaybeVnodeCount => {
19046 if maybe_vnode_count__.is_some() {
19047 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
19048 }
19049 maybe_vnode_count__ =
19050 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19051 ;
19052 }
19053 GeneratedField::Nodes => {
19054 if nodes__.is_some() {
19055 return Err(serde::de::Error::duplicate_field("nodes"));
19056 }
19057 nodes__ = map_.next_value()?;
19058 }
19059 }
19060 }
19061 Ok(table_fragments::Fragment {
19062 fragment_id: fragment_id__.unwrap_or_default(),
19063 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
19064 distribution_type: distribution_type__.unwrap_or_default(),
19065 actors: actors__.unwrap_or_default(),
19066 state_table_ids: state_table_ids__.unwrap_or_default(),
19067 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
19068 maybe_vnode_count: maybe_vnode_count__,
19069 nodes: nodes__,
19070 })
19071 }
19072 }
19073 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
19074 }
19075}
19076impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
19077 #[allow(deprecated)]
19078 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19079 where
19080 S: serde::Serializer,
19081 {
19082 let variant = match self {
19083 Self::Unspecified => "UNSPECIFIED",
19084 Self::Single => "SINGLE",
19085 Self::Hash => "HASH",
19086 };
19087 serializer.serialize_str(variant)
19088 }
19089}
19090impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
19091 #[allow(deprecated)]
19092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19093 where
19094 D: serde::Deserializer<'de>,
19095 {
19096 const FIELDS: &[&str] = &[
19097 "UNSPECIFIED",
19098 "SINGLE",
19099 "HASH",
19100 ];
19101
19102 struct GeneratedVisitor;
19103
19104 impl serde::de::Visitor<'_> for GeneratedVisitor {
19105 type Value = table_fragments::fragment::FragmentDistributionType;
19106
19107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19108 write!(formatter, "expected one of: {:?}", &FIELDS)
19109 }
19110
19111 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19112 where
19113 E: serde::de::Error,
19114 {
19115 i32::try_from(v)
19116 .ok()
19117 .and_then(|x| x.try_into().ok())
19118 .ok_or_else(|| {
19119 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19120 })
19121 }
19122
19123 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19124 where
19125 E: serde::de::Error,
19126 {
19127 i32::try_from(v)
19128 .ok()
19129 .and_then(|x| x.try_into().ok())
19130 .ok_or_else(|| {
19131 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19132 })
19133 }
19134
19135 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19136 where
19137 E: serde::de::Error,
19138 {
19139 match value {
19140 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
19141 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
19142 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
19143 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19144 }
19145 }
19146 }
19147 deserializer.deserialize_any(GeneratedVisitor)
19148 }
19149}
19150impl serde::Serialize for table_fragments::State {
19151 #[allow(deprecated)]
19152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19153 where
19154 S: serde::Serializer,
19155 {
19156 let variant = match self {
19157 Self::Unspecified => "UNSPECIFIED",
19158 Self::Initial => "INITIAL",
19159 Self::Creating => "CREATING",
19160 Self::Created => "CREATED",
19161 };
19162 serializer.serialize_str(variant)
19163 }
19164}
19165impl<'de> serde::Deserialize<'de> for table_fragments::State {
19166 #[allow(deprecated)]
19167 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19168 where
19169 D: serde::Deserializer<'de>,
19170 {
19171 const FIELDS: &[&str] = &[
19172 "UNSPECIFIED",
19173 "INITIAL",
19174 "CREATING",
19175 "CREATED",
19176 ];
19177
19178 struct GeneratedVisitor;
19179
19180 impl serde::de::Visitor<'_> for GeneratedVisitor {
19181 type Value = table_fragments::State;
19182
19183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19184 write!(formatter, "expected one of: {:?}", &FIELDS)
19185 }
19186
19187 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19188 where
19189 E: serde::de::Error,
19190 {
19191 i32::try_from(v)
19192 .ok()
19193 .and_then(|x| x.try_into().ok())
19194 .ok_or_else(|| {
19195 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19196 })
19197 }
19198
19199 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19200 where
19201 E: serde::de::Error,
19202 {
19203 i32::try_from(v)
19204 .ok()
19205 .and_then(|x| x.try_into().ok())
19206 .ok_or_else(|| {
19207 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19208 })
19209 }
19210
19211 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19212 where
19213 E: serde::de::Error,
19214 {
19215 match value {
19216 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
19217 "INITIAL" => Ok(table_fragments::State::Initial),
19218 "CREATING" => Ok(table_fragments::State::Creating),
19219 "CREATED" => Ok(table_fragments::State::Created),
19220 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19221 }
19222 }
19223 }
19224 deserializer.deserialize_any(GeneratedVisitor)
19225 }
19226}
19227impl serde::Serialize for TableParallelism {
19228 #[allow(deprecated)]
19229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19230 where
19231 S: serde::Serializer,
19232 {
19233 use serde::ser::SerializeStruct;
19234 let mut len = 0;
19235 if self.parallelism.is_some() {
19236 len += 1;
19237 }
19238 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
19239 if let Some(v) = self.parallelism.as_ref() {
19240 match v {
19241 table_parallelism::Parallelism::Fixed(v) => {
19242 struct_ser.serialize_field("fixed", v)?;
19243 }
19244 table_parallelism::Parallelism::Auto(v) => {
19245 struct_ser.serialize_field("auto", v)?;
19246 }
19247 table_parallelism::Parallelism::Custom(v) => {
19248 struct_ser.serialize_field("custom", v)?;
19249 }
19250 table_parallelism::Parallelism::Adaptive(v) => {
19251 struct_ser.serialize_field("adaptive", v)?;
19252 }
19253 }
19254 }
19255 struct_ser.end()
19256 }
19257}
19258impl<'de> serde::Deserialize<'de> for TableParallelism {
19259 #[allow(deprecated)]
19260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19261 where
19262 D: serde::Deserializer<'de>,
19263 {
19264 const FIELDS: &[&str] = &[
19265 "fixed",
19266 "auto",
19267 "custom",
19268 "adaptive",
19269 ];
19270
19271 #[allow(clippy::enum_variant_names)]
19272 enum GeneratedField {
19273 Fixed,
19274 Auto,
19275 Custom,
19276 Adaptive,
19277 }
19278 impl<'de> serde::Deserialize<'de> for GeneratedField {
19279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19280 where
19281 D: serde::Deserializer<'de>,
19282 {
19283 struct GeneratedVisitor;
19284
19285 impl serde::de::Visitor<'_> for GeneratedVisitor {
19286 type Value = GeneratedField;
19287
19288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19289 write!(formatter, "expected one of: {:?}", &FIELDS)
19290 }
19291
19292 #[allow(unused_variables)]
19293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19294 where
19295 E: serde::de::Error,
19296 {
19297 match value {
19298 "fixed" => Ok(GeneratedField::Fixed),
19299 "auto" => Ok(GeneratedField::Auto),
19300 "custom" => Ok(GeneratedField::Custom),
19301 "adaptive" => Ok(GeneratedField::Adaptive),
19302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19303 }
19304 }
19305 }
19306 deserializer.deserialize_identifier(GeneratedVisitor)
19307 }
19308 }
19309 struct GeneratedVisitor;
19310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19311 type Value = TableParallelism;
19312
19313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19314 formatter.write_str("struct meta.TableParallelism")
19315 }
19316
19317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
19318 where
19319 V: serde::de::MapAccess<'de>,
19320 {
19321 let mut parallelism__ = None;
19322 while let Some(k) = map_.next_key()? {
19323 match k {
19324 GeneratedField::Fixed => {
19325 if parallelism__.is_some() {
19326 return Err(serde::de::Error::duplicate_field("fixed"));
19327 }
19328 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
19329;
19330 }
19331 GeneratedField::Auto => {
19332 if parallelism__.is_some() {
19333 return Err(serde::de::Error::duplicate_field("auto"));
19334 }
19335 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
19336;
19337 }
19338 GeneratedField::Custom => {
19339 if parallelism__.is_some() {
19340 return Err(serde::de::Error::duplicate_field("custom"));
19341 }
19342 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
19343;
19344 }
19345 GeneratedField::Adaptive => {
19346 if parallelism__.is_some() {
19347 return Err(serde::de::Error::duplicate_field("adaptive"));
19348 }
19349 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
19350;
19351 }
19352 }
19353 }
19354 Ok(TableParallelism {
19355 parallelism: parallelism__,
19356 })
19357 }
19358 }
19359 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
19360 }
19361}
19362impl serde::Serialize for table_parallelism::AdaptiveParallelism {
19363 #[allow(deprecated)]
19364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19365 where
19366 S: serde::Serializer,
19367 {
19368 use serde::ser::SerializeStruct;
19369 let len = 0;
19370 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
19371 struct_ser.end()
19372 }
19373}
19374impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
19375 #[allow(deprecated)]
19376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19377 where
19378 D: serde::Deserializer<'de>,
19379 {
19380 const FIELDS: &[&str] = &[
19381 ];
19382
19383 #[allow(clippy::enum_variant_names)]
19384 enum GeneratedField {
19385 }
19386 impl<'de> serde::Deserialize<'de> for GeneratedField {
19387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19388 where
19389 D: serde::Deserializer<'de>,
19390 {
19391 struct GeneratedVisitor;
19392
19393 impl serde::de::Visitor<'_> for GeneratedVisitor {
19394 type Value = GeneratedField;
19395
19396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19397 write!(formatter, "expected one of: {:?}", &FIELDS)
19398 }
19399
19400 #[allow(unused_variables)]
19401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19402 where
19403 E: serde::de::Error,
19404 {
19405 Err(serde::de::Error::unknown_field(value, FIELDS))
19406 }
19407 }
19408 deserializer.deserialize_identifier(GeneratedVisitor)
19409 }
19410 }
19411 struct GeneratedVisitor;
19412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19413 type Value = table_parallelism::AdaptiveParallelism;
19414
19415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19416 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
19417 }
19418
19419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
19420 where
19421 V: serde::de::MapAccess<'de>,
19422 {
19423 while map_.next_key::<GeneratedField>()?.is_some() {
19424 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19425 }
19426 Ok(table_parallelism::AdaptiveParallelism {
19427 })
19428 }
19429 }
19430 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
19431 }
19432}
19433impl serde::Serialize for table_parallelism::AutoParallelism {
19434 #[allow(deprecated)]
19435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19436 where
19437 S: serde::Serializer,
19438 {
19439 use serde::ser::SerializeStruct;
19440 let len = 0;
19441 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
19442 struct_ser.end()
19443 }
19444}
19445impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
19446 #[allow(deprecated)]
19447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19448 where
19449 D: serde::Deserializer<'de>,
19450 {
19451 const FIELDS: &[&str] = &[
19452 ];
19453
19454 #[allow(clippy::enum_variant_names)]
19455 enum GeneratedField {
19456 }
19457 impl<'de> serde::Deserialize<'de> for GeneratedField {
19458 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19459 where
19460 D: serde::Deserializer<'de>,
19461 {
19462 struct GeneratedVisitor;
19463
19464 impl serde::de::Visitor<'_> for GeneratedVisitor {
19465 type Value = GeneratedField;
19466
19467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19468 write!(formatter, "expected one of: {:?}", &FIELDS)
19469 }
19470
19471 #[allow(unused_variables)]
19472 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19473 where
19474 E: serde::de::Error,
19475 {
19476 Err(serde::de::Error::unknown_field(value, FIELDS))
19477 }
19478 }
19479 deserializer.deserialize_identifier(GeneratedVisitor)
19480 }
19481 }
19482 struct GeneratedVisitor;
19483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19484 type Value = table_parallelism::AutoParallelism;
19485
19486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19487 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
19488 }
19489
19490 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
19491 where
19492 V: serde::de::MapAccess<'de>,
19493 {
19494 while map_.next_key::<GeneratedField>()?.is_some() {
19495 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19496 }
19497 Ok(table_parallelism::AutoParallelism {
19498 })
19499 }
19500 }
19501 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
19502 }
19503}
19504impl serde::Serialize for table_parallelism::CustomParallelism {
19505 #[allow(deprecated)]
19506 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19507 where
19508 S: serde::Serializer,
19509 {
19510 use serde::ser::SerializeStruct;
19511 let len = 0;
19512 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
19513 struct_ser.end()
19514 }
19515}
19516impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
19517 #[allow(deprecated)]
19518 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19519 where
19520 D: serde::Deserializer<'de>,
19521 {
19522 const FIELDS: &[&str] = &[
19523 ];
19524
19525 #[allow(clippy::enum_variant_names)]
19526 enum GeneratedField {
19527 }
19528 impl<'de> serde::Deserialize<'de> for GeneratedField {
19529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19530 where
19531 D: serde::Deserializer<'de>,
19532 {
19533 struct GeneratedVisitor;
19534
19535 impl serde::de::Visitor<'_> for GeneratedVisitor {
19536 type Value = GeneratedField;
19537
19538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19539 write!(formatter, "expected one of: {:?}", &FIELDS)
19540 }
19541
19542 #[allow(unused_variables)]
19543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19544 where
19545 E: serde::de::Error,
19546 {
19547 Err(serde::de::Error::unknown_field(value, FIELDS))
19548 }
19549 }
19550 deserializer.deserialize_identifier(GeneratedVisitor)
19551 }
19552 }
19553 struct GeneratedVisitor;
19554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19555 type Value = table_parallelism::CustomParallelism;
19556
19557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19558 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
19559 }
19560
19561 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
19562 where
19563 V: serde::de::MapAccess<'de>,
19564 {
19565 while map_.next_key::<GeneratedField>()?.is_some() {
19566 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19567 }
19568 Ok(table_parallelism::CustomParallelism {
19569 })
19570 }
19571 }
19572 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
19573 }
19574}
19575impl serde::Serialize for table_parallelism::FixedParallelism {
19576 #[allow(deprecated)]
19577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19578 where
19579 S: serde::Serializer,
19580 {
19581 use serde::ser::SerializeStruct;
19582 let mut len = 0;
19583 if self.parallelism != 0 {
19584 len += 1;
19585 }
19586 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
19587 if self.parallelism != 0 {
19588 struct_ser.serialize_field("parallelism", &self.parallelism)?;
19589 }
19590 struct_ser.end()
19591 }
19592}
19593impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
19594 #[allow(deprecated)]
19595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19596 where
19597 D: serde::Deserializer<'de>,
19598 {
19599 const FIELDS: &[&str] = &[
19600 "parallelism",
19601 ];
19602
19603 #[allow(clippy::enum_variant_names)]
19604 enum GeneratedField {
19605 Parallelism,
19606 }
19607 impl<'de> serde::Deserialize<'de> for GeneratedField {
19608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19609 where
19610 D: serde::Deserializer<'de>,
19611 {
19612 struct GeneratedVisitor;
19613
19614 impl serde::de::Visitor<'_> for GeneratedVisitor {
19615 type Value = GeneratedField;
19616
19617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19618 write!(formatter, "expected one of: {:?}", &FIELDS)
19619 }
19620
19621 #[allow(unused_variables)]
19622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19623 where
19624 E: serde::de::Error,
19625 {
19626 match value {
19627 "parallelism" => Ok(GeneratedField::Parallelism),
19628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19629 }
19630 }
19631 }
19632 deserializer.deserialize_identifier(GeneratedVisitor)
19633 }
19634 }
19635 struct GeneratedVisitor;
19636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19637 type Value = table_parallelism::FixedParallelism;
19638
19639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19640 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
19641 }
19642
19643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
19644 where
19645 V: serde::de::MapAccess<'de>,
19646 {
19647 let mut parallelism__ = None;
19648 while let Some(k) = map_.next_key()? {
19649 match k {
19650 GeneratedField::Parallelism => {
19651 if parallelism__.is_some() {
19652 return Err(serde::de::Error::duplicate_field("parallelism"));
19653 }
19654 parallelism__ =
19655 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19656 ;
19657 }
19658 }
19659 }
19660 Ok(table_parallelism::FixedParallelism {
19661 parallelism: parallelism__.unwrap_or_default(),
19662 })
19663 }
19664 }
19665 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
19666 }
19667}
19668impl serde::Serialize for TableRefillRuntimeConfig {
19669 #[allow(deprecated)]
19670 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19671 where
19672 S: serde::Serializer,
19673 {
19674 use serde::ser::SerializeStruct;
19675 let mut len = 0;
19676 if self.table_cache_refill_policies.is_some() {
19677 len += 1;
19678 }
19679 if self.serving_table_vnode_mappings.is_some() {
19680 len += 1;
19681 }
19682 if self.version != 0 {
19683 len += 1;
19684 }
19685 let mut struct_ser = serializer.serialize_struct("meta.TableRefillRuntimeConfig", len)?;
19686 if let Some(v) = self.table_cache_refill_policies.as_ref() {
19687 struct_ser.serialize_field("tableCacheRefillPolicies", v)?;
19688 }
19689 if let Some(v) = self.serving_table_vnode_mappings.as_ref() {
19690 struct_ser.serialize_field("servingTableVnodeMappings", v)?;
19691 }
19692 if self.version != 0 {
19693 #[allow(clippy::needless_borrow)]
19694 #[allow(clippy::needless_borrows_for_generic_args)]
19695 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
19696 }
19697 struct_ser.end()
19698 }
19699}
19700impl<'de> serde::Deserialize<'de> for TableRefillRuntimeConfig {
19701 #[allow(deprecated)]
19702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19703 where
19704 D: serde::Deserializer<'de>,
19705 {
19706 const FIELDS: &[&str] = &[
19707 "table_cache_refill_policies",
19708 "tableCacheRefillPolicies",
19709 "serving_table_vnode_mappings",
19710 "servingTableVnodeMappings",
19711 "version",
19712 ];
19713
19714 #[allow(clippy::enum_variant_names)]
19715 enum GeneratedField {
19716 TableCacheRefillPolicies,
19717 ServingTableVnodeMappings,
19718 Version,
19719 }
19720 impl<'de> serde::Deserialize<'de> for GeneratedField {
19721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19722 where
19723 D: serde::Deserializer<'de>,
19724 {
19725 struct GeneratedVisitor;
19726
19727 impl serde::de::Visitor<'_> for GeneratedVisitor {
19728 type Value = GeneratedField;
19729
19730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19731 write!(formatter, "expected one of: {:?}", &FIELDS)
19732 }
19733
19734 #[allow(unused_variables)]
19735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19736 where
19737 E: serde::de::Error,
19738 {
19739 match value {
19740 "tableCacheRefillPolicies" | "table_cache_refill_policies" => Ok(GeneratedField::TableCacheRefillPolicies),
19741 "servingTableVnodeMappings" | "serving_table_vnode_mappings" => Ok(GeneratedField::ServingTableVnodeMappings),
19742 "version" => Ok(GeneratedField::Version),
19743 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19744 }
19745 }
19746 }
19747 deserializer.deserialize_identifier(GeneratedVisitor)
19748 }
19749 }
19750 struct GeneratedVisitor;
19751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19752 type Value = TableRefillRuntimeConfig;
19753
19754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19755 formatter.write_str("struct meta.TableRefillRuntimeConfig")
19756 }
19757
19758 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableRefillRuntimeConfig, V::Error>
19759 where
19760 V: serde::de::MapAccess<'de>,
19761 {
19762 let mut table_cache_refill_policies__ = None;
19763 let mut serving_table_vnode_mappings__ = None;
19764 let mut version__ = None;
19765 while let Some(k) = map_.next_key()? {
19766 match k {
19767 GeneratedField::TableCacheRefillPolicies => {
19768 if table_cache_refill_policies__.is_some() {
19769 return Err(serde::de::Error::duplicate_field("tableCacheRefillPolicies"));
19770 }
19771 table_cache_refill_policies__ = map_.next_value()?;
19772 }
19773 GeneratedField::ServingTableVnodeMappings => {
19774 if serving_table_vnode_mappings__.is_some() {
19775 return Err(serde::de::Error::duplicate_field("servingTableVnodeMappings"));
19776 }
19777 serving_table_vnode_mappings__ = map_.next_value()?;
19778 }
19779 GeneratedField::Version => {
19780 if version__.is_some() {
19781 return Err(serde::de::Error::duplicate_field("version"));
19782 }
19783 version__ =
19784 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19785 ;
19786 }
19787 }
19788 }
19789 Ok(TableRefillRuntimeConfig {
19790 table_cache_refill_policies: table_cache_refill_policies__,
19791 serving_table_vnode_mappings: serving_table_vnode_mappings__,
19792 version: version__.unwrap_or_default(),
19793 })
19794 }
19795 }
19796 deserializer.deserialize_struct("meta.TableRefillRuntimeConfig", FIELDS, GeneratedVisitor)
19797 }
19798}
19799impl serde::Serialize for TelemetryInfoResponse {
19800 #[allow(deprecated)]
19801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19802 where
19803 S: serde::Serializer,
19804 {
19805 use serde::ser::SerializeStruct;
19806 let mut len = 0;
19807 if self.tracking_id.is_some() {
19808 len += 1;
19809 }
19810 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
19811 if let Some(v) = self.tracking_id.as_ref() {
19812 struct_ser.serialize_field("trackingId", v)?;
19813 }
19814 struct_ser.end()
19815 }
19816}
19817impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
19818 #[allow(deprecated)]
19819 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19820 where
19821 D: serde::Deserializer<'de>,
19822 {
19823 const FIELDS: &[&str] = &[
19824 "tracking_id",
19825 "trackingId",
19826 ];
19827
19828 #[allow(clippy::enum_variant_names)]
19829 enum GeneratedField {
19830 TrackingId,
19831 }
19832 impl<'de> serde::Deserialize<'de> for GeneratedField {
19833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19834 where
19835 D: serde::Deserializer<'de>,
19836 {
19837 struct GeneratedVisitor;
19838
19839 impl serde::de::Visitor<'_> for GeneratedVisitor {
19840 type Value = GeneratedField;
19841
19842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19843 write!(formatter, "expected one of: {:?}", &FIELDS)
19844 }
19845
19846 #[allow(unused_variables)]
19847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19848 where
19849 E: serde::de::Error,
19850 {
19851 match value {
19852 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
19853 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19854 }
19855 }
19856 }
19857 deserializer.deserialize_identifier(GeneratedVisitor)
19858 }
19859 }
19860 struct GeneratedVisitor;
19861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19862 type Value = TelemetryInfoResponse;
19863
19864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19865 formatter.write_str("struct meta.TelemetryInfoResponse")
19866 }
19867
19868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
19869 where
19870 V: serde::de::MapAccess<'de>,
19871 {
19872 let mut tracking_id__ = None;
19873 while let Some(k) = map_.next_key()? {
19874 match k {
19875 GeneratedField::TrackingId => {
19876 if tracking_id__.is_some() {
19877 return Err(serde::de::Error::duplicate_field("trackingId"));
19878 }
19879 tracking_id__ = map_.next_value()?;
19880 }
19881 }
19882 }
19883 Ok(TelemetryInfoResponse {
19884 tracking_id: tracking_id__,
19885 })
19886 }
19887 }
19888 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
19889 }
19890}
19891impl serde::Serialize for ThrottleTarget {
19892 #[allow(deprecated)]
19893 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19894 where
19895 S: serde::Serializer,
19896 {
19897 let variant = match self {
19898 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
19899 Self::Source => "SOURCE",
19900 Self::Mv => "MV",
19901 Self::Table => "TABLE",
19902 Self::Sink => "SINK",
19903 Self::Fragment => "FRAGMENT",
19904 };
19905 serializer.serialize_str(variant)
19906 }
19907}
19908impl<'de> serde::Deserialize<'de> for ThrottleTarget {
19909 #[allow(deprecated)]
19910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19911 where
19912 D: serde::Deserializer<'de>,
19913 {
19914 const FIELDS: &[&str] = &[
19915 "THROTTLE_TARGET_UNSPECIFIED",
19916 "SOURCE",
19917 "MV",
19918 "TABLE",
19919 "SINK",
19920 "FRAGMENT",
19921 ];
19922
19923 struct GeneratedVisitor;
19924
19925 impl serde::de::Visitor<'_> for GeneratedVisitor {
19926 type Value = ThrottleTarget;
19927
19928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19929 write!(formatter, "expected one of: {:?}", &FIELDS)
19930 }
19931
19932 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19933 where
19934 E: serde::de::Error,
19935 {
19936 i32::try_from(v)
19937 .ok()
19938 .and_then(|x| x.try_into().ok())
19939 .ok_or_else(|| {
19940 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19941 })
19942 }
19943
19944 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19945 where
19946 E: serde::de::Error,
19947 {
19948 i32::try_from(v)
19949 .ok()
19950 .and_then(|x| x.try_into().ok())
19951 .ok_or_else(|| {
19952 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19953 })
19954 }
19955
19956 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19957 where
19958 E: serde::de::Error,
19959 {
19960 match value {
19961 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
19962 "SOURCE" => Ok(ThrottleTarget::Source),
19963 "MV" => Ok(ThrottleTarget::Mv),
19964 "TABLE" => Ok(ThrottleTarget::Table),
19965 "SINK" => Ok(ThrottleTarget::Sink),
19966 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
19967 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19968 }
19969 }
19970 }
19971 deserializer.deserialize_any(GeneratedVisitor)
19972 }
19973}
19974impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
19975 #[allow(deprecated)]
19976 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19977 where
19978 S: serde::Serializer,
19979 {
19980 use serde::ser::SerializeStruct;
19981 let mut len = 0;
19982 if self.id != 0 {
19983 len += 1;
19984 }
19985 if !self.node_label.is_empty() {
19986 len += 1;
19987 }
19988 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
19989 if self.id != 0 {
19990 struct_ser.serialize_field("id", &self.id)?;
19991 }
19992 if !self.node_label.is_empty() {
19993 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
19994 }
19995 struct_ser.end()
19996 }
19997}
19998impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
19999 #[allow(deprecated)]
20000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20001 where
20002 D: serde::Deserializer<'de>,
20003 {
20004 const FIELDS: &[&str] = &[
20005 "id",
20006 "node_label",
20007 "nodeLabel",
20008 ];
20009
20010 #[allow(clippy::enum_variant_names)]
20011 enum GeneratedField {
20012 Id,
20013 NodeLabel,
20014 }
20015 impl<'de> serde::Deserialize<'de> for GeneratedField {
20016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20017 where
20018 D: serde::Deserializer<'de>,
20019 {
20020 struct GeneratedVisitor;
20021
20022 impl serde::de::Visitor<'_> for GeneratedVisitor {
20023 type Value = GeneratedField;
20024
20025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20026 write!(formatter, "expected one of: {:?}", &FIELDS)
20027 }
20028
20029 #[allow(unused_variables)]
20030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20031 where
20032 E: serde::de::Error,
20033 {
20034 match value {
20035 "id" => Ok(GeneratedField::Id),
20036 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
20037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20038 }
20039 }
20040 }
20041 deserializer.deserialize_identifier(GeneratedVisitor)
20042 }
20043 }
20044 struct GeneratedVisitor;
20045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20046 type Value = UpdateStreamingJobNodeLabelsRequest;
20047
20048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20049 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
20050 }
20051
20052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
20053 where
20054 V: serde::de::MapAccess<'de>,
20055 {
20056 let mut id__ = None;
20057 let mut node_label__ = None;
20058 while let Some(k) = map_.next_key()? {
20059 match k {
20060 GeneratedField::Id => {
20061 if id__.is_some() {
20062 return Err(serde::de::Error::duplicate_field("id"));
20063 }
20064 id__ =
20065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20066 ;
20067 }
20068 GeneratedField::NodeLabel => {
20069 if node_label__.is_some() {
20070 return Err(serde::de::Error::duplicate_field("nodeLabel"));
20071 }
20072 node_label__ = Some(map_.next_value()?);
20073 }
20074 }
20075 }
20076 Ok(UpdateStreamingJobNodeLabelsRequest {
20077 id: id__.unwrap_or_default(),
20078 node_label: node_label__.unwrap_or_default(),
20079 })
20080 }
20081 }
20082 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
20083 }
20084}
20085impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
20086 #[allow(deprecated)]
20087 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20088 where
20089 S: serde::Serializer,
20090 {
20091 use serde::ser::SerializeStruct;
20092 let len = 0;
20093 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
20094 struct_ser.end()
20095 }
20096}
20097impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
20098 #[allow(deprecated)]
20099 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20100 where
20101 D: serde::Deserializer<'de>,
20102 {
20103 const FIELDS: &[&str] = &[
20104 ];
20105
20106 #[allow(clippy::enum_variant_names)]
20107 enum GeneratedField {
20108 }
20109 impl<'de> serde::Deserialize<'de> for GeneratedField {
20110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20111 where
20112 D: serde::Deserializer<'de>,
20113 {
20114 struct GeneratedVisitor;
20115
20116 impl serde::de::Visitor<'_> for GeneratedVisitor {
20117 type Value = GeneratedField;
20118
20119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20120 write!(formatter, "expected one of: {:?}", &FIELDS)
20121 }
20122
20123 #[allow(unused_variables)]
20124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20125 where
20126 E: serde::de::Error,
20127 {
20128 Err(serde::de::Error::unknown_field(value, FIELDS))
20129 }
20130 }
20131 deserializer.deserialize_identifier(GeneratedVisitor)
20132 }
20133 }
20134 struct GeneratedVisitor;
20135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20136 type Value = UpdateStreamingJobNodeLabelsResponse;
20137
20138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20139 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
20140 }
20141
20142 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
20143 where
20144 V: serde::de::MapAccess<'de>,
20145 {
20146 while map_.next_key::<GeneratedField>()?.is_some() {
20147 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
20148 }
20149 Ok(UpdateStreamingJobNodeLabelsResponse {
20150 })
20151 }
20152 }
20153 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
20154 }
20155}
20156impl serde::Serialize for WorkerReschedule {
20157 #[allow(deprecated)]
20158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20159 where
20160 S: serde::Serializer,
20161 {
20162 use serde::ser::SerializeStruct;
20163 let mut len = 0;
20164 if !self.worker_actor_diff.is_empty() {
20165 len += 1;
20166 }
20167 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
20168 if !self.worker_actor_diff.is_empty() {
20169 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
20170 }
20171 struct_ser.end()
20172 }
20173}
20174impl<'de> serde::Deserialize<'de> for WorkerReschedule {
20175 #[allow(deprecated)]
20176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20177 where
20178 D: serde::Deserializer<'de>,
20179 {
20180 const FIELDS: &[&str] = &[
20181 "worker_actor_diff",
20182 "workerActorDiff",
20183 ];
20184
20185 #[allow(clippy::enum_variant_names)]
20186 enum GeneratedField {
20187 WorkerActorDiff,
20188 }
20189 impl<'de> serde::Deserialize<'de> for GeneratedField {
20190 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20191 where
20192 D: serde::Deserializer<'de>,
20193 {
20194 struct GeneratedVisitor;
20195
20196 impl serde::de::Visitor<'_> for GeneratedVisitor {
20197 type Value = GeneratedField;
20198
20199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20200 write!(formatter, "expected one of: {:?}", &FIELDS)
20201 }
20202
20203 #[allow(unused_variables)]
20204 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20205 where
20206 E: serde::de::Error,
20207 {
20208 match value {
20209 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
20210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20211 }
20212 }
20213 }
20214 deserializer.deserialize_identifier(GeneratedVisitor)
20215 }
20216 }
20217 struct GeneratedVisitor;
20218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20219 type Value = WorkerReschedule;
20220
20221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20222 formatter.write_str("struct meta.WorkerReschedule")
20223 }
20224
20225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
20226 where
20227 V: serde::de::MapAccess<'de>,
20228 {
20229 let mut worker_actor_diff__ = None;
20230 while let Some(k) = map_.next_key()? {
20231 match k {
20232 GeneratedField::WorkerActorDiff => {
20233 if worker_actor_diff__.is_some() {
20234 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
20235 }
20236 worker_actor_diff__ = Some(
20237 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
20238 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
20239 );
20240 }
20241 }
20242 }
20243 Ok(WorkerReschedule {
20244 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
20245 })
20246 }
20247 }
20248 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
20249 }
20250}